itkCellInterface.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkCellInterface.h,v $
  Language:  C++
  Date:      $Date: 2002/09/30 15:24:40 $
  Version:   $Revision: 1.52 $

  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 __itkCellInterface_h
#define __itkCellInterface_h

#include "itkObject.h"
#include "itkObjectFactory.h"
#include <map>
#include "itkCellInterfaceVisitor.h"
#include "itkAutoPointer.h"
#include "itkArray.h"


// Define a macro for CellInterface sub-classes to use
// to define the Accept and GetTopologyId virtuals used
// by the MultiVisitor class
#define itkCellVisitMacro(TopologyId) \
  static int GetTopologyId() {return TopologyId;}\
  virtual void Accept(unsigned long cellid, typename CellInterface<PixelType, CellTraits>::MultiVisitor* mv)\
    {\
      typename CellInterfaceVisitor<PixelType, CellTraits>::Pointer v = mv->GetVisitor(TopologyId);\
      if(v)\
        {\
        v->VisitFromCell(cellid, this);\
        }\
    }



// Define a macro for the common typedefs required by the 
// classes deriving form CellInterface (included).
// This wouldn't be necessary if SGI compilers 
// were able to inherit types.
#define itkCellCommonTypedefs( celltype ) \
  typedef celltype                  Self;   \
  typedef AutoPointer<const Self>   ConstSelfAutoPointer;  \
  typedef AutoPointer<Self>         SelfAutoPointer;   \
  typedef Self *                    RawPointer;        \
  typedef const Self *              ConstRawPointer;   \
  SelfAutoPointer   New(void) {                        \
                SelfAutoPointer ptr( new celltype );   \
                ptr.TakeOwnership();                   \
                return ptr;                            \
                }                                      \


// Define a macro for the common typedefs required by the 
// classes deriving form CellInterface (excluded).
// This wouldn't be necessary if SGI compilers 
// were able to inherit types.
#define itkCellInheritedTypedefs( superclassArg ) \
  typedef superclassArg                                Superclass; \
  typedef typename Superclass::PixelType               PixelType;  \
  typedef typename Superclass::CellType                CellType;  \
  typedef typename Superclass::CellAutoPointer         CellAutoPointer;  \
  typedef typename Superclass::CellConstAutoPointer    CellConstAutoPointer;  \
  typedef typename Superclass::CellRawPointer          CellRawPointer;  \
  typedef typename Superclass::CellConstRawPointer     CellConstRawPointer;  \
  typedef typename Superclass::CellTraits              CellTraits;  \
  typedef typename Superclass::CoordRepType            CoordRepType;  \
  typedef typename Superclass::InterpolationWeightType InterpolationWeightType; \
  typedef typename Superclass::PointIdentifier         PointIdentifier; \
  typedef typename Superclass::PointIdIterator         PointIdIterator; \
  typedef typename Superclass::PointIdConstIterator    PointIdConstIterator; \
  typedef typename Superclass::CellIdentifier          CellIdentifier; \
  typedef typename Superclass::CellFeatureIdentifier   CellFeatureIdentifier; \
  typedef typename Superclass::CellFeatureIdentifier   CellFeatureCount; \
  typedef typename Superclass::PointType               PointType; \
  typedef typename Superclass::PointsContainer         PointsContainer; \
  typedef typename Superclass::UsingCellsContainer     UsingCellsContainer; \
  typedef typename Superclass::CellGeometry            CellGeometry;  \
  typedef typename Superclass::ParametricCoordArrayType  ParametricCoordArrayType;  \
  typedef typename Superclass::ShapeFunctionsArrayType   ShapeFunctionsArrayType;  \
  itkStaticConstMacro(PointDimension, unsigned int, Superclass::PointDimension)
 



namespace itk
{

template <
  typename TPixelType,
  typename TCellTraits
  >
class CellInterface
{
public:

  itkCellCommonTypedefs(CellInterface);

  typedef TPixelType                                PixelType;
  
  typedef TCellTraits                                 CellTraits;

  typedef typename CellTraits::CoordRepType            CoordRepType;
  typedef typename CellTraits::InterpolationWeightType InterpolationWeightType;
  typedef typename CellTraits::PointIdentifier         PointIdentifier;
  typedef typename CellTraits::PointIdIterator         PointIdIterator;
  typedef typename CellTraits::PointIdConstIterator    PointIdConstIterator;
  typedef typename CellTraits::CellIdentifier          CellIdentifier;
  typedef typename CellTraits::CellFeatureIdentifier   CellFeatureIdentifier;
  typedef typename CellTraits::PointType               PointType;
  typedef typename CellTraits::PointsContainer         PointsContainer;
  typedef typename CellTraits::UsingCellsContainer     UsingCellsContainer;
    
  itkStaticConstMacro(PointDimension, unsigned int,CellTraits::PointDimension);

  typedef typename UsingCellsContainer::iterator  UsingCellsContainerIterator;

  typedef CellInterface         CellType;
  typedef SelfAutoPointer       CellAutoPointer;
  typedef ConstSelfAutoPointer  CellConstAutoPointer;
  typedef RawPointer            CellRawPointer;
  typedef ConstRawPointer       CellConstRawPointer;
  
  typedef CellFeatureIdentifier  CellFeatureCount;

  enum CellGeometry {VERTEX_CELL=0, LINE_CELL, TRIANGLE_CELL, QUADRILATERAL_CELL, 
        POLYGON_CELL, TETRAHEDRON_CELL, HEXAHEDRON_CELL, 
        QUADRATIC_EDGE_CELL, QUADRATIC_TRIANGLE_CELL,
        LAST_ITK_CELL, MAX_ITK_CELLS=255};

  typedef Array<CoordRepType>                 ParametricCoordArrayType;
  typedef Array<InterpolationWeightType>      ShapeFunctionsArrayType;

  static int GetNextUserCellId(); // never return > MAX_INTERFACE

  class MultiVisitor : public LightObject
  { 
  public:
    typedef CellInterfaceVisitor<TPixelType, TCellTraits> VisitorType;

    typedef MultiVisitor       Self;
    typedef SmartPointer<Self>  Pointer;
      
    //itkNewMacro(Self);
    static  Pointer New(void) { return new Self; }
  
    itkTypeMacro(MultiVisitor,LightObject);
  
    typedef typename VisitorType::Pointer VisitorPointer;

  public:
    VisitorType * GetVisitor(int id)
      {
        if(id <= LAST_ITK_CELL)
          {
          return m_Visitors[id];
          }
        else
          {
          typename std::map<int, ITK_TYPENAME VisitorType::Pointer>::iterator
            pos = m_UserDefined.find(id);
          if(pos != m_UserDefined.end())
            {
            return (*pos).second;
            }
          }
        return 0;
      }
    void AddVisitor(VisitorType* v)
      {
        int id = v->GetCellTopologyId();
        if(id <= LAST_ITK_CELL)
          {
          m_Visitors[id] = v;
          }
        else
          {
          m_UserDefined.insert(std::map<int, VisitorPointer>::value_type(id,v));
          }
      }
    ~MultiVisitor() {}
  protected:
    VisitorPointer m_Visitors[LAST_ITK_CELL]; // fixed array set to the size from the enum
    std::map<int,VisitorPointer> m_UserDefined; // user defined cell types go here
  };

  virtual void Accept(unsigned long cellId, MultiVisitor*)= 0; 
  
  virtual CellGeometry GetType(void) const =0;

  virtual void MakeCopy( CellAutoPointer & ) const = 0;
  
  virtual unsigned int GetDimension(void) const=0;

  virtual unsigned int GetInterpolationOrder(void) const;
  
  virtual unsigned int GetNumberOfPoints(void) const=0;
  
  virtual CellFeatureCount GetNumberOfBoundaryFeatures(int dimension) const =0;
  
  virtual bool GetBoundaryFeature(int dimension, CellFeatureIdentifier, CellAutoPointer & )=0;

  virtual PointIdConstIterator GetPointIds(void) const;
  
  virtual void SetPointIds(PointIdConstIterator first)=0;
  
  virtual void SetPointIds(PointIdConstIterator first,
                           PointIdConstIterator last)=0;
  
  virtual void SetPointId(int localId, PointIdentifier)=0;
  
  virtual PointIdIterator PointIdsBegin(void)=0;

  virtual PointIdConstIterator PointIdsBegin(void) const =0;

  virtual PointIdIterator PointIdsEnd(void)=0;

  virtual PointIdConstIterator PointIdsEnd(void) const =0;

  virtual bool GetClosestBoundary(CoordRepType pCoords[], bool* inside, CellAutoPointer &) 
    {return false;}

  virtual bool EvaluatePosition(CoordRepType coords[PointDimension],
                                CoordRepType closestPoint[PointDimension],
                                CoordRepType pCoords[],
                                CoordRepType* dist2,
                                InterpolationWeightType weights[]) 
    {return bool();}
  
  virtual void EvaluateShapeFunctions( 
                          const ParametricCoordArrayType & parametricCoordinates,
                                ShapeFunctionsArrayType  & weights) const {}

  virtual bool IntersectWithLine(CoordRepType origin[PointDimension],
                                 CoordRepType direction[PointDimension],
                                 CoordRepType tolerance,
                                 CoordRepType coords[PointDimension],
                                 CoordRepType* t,
                                 CoordRepType pCoords[]) {return bool();}
  
  CoordRepType* GetBoundingBox(CoordRepType bounds[PointDimension*2]) {return NULL;}

  CoordRepType GetBoundingBoxDiagonalLength2(void) {return NULL;}

  virtual bool IntersectBoundingBoxWithLine(CoordRepType bounds[PointDimension*2],
                                            CoordRepType origin[PointDimension],
                                            CoordRepType direction[PointDimension],
                                            CoordRepType coords[PointDimension],
                                            CoordRepType* t) {return bool();}
  
  virtual bool IsBoundary(void);
  virtual void AddUsingCell(CellIdentifier);
  virtual void RemoveUsingCell(CellIdentifier);
  virtual bool IsUsingCell(CellIdentifier);
  virtual unsigned int GetNumberOfUsingCells(void);
  virtual UsingCellsContainerIterator UsingCellsBegin(void);
  virtual UsingCellsContainerIterator UsingCellsEnd(void);
    
  itkTypeMacro(CellInterface, LightObject);

public:
  CellInterface() {}
  virtual ~CellInterface() {}
//  bool GetPointPosition(PointsContainer*, int localId, Point*)=0;
private:
  CellInterface(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented  
};


template <int VPointDimension, typename TCoordRep,
  typename TInterpolationWeight, typename TPointIdentifier,
  typename TCellIdentifier, typename TCellFeatureIdentifier,
  typename TPoint, typename TPointsContainer,
  typename TUsingCellsContainer>
class CellTraitsInfo
{
public:
  itkStaticConstMacro(PointDimension, unsigned int, VPointDimension);
  typedef TCoordRep               CoordRepType;
  typedef TInterpolationWeight    InterpolationWeightType;
  typedef TPointIdentifier        PointIdentifier;
  typedef TCellIdentifier         CellIdentifier;
  typedef TCellFeatureIdentifier  CellFeatureIdentifier;
  typedef TPoint                  PointType;
  typedef TPointsContainer        PointsContainer;
  typedef TUsingCellsContainer    UsingCellsContainer;
  typedef PointIdentifier*        PointIdIterator;
  typedef const PointIdentifier*  PointIdConstIterator;  
};

#define itkMakeCellTraitsMacro \
  CellTraitsInfo<itkGetStaticConstMacro(PointDimension), CoordRepType, \
               InterpolationWeightType,  \
               PointIdentifier, CellIdentifier, CellFeatureIdentifier, \
               PointType, PointsContainer, UsingCellsContainer>

} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkCellInterface.txx"
#endif

#endif

---