itkSpatialObject.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkSpatialObject.h,v $
  Language:  C++
  Date:      $Date: 2003/02/10 15:59:46 $
  Version:   $Revision: 1.26 $

  Copyright (c) 2002 Insight 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 "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);

  typedef SpatialObject<TDimension> Self;
  typedef DataObject Superclass; 
  
  typedef SmartPointer< Self > Pointer;
  typedef SmartPointer< const Self > ConstPointer;
  
  typedef Point < ScalarType, TDimension > PointType; 
  typedef PointType * PointPointer; 
  
  typedef Vector< ScalarType, TDimension > VectorType; 
  typedef VectorType * VectorPointer;

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

  typedef AffineTransform< double, TDimension>   TransformType;
  typedef typename TransformType::Pointer  TransformPointer;
  typedef const TransformType*             TransformConstPointer;
  
  typedef std::list< TransformType * > TransformListType;
  
  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;}

  itkStaticConstMacro(ObjectDimension, unsigned int, TDimension);

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

  void SetBoundingBox( BoundingBoxPointer bounds ); 

  virtual BoundingBoxType * GetBoundingBox( void ) const; 

  void SetTransform( TransformType * transform ); 
  TransformType * GetTransform( void ); 
  const TransformType * GetTransform( void ) const; 

  void SetGlobalTransform( TransformType * transform );
  TransformType * GetGlobalTransform( void );
  const TransformType * GetGlobalTransform( void ) const;

  itkSetMacro(CenterOfRotation,PointType);
  itkGetMacro(CenterOfRotation,PointType);

  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;

  void SetParent(const Self * parent);

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

  void TransformPointToLocalCoordinate( PointType & p ) const;

  void TransformPointToGlobalCoordinate( PointType & p ) const; 

  TransformListType & GetGlobalTransformList( void );

  virtual bool ComputeBoundingBox( unsigned int depth=0,
                                   char * name = NULL);

  void SetSpacing( const double spacing[ObjectDimension] );

  void SetScale( const double scale[ObjectDimension] );

  const double* GetSpacing() const {return m_Spacing;}
  
  const double* GetScale() const {return m_Scale;}

  const double* GetGlobalScale() const {return m_GlobalScale;}

  unsigned long GetMTime( void ) const;

  void ComputeGlobalTransform(void);

  void ComputeTransform(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);

  void SetChildren( ChildrenListType & children ); 

  virtual void Clear(void);

  unsigned long GetTransformMTime(void);

  unsigned long GetGlobalTransformMTime(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 );

  void SetProperty( const PropertyType * property ); 

  void SetParentId(int parentid) {m_ParentId=parentid;}
  int  GetParentId(void) {return m_ParentId;}

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

  virtual void Update(void);


protected: 
  
  BoundingBoxPointer  m_Bounds; 
  unsigned long       m_BoundsMTime;
  double              m_Spacing[ObjectDimension];
  double              m_Scale[ObjectDimension];
  double              m_GlobalScale[ObjectDimension];
  PointType           m_CenterOfRotation;
  TransformListType   m_GlobalTransformList;

  TransformPointer    m_Transform;
  TransformPointer    m_TransformWithCoR;
  TransformPointer    m_GlobalTransform; 

  SpatialObject(); 

  virtual ~SpatialObject(); 

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

  ChildrenListType m_Children; 

  void ComputeOffsetTable();

  const Self* m_Parent;

  char m_TypeName[255];

  unsigned int m_Dimension;

  double  m_OffsetTable[3+1];

  RegionType          m_LargestPossibleRegion;
  RegionType          m_RequestedRegion;
  RegionType          m_BufferedRegion;
    

  PropertyPointer m_Property; 

  int m_ParentId;

  int m_Id;

}; 

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

---