itkCellInterface.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkCellInterface_h
#define __itkCellInterface_h

#include "itkObject.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(CellIdentifier 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).
#define itkCellCommonTypedefs(celltype)                   \
  typedef celltype                  Self;                 \
  typedef AutoPointer< const Self > ConstSelfAutoPointer; \
  typedef AutoPointer< Self >       SelfAutoPointer;      \
  typedef Self *                    RawPointer;           \
  typedef const Self *ConstRawPointer

// Define a macro for the common typedefs required by the
// classes deriving form CellInterface (excluded).
#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::VectorType            VectorType;            \
  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;

  typedef typename PointType::VectorType VectorType;

  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) { Pointer smartPtr = new Self; smartPtr->UnRegister(); return smartPtr; }

    itkTypeMacro(MultiVisitor, LightObject);

    typedef typename VisitorType::Pointer VisitorPointer;
    typedef typename std::map< int, VisitorPointer >::value_type
    VisitorPointerValueType;

public:
    VisitorType * GetVisitor(int id)
    {
      if ( id < LAST_ITK_CELL )
        {
        return m_Visitors[id];
        }
      else
        {
        typename std::map< int, typename VisitorType::Pointer >::iterator
        pos = m_UserDefined.find(id);
        if ( pos != m_UserDefined.end() )
          {
          return ( *pos ).second;
          }
        }
      return ITK_NULLPTR;
    }

    void AddVisitor(VisitorType *v)
    {
      int id = v->GetCellTopologyId();

      if ( id < LAST_ITK_CELL )
        {
        m_Visitors[id] = v;
        }
      else
        {
        m_UserDefined.insert( VisitorPointerValueType(id, v) );
        }
    }

    virtual ~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(CellIdentifier 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;

  typedef itk::Array<PointIdentifier> PointIdentifierContainerType;
  PointIdentifierContainerType GetPointIdsContainer() const;
  void SetPointIdsContainer( const PointIdentifierContainerType & );

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

  virtual bool EvaluatePosition(CoordRepType *,
                                PointsContainer *,
                                CoordRepType *,
                                CoordRepType[],
                                double *,
                                InterpolationWeightType *)
  { return bool(); }

  virtual void EvaluateShapeFunctions(
    const ParametricCoordArrayType &,
    ShapeFunctionsArrayType  &) const {}

  virtual bool IntersectWithLine(CoordRepType[PointDimension],
                                 CoordRepType[PointDimension],
                                 CoordRepType,
                                 CoordRepType[PointDimension],
                                 CoordRepType *,
                                 CoordRepType[]) { return bool(); }

  CoordRepType * GetBoundingBox(CoordRepType[PointDimension * 2]) { return NULL; }

  CoordRepType GetBoundingBoxDiagonalLength2(void) { return NULL; }

  virtual bool IntersectBoundingBoxWithLine(CoordRepType[PointDimension * 2],
                                            CoordRepType[PointDimension],
                                            CoordRepType[PointDimension],
                                            CoordRepType[PointDimension],
                                            CoordRepType *) { return bool(); }

  virtual bool IsExplicitBoundary(void);

  virtual void AddUsingCell(CellIdentifier cellId);

  virtual void RemoveUsingCell(CellIdentifier cellId);

  virtual bool IsUsingCell(CellIdentifier cellId);

  virtual unsigned int GetNumberOfUsingCells(void);

#if !defined( CABLE_CONFIGURATION )

  virtual UsingCellsContainerIterator UsingCellsBegin(void);

  virtual UsingCellsContainerIterator UsingCellsEnd(void);

#endif

  itkTypeMacro(CellInterface, LightObject);

public:
  CellInterface() {}
  virtual ~CellInterface() {}
//  bool GetPointPosition(PointsContainer*, int localId, Point*)=0;

protected:
  UsingCellsContainer m_UsingCells;

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

#if !defined( CABLE_CONFIGURATION )
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkCellInterface.hxx"
#endif
#endif

#endif