itkSpatialObject.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkSpatialObject_h
#define __itkSpatialObject_h

// Disable warning for lengthy symbol names in this file only

#include "itkAffineGeometryFrame.h"
#include "itkCovariantVector.h"
#include "itkExceptionObject.h"
#include <list>
#include "itkSpatialObjectProperty.h"
#include "itkProcessObject.h"
#include "itkIndex.h"
#include "itkImageRegion.h"
#include "itkSpatialObjectTreeNode.h"

namespace itk
{
template< unsigned int VDimension >
class SpatialObjectTreeNode;

template< unsigned int VDimension = 3 >
class SpatialObject:
  public DataObject
{
public:

  typedef double ScalarType;

  itkStaticConstMacro(MaximumDepth, unsigned int, 9999999);

  unsigned int GetMaximumDepth() const { return MaximumDepth; }

  typedef SpatialObject< VDimension > Self;
  typedef DataObject                  Superclass;

  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  typedef Point< ScalarType, VDimension > PointType;
  // Spatial Function Iterator needs the following typedef
  typedef Point< ScalarType, VDimension > InputType;
  typedef PointType *                     PointPointer;

  typedef Vector< ScalarType, VDimension >          VectorType;
  typedef CovariantVector< ScalarType, VDimension > CovariantVectorType;
  typedef VectorType *                              VectorPointer;

  typedef double *SpacingType;

  typedef CovariantVector< double, VDimension > OutputVectorType;
  typedef OutputVectorType *                    OutputVectorPointer;

  typedef ScalableAffineTransform< double, VDimension > TransformType;
  typedef typename TransformType::Pointer               TransformPointer;
  typedef const TransformType *                         TransformConstPointer;

  typedef VectorContainer< IdentifierType, PointType >  VectorContainerType;

  typedef BoundingBox< IdentifierType, VDimension, ScalarType, VectorContainerType > BoundingBoxType;
  typedef typename BoundingBoxType::Pointer                                          BoundingBoxPointer;

  typedef AffineGeometryFrame< double, VDimension > AffineGeometryFrameType;
  typedef typename AffineGeometryFrameType::Pointer AffineGeometryFramePointer;

  typedef std::list< Pointer > ChildrenListType;
  typedef ChildrenListType *   ChildrenListPointer;

  typedef Index< VDimension >                IndexType;

  typedef Offset< VDimension >                 OffsetType;
  typedef ImageRegion< VDimension >            RegionType;
  typedef Size< VDimension >                   SizeType;
  typedef SpatialObjectProperty< float >       PropertyType;
  typedef typename PropertyType::Pointer       PropertyPointer;

  typedef SpatialObjectTreeNode< VDimension > TreeNodeType;

  virtual bool HasParent(void) const;

  virtual const char * GetTypeName(void) const { return m_TypeName.c_str(); }

  itkStaticConstMacro(ObjectDimension, unsigned int, VDimension);

  unsigned int GetObjectDimension(void) const { return VDimension; }

  itkNewMacro(Self);

  itkTypeMacro(SpatialObject, DataObject);

  itkSetObjectMacro(AffineGeometryFrame, AffineGeometryFrameType);
  itkGetModifiableObjectMacro(AffineGeometryFrame, AffineGeometryFrameType);

  void SetObjectToWorldTransform(TransformType *transform);
  itkGetModifiableObjectMacro(ObjectToWorldTransform, TransformType);

  itkGetModifiableObjectMacro(IndexToWorldTransform, TransformType);

  void ComputeObjectToWorldTransform(void);

  void ComputeObjectToParentTransform(void);

  unsigned long GetTransformMTime(void);

  unsigned long GetWorldTransformMTime(void);

  virtual bool ValueAt(const PointType & point, double & value,
                       unsigned int depth = 0,
                       char *name = NULL) const;

  virtual bool IsEvaluableAt(const PointType & point,
                             unsigned int depth = 0,
                             char *name = NULL) const;

  virtual bool IsInside(const PointType & point,
                        unsigned int depth = 0,
                        char *name = NULL) const;

  bool Evaluate(const PointType & point) const
  {
    return this->IsInside(point);
  }

  virtual void DerivativeAt(const PointType & point,
                            short unsigned int order,
                            OutputVectorType & value,
                            unsigned int depth = 0,
                            char *name = NULL);

  ModifiedTimeType GetMTime(void) const;

  unsigned long GetObjectMTime(void) const
  {
    return Superclass::GetMTime();
  }

  virtual void SetLargestPossibleRegion(const RegionType & region);

  virtual const RegionType & GetLargestPossibleRegion() const
  { return m_LargestPossibleRegion; }

  virtual void SetBufferedRegion(const RegionType & region);

  virtual const RegionType & GetBufferedRegion() const
  { return m_BufferedRegion; }

  virtual void SetRequestedRegion(const RegionType & region);

  virtual void SetRequestedRegion(const DataObject *data);

  virtual const RegionType & GetRequestedRegion() const
  { return m_RequestedRegion; }

  const OffsetValueType * GetOffsetTable() const { return m_OffsetTable; }

  OffsetValueType ComputeOffset(const IndexType & ind) const
  {
    // need to add bounds checking for the region/buffer?
    OffsetValueType   offset = 0;
    const IndexType & bufferedRegionIndex = m_BufferedRegion.GetIndex();

    // data is arranged as [][][][slice][row][col]
    // with Index[0] = col, Index[1] = row, Index[2] = slice
    for ( int i = VDimension - 1; i > 0; i-- )
      {
      offset += ( ind[i] - bufferedRegionIndex[i] ) * m_OffsetTable[i];
      }
    offset += ( ind[0] - bufferedRegionIndex[0] );

    return offset;
  }

  IndexType ComputeIndex(OffsetValueType offset) const
  {
    IndexType         index;
    const IndexType & bufferedRegionIndex = m_BufferedRegion.GetIndex();

    for ( int i = VDimension - 1; i > 0; i-- )
      {
      index[i] = static_cast< IndexValueType >( offset / m_OffsetTable[i] );
      offset -= ( index[i] * m_OffsetTable[i] );
      index[i] += bufferedRegionIndex[i];
      }
    index[0] = bufferedRegionIndex[0] + static_cast< IndexValueType >( offset );

    return index;
  }

  virtual void CopyInformation(const DataObject *data);

  virtual void UpdateOutputInformation();

  virtual void SetRequestedRegionToLargestPossibleRegion();

  virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();

  virtual bool VerifyRequestedRegion();

  PropertyType * GetProperty(void);

  const PropertyType * GetProperty(void) const { return m_Property; }

  void SetProperty(PropertyType *property);

  itkGetConstReferenceMacro(Id, int);
  itkSetMacro(Id, int);

  itkSetMacro(ParentId, int);
  itkGetConstReferenceMacro(ParentId, int);

  virtual void Update(void);

  itkSetObjectMacro(TreeNode, TreeNodeType)


  itkGetModifiableObjectMacro(TreeNode, TreeNodeType);

  void SetSpacing(const double spacing[itkGetStaticConstMacro(ObjectDimension)])
  {
  m_AffineGeometryFrame->GetModifiableIndexToObjectTransform()->SetScale(spacing);
  this->Modified();
  }

  virtual const double * GetSpacing() const
  {
  return this->GetIndexToObjectTransform()->GetScale();
  }

  const TransformType * GetIndexToObjectTransform(void) const;

  TransformType * GetModifiableIndexToObjectTransform(void)
    {
    return m_AffineGeometryFrame->GetModifiableIndexToObjectTransform();
    }
  TransformType * GetIndexToObjectTransform(void)
    {
    return m_AffineGeometryFrame->GetModifiableIndexToObjectTransform();
    }


  void SetObjectToParentTransform(TransformType *transform);

  TransformType * GetObjectToParentTransform(void);

  const TransformType * GetObjectToParentTransform(void) const;

  TransformType * GetObjectToNodeTransform(void);

  const TransformType * GetObjectToNodeTransform(void) const;

  void AddSpatialObject(Self *pointer);

  void RemoveSpatialObject(Self *object);

  virtual const Self * GetParent(void) const;

  virtual Self * GetParent(void);

  virtual ChildrenListType * GetChildren(unsigned int depth = 0,
                                         char *name = NULL) const;

  unsigned int GetNumberOfChildren(unsigned int depth = 0,
                                   char *name = NULL) const;

  void SetChildren(ChildrenListType & children);

  virtual void Clear(void);

  virtual bool ComputeBoundingBox() const;

  virtual bool ComputeLocalBoundingBox() const
  {
    std::cerr << "SpatialObject::ComputeLocalBoundingBox Not Implemented!"
              << std::endl;
    return false;
  }

  virtual BoundingBoxType * GetBoundingBox() const;

  itkSetMacro(BoundingBoxChildrenDepth, unsigned int);
  itkGetConstReferenceMacro(BoundingBoxChildrenDepth, unsigned int);

  itkSetMacro(BoundingBoxChildrenName, std::string);
  itkGetConstReferenceMacro(BoundingBoxChildrenName, std::string);

  void SetParent(Self *parent);

  void SetNodeToParentNodeTransform(TransformType *transform);

  TransformType * GetNodeToParentNodeTransform(void);

  const TransformType * GetNodeToParentNodeTransform(void) const;

  itkSetMacro(DefaultInsideValue, double);
  itkGetConstMacro(DefaultInsideValue, double);

  itkSetMacro(DefaultOutsideValue, double);
  itkGetConstMacro(DefaultOutsideValue, double);

  virtual std::string GetSpatialObjectTypeAsString() const;

protected:

  SpatialObject();

  virtual ~SpatialObject();

  virtual void PrintSelf(std::ostream & os, Indent indent) const;

  void ComputeOffsetTable();

  itkSetMacro(Dimension, unsigned int);
  itkGetConstReferenceMacro(Dimension, unsigned int)
  itkSetMacro(TypeName, std::string);
  itkGetModifiableObjectMacro(Bounds, BoundingBoxType);
  itkGetModifiableObjectMacro(InternalInverseTransform, TransformType);

  bool SetInternalInverseTransformToWorldToIndexTransform() const;

private:

  SpatialObject(const Self &);  //purposely not implemented
  void operator=(const Self &); //purposely not implemented

  BoundingBoxPointer       m_Bounds;
  mutable ModifiedTimeType m_BoundsMTime;

  TransformPointer m_ObjectToParentTransform;
  TransformPointer m_ObjectToWorldTransform;
  TransformPointer m_IndexToWorldTransform;

  std::string m_TypeName;

  unsigned int m_Dimension;

  OffsetValueType m_OffsetTable[3 + 1];

  RegionType m_LargestPossibleRegion;
  RegionType m_RequestedRegion;
  RegionType m_BufferedRegion;

  std::string     m_BoundingBoxChildrenName;
  unsigned int    m_BoundingBoxChildrenDepth;
  PropertyPointer m_Property;

  int m_Id;
  int m_ParentId;

  typename TreeNodeType::Pointer m_TreeNode;

  AffineGeometryFramePointer m_AffineGeometryFrame;

  ChildrenListType m_InternalChildrenList;

  TransformPointer m_InternalInverseTransform;

  double m_DefaultInsideValue;

  double m_DefaultOutsideValue;
};
} // end of namespace itk

#if !defined( CABLE_CONFIGURATION )
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkSpatialObject.hxx"
#endif
#endif

#endif // __itkSpatialObject_h