itkNDimensionalSpatialObject.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkNDimensionalSpatialObject.h,v $
  Language:  C++
  Date:      $Date: 2002/10/18 19:21:27 $
  Version:   $Revision: 1.4 $

  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 __itkNDimensionalSpatialObject_h 
#define __itkNDimensionalSpatialObject_h 
 
#include "itkDataObject.h"
#include "itkObjectFactory.h"
#include "vnl/vnl_vector.h"
#include "itkImageRegion.h"
#include "itkProcessObject.h"
#include "itkIndex.h"
#include "itkSize.h"
#include "itkSpatialObjectProperty.h" 

namespace itk  
{ 

template <unsigned int PipelineDimension = 3>
class NDimensionalSpatialObject
:public DataObject
{ 

public: 

  typedef NDimensionalSpatialObject<PipelineDimension> Self;
  typedef DataObject Superclass; 
  
  typedef SmartPointer< Self > Pointer;
  typedef SmartPointer< const Self > ConstPointer;
//  typedef vnl_vector<double> VectorType;

  typedef Index<PipelineDimension>  IndexType;
  typedef typename IndexType::IndexValueType  IndexValueType;
  
  typedef Offset<PipelineDimension>  OffsetType;
  typedef typename OffsetType::OffsetValueType OffsetValueType;
  typedef ImageRegion<PipelineDimension> RegionType;
  typedef Size<PipelineDimension>    SizeType; 
  typedef SpatialObjectProperty< float > PropertyType; 
  typedef typename PropertyType::Pointer  PropertyPointer; 

  typedef std::list< Self * > NDimensionalChildrenListType; 

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

  virtual void SetParent( const Self * parent );

  virtual const Self * GetParent( void ) const; 

  virtual bool HasParent( void ) const;

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

  unsigned int GetDimension(void) const {return m_Dimension;}

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

  itkGetMacro(Id,int);
  itkSetMacro(Id,int);

  NDimensionalChildrenListType & GetNDimensionalChildren( void ) {return m_NDimensionalChildrenList;}


protected: 
  
  void ComputeOffsetTable();

  NDimensionalSpatialObject(); 

  virtual ~NDimensionalSpatialObject(); 

  ConstPointer m_Parent; 
  char m_TypeName[255];

  unsigned int m_Dimension;

  double  m_OffsetTable[3+1];

  RegionType          m_LargestPossibleRegion;
  RegionType          m_RequestedRegion;
  RegionType          m_BufferedRegion;
    

  NDimensionalChildrenListType m_NDimensionalChildrenList;

  PropertyPointer m_Property; 

  int m_ParentId;

  int m_Id;

}; 

} // end of namespace itk

#ifndef ITK_MANUAL_INSTANTIATION 
  #include "itkNDimensionalSpatialObject.txx" 
#endif 
 
#endif // __itkNDimensionalSpatialObject_h

---