itkSpatialObject.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkSpatialObject.h,v $
  Language:  C++
  Date:      $Date: 2003/09/10 14:29:50 $
  Version:   $Revision: 1.36 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
 
#ifndef __itkSpatialObject_h 
#define __itkSpatialObject_h 
 
#include "itkDataObject.h"
#include "itkBoundingBox.h"
#include "itkPoint.h"
#include "itkAffineTransform.h"
#include "itkFixedCenterOfRotationAffineTransform.h"
#include "itkSmartPointer.h" 
#include "itkVector.h"
#include "itkCovariantVector.h"
#include "itkExceptionObject.h" 
#include <list> 
#include "itkSpatialObjectProperty.h" 
#include "itkProcessObject.h"
#include "itkIndex.h"
#include "itkSize.h"
#include "itkImageRegion.h"
#include "itkObjectFactory.h"

namespace itk  
{ 

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

public: 

  typedef double ScalarType;

  itkStaticConstMacro(MaximumDepth, unsigned int, 9999999);

  unsigned int GetMaximumDepth() { return MaximumDepth; }

  typedef SpatialObject<TDimension> Self;
  typedef DataObject Superclass; 
  
  typedef SmartPointer< Self > Pointer;
  typedef SmartPointer< const Self > ConstPointer;
  
  typedef Point < ScalarType, TDimension > PointType; 
  typedef Point < ScalarType, TDimension > InputType; // Spatial Function Iterator needs it 
  typedef PointType * PointPointer; 
  
  typedef Vector< ScalarType, TDimension > VectorType; 
  typedef CovariantVector<ScalarType, TDimension > CovariantVectorType; 
  typedef VectorType * VectorPointer;

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

  typedef FixedCenterOfRotationAffineTransform< double, TDimension>   TransformType;
  typedef typename TransformType::Pointer  TransformPointer;
  typedef const TransformType*             TransformConstPointer;
  
  typedef VectorContainer< unsigned long int, PointType > VectorContainerType;
  
  typedef BoundingBox< unsigned long int, TDimension, ScalarType,
                       VectorContainerType > BoundingBoxType; 
  typedef typename BoundingBoxType::Pointer BoundingBoxPointer; 

  typedef std::list< Self * > ChildrenListType; 
  typedef ChildrenListType* ChildrenListPointer; 
   
  typedef Index<TDimension>  IndexType;
  typedef typename IndexType::IndexValueType  IndexValueType;

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

  virtual bool HasParent( void ) const;

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

  itkStaticConstMacro(ObjectDimension, unsigned int, TDimension);

  itkNewMacro( Self );
 
  itkTypeMacro( Self, Superclass );


  void SetIndexToObjectTransform( TransformType * transform ); 
  TransformType * GetIndexToObjectTransform( void ); 
  const TransformType * GetIndexToObjectTransform( void ) const; 

  void SetObjectToParentTransform( TransformType * transform ); 
  TransformType * GetObjectToParentTransform( void );
  const TransformType * GetObjectToParentTransform( void ) const;

  void SetObjectToWorldTransform( TransformType * transform );
  TransformType * GetObjectToWorldTransform( void );
  const TransformType * GetObjectToWorldTransform( void ) const;

  TransformType * GetIndexToWorldTransform( void );
  const TransformType * GetIndexToWorldTransform( void ) const;

  TransformType * GetWorldToIndexTransform( void );
  const TransformType * GetWorldToIndexTransform( void ) const;

  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 );
  };

  void SetParent(const Self * parent);

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

  unsigned long GetMTime( void ) const;

  void ComputeObjectToWorldTransform(void);

  void ComputeObjectToParentTransform(void);

  void AddSpatialObject( Self * pointer ); 
     
  void RemoveSpatialObject( Self * object ); 

  virtual const Self * GetParent( void ) const; 

  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 );

  unsigned long GetTransformMTime( void );

  unsigned long GetWorldTransformMTime( void );

  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(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=VImageDimension-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=VImageDimension-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( const PropertyType * property ); 

  itkGetConstMacro(Id,int);
  itkSetMacro(Id,int);

  virtual void Update(void);

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

  itkSetMacro(BoundingBoxChildrenName, std::string);
  itkGetMacro(BoundingBoxChildrenName, std::string);
  
  itkSetMacro(ParentId, int);
  itkGetMacro(ParentId, int);

  void SetSpacing( const double spacing[itkGetStaticConstMacro(ObjectDimension)] )
  { m_IndexToObjectTransform->SetScaleComponent(spacing);}
  virtual const double* GetSpacing() const 
  {return m_IndexToObjectTransform->GetScaleComponent();}

  itkSetMacro(SceneManageMemory,bool);
  itkGetMacro(SceneManageMemory,bool);

protected: 
 
  BoundingBoxPointer  m_Bounds; 
  mutable unsigned long       m_BoundsMTime;

  TransformPointer    m_IndexToObjectTransform;
  TransformPointer    m_ObjectToParentTransform;
  TransformPointer    m_ObjectToWorldTransform; 
  TransformPointer    m_IndexToWorldTransform; 
  TransformPointer    m_WorldToIndexTransform; 

  SpatialObject(); 

  virtual ~SpatialObject(); 

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

  ChildrenListType m_Children; 

  void ComputeOffsetTable();

  const Self* m_Parent;

  std::string m_TypeName;

  unsigned int m_Dimension;

  double  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;

  bool m_SceneManageMemory;
}; 

} // end of namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION 
#include "itkSpatialObject.txx" 
#endif 
 
#endif // __itkSpatialObject_h

---