itkSpatialObject.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkSpatialObject.h,v $
  Language:  C++
  Date:      $Date: 2009-04-07 14:34:16 $
  Version:   $Revision: 1.68 $

  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 
 
// Disable warning for long symbol names in this file only
#ifdef _MSC_VER
#pragma warning ( disable : 4786 )
#endif

#include "itkAffineGeometryFrame.h"
#include "itkDataObject.h"
#include "itkBoundingBox.h"
#include "itkPoint.h"
#include "itkScalableAffineTransform.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"
#include "itkSpatialObjectTreeNode.h"

namespace itk  
{ 

template <unsigned int TDimension> class SpatialObjectTreeNode;

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; 
  // Spatial Function Iterator needs the following typedef 
  typedef Point < ScalarType, TDimension > InputType; 
  typedef PointType * PointPointer; 
  
  typedef Vector< ScalarType, TDimension > VectorType; 
  typedef CovariantVector<ScalarType, TDimension > CovariantVectorType; 
  typedef VectorType * VectorPointer;

  typedef double *                              SpacingType;

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

  typedef ScalableAffineTransform< 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 AffineGeometryFrame<double,TDimension>    AffineGeometryFrameType;
  typedef typename AffineGeometryFrameType::Pointer AffineGeometryFramePointer;

  typedef std::list< Pointer > 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; 

  typedef SpatialObjectTreeNode<TDimension> TreeNodeType;

  virtual bool HasParent( void ) const;

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

  itkStaticConstMacro(ObjectDimension, unsigned int, TDimension);

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

  itkNewMacro( Self );

  itkTypeMacro( SpatialObject, DataObject );

  itkGetConstObjectMacro(AffineGeometryFrame,AffineGeometryFrameType);
  itkSetObjectMacro(AffineGeometryFrame,AffineGeometryFrameType);

  void SetObjectToWorldTransform( TransformType * transform );
  itkGetObjectMacro(ObjectToWorldTransform,TransformType);
  itkGetConstObjectMacro(ObjectToWorldTransform,TransformType);
  itkGetObjectMacro(IndexToWorldTransform,TransformType);
  itkGetConstObjectMacro(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);


  unsigned long 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(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=TDimension-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=TDimension-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)


  itkGetObjectMacro(TreeNode, TreeNodeType);
  itkGetConstObjectMacro(TreeNode, TreeNodeType);

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

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


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

  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);
  itkGetConstObjectMacro(Bounds,BoundingBoxType);
  itkGetConstObjectMacro(InternalInverseTransform,TransformType);

  bool SetInternalInverseTransformToWorldToIndexTransform() const;

private:

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

  BoundingBoxPointer          m_Bounds; 
  mutable unsigned long       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.txx" 
#endif 
#endif 
 
#endif // __itkSpatialObject_h