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) override                                  \
    {                                                                                                \
    typename CellInterfaceVisitor< PixelType, CellTraits >::Pointer v =                              \
      mv->GetVisitor(TopologyId);                                                                    \
    if ( v )                                                                                         \
      {                                                                                              \
      v->VisitFromCell(cellid, this);                                                                \
      }                                                                                              \
    }

// Define a macro for the common type alias required by the
// classes deriving form CellInterface (included).
#define itkCellCommonTypedefs(celltype)                   \
  using Self = celltype;                 \
  using ConstSelfAutoPointer = AutoPointer< const Self >; \
  using SelfAutoPointer = AutoPointer< Self >;      \
  using RawPointer = Self *;           \
  using ConstRawPointer = const Self *

// Define a macro for the common type alias required by the
// classes deriving form CellInterface (excluded).
#define itkCellInheritedTypedefs(superclassArg)                             \
  using Superclass = superclassArg;             \
  using PixelType = typename Superclass::PixelType;              \
  using CellType = typename Superclass::CellType;               \
  using CellAutoPointer = typename Superclass::CellAutoPointer;        \
  using CellConstAutoPointer = typename Superclass::CellConstAutoPointer;   \
  using CellRawPointer = typename Superclass::CellRawPointer;         \
  using CellConstRawPointer = typename Superclass::CellConstRawPointer;    \
  using CellTraits = typename Superclass::CellTraits;             \
  using CoordRepType = typename Superclass::CoordRepType;           \
  using InterpolationWeightType = typename Superclass::InterpolationWeightType; \
  using PointIdentifier = typename Superclass::PointIdentifier;       \
  using PointIdIterator = typename Superclass::PointIdIterator;       \
  using PointIdConstIterator = typename Superclass::PointIdConstIterator;  \
  using CellIdentifier = typename Superclass::CellIdentifier;        \
  using CellFeatureIdentifier = typename Superclass::CellFeatureIdentifier; \
  using CellFeatureCount = typename Superclass::CellFeatureIdentifier;      \
  using PointType = typename Superclass::PointType;             \
  using VectorType = typename Superclass::VectorType;            \
  using PointsContainer = typename Superclass::PointsContainer;       \
  using UsingCellsContainer = typename Superclass::UsingCellsContainer;   \
  using CellGeometry = typename Superclass::CellGeometry;          \
  using ParametricCoordArrayType = typename Superclass::ParametricCoordArrayType; \
  using ShapeFunctionsArrayType = typename Superclass::ShapeFunctionsArrayType; \
  static constexpr unsigned int PointDimension = Superclass::PointDimension

namespace itk
{
template<
  typename TPixelType,
  typename TCellTraits
  >
class ITK_TEMPLATE_EXPORT CellInterface
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(CellInterface);

  itkCellCommonTypedefs(CellInterface);

  using PixelType = TPixelType;

  using CellTraits = TCellTraits;

  using CoordRepType = typename CellTraits::CoordRepType;
  using InterpolationWeightType = typename CellTraits::InterpolationWeightType;
  using PointIdentifier = typename CellTraits::PointIdentifier;
  using PointIdIterator = typename CellTraits::PointIdIterator;
  using PointIdConstIterator = typename CellTraits::PointIdConstIterator;
  using CellIdentifier = typename CellTraits::CellIdentifier;
  using CellFeatureIdentifier = typename CellTraits::CellFeatureIdentifier;
  using PointType = typename CellTraits::PointType;
  using PointsContainer = typename CellTraits::PointsContainer;
  using UsingCellsContainer = typename CellTraits::UsingCellsContainer;

  using VectorType = typename PointType::VectorType;

  static constexpr unsigned int PointDimension = CellTraits::PointDimension;

  using UsingCellsContainerIterator = typename UsingCellsContainer::iterator;

  using CellType = CellInterface;
  using CellAutoPointer = SelfAutoPointer;
  using CellConstAutoPointer = ConstSelfAutoPointer;
  using CellRawPointer = RawPointer;
  using CellConstRawPointer = ConstRawPointer;

  using CellFeatureCount = CellFeatureIdentifier;

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

  using ParametricCoordArrayType = Array< CoordRepType >;
  using ShapeFunctionsArrayType = Array< InterpolationWeightType >;

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

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

    using Self = MultiVisitor;
    using Pointer = SmartPointer< Self >;

    //itkNewMacro(Self);
    static Pointer New() { Pointer smartPtr = new Self; smartPtr->UnRegister(); return smartPtr; }

    itkTypeMacro(MultiVisitor, LightObject);

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

public:
    VisitorType * GetVisitor(int id)
    {
      if ( id < LAST_ITK_CELL )
        {
        return m_Visitors[id];
        }
      else
        {
        auto pos = m_UserDefined.find(id);
        if ( pos != m_UserDefined.end() )
          {
          return ( *pos ).second;
          }
        }
      return 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) );
        }
    }

    ~MultiVisitor() override = default;

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() const = 0;

  virtual void MakeCopy(CellAutoPointer &) const = 0;

  virtual unsigned int GetDimension() const = 0;

  virtual unsigned int GetInterpolationOrder() const;

  virtual unsigned int GetNumberOfPoints() const = 0;

  virtual CellFeatureCount GetNumberOfBoundaryFeatures(int dimension) const = 0;

  virtual bool GetBoundaryFeature(int dimension, CellFeatureIdentifier,
                                  CellAutoPointer &) = 0;

  virtual PointIdConstIterator GetPointIds() 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() = 0;

  virtual PointIdConstIterator PointIdsBegin() const = 0;

  virtual PointIdIterator PointIdsEnd() = 0;

  virtual PointIdConstIterator PointIdsEnd() const = 0;

  using PointIdentifierContainerType = itk::Array<PointIdentifier>;
  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 nullptr; }

  CoordRepType GetBoundingBoxDiagonalLength2() { return NumericTraits< CoordRepType >::ZeroValue(); }

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

  virtual bool IsExplicitBoundary();

  virtual void AddUsingCell(CellIdentifier cellId);

  virtual void RemoveUsingCell(CellIdentifier cellId);

  virtual bool IsUsingCell(CellIdentifier cellId);

  virtual unsigned int GetNumberOfUsingCells();

#if !defined( ITK_WRAPPING_PARSER )

  virtual UsingCellsContainerIterator UsingCellsBegin();

  virtual UsingCellsContainerIterator UsingCellsEnd();

#endif

  itkTypeMacroNoParent(CellInterface);

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

protected:
  UsingCellsContainer m_UsingCells;
};

template< int VPointDimension, typename TCoordRep,
          typename TInterpolationWeight, typename TPointIdentifier,
          typename TCellIdentifier, typename TCellFeatureIdentifier,
          typename TPoint, typename TPointsContainer,
          typename TUsingCellsContainer >
class ITK_TEMPLATE_EXPORT CellTraitsInfo
{
public:
  static constexpr unsigned int PointDimension = VPointDimension;
  using CoordRepType = TCoordRep;
  using InterpolationWeightType = TInterpolationWeight;
  using PointIdentifier = TPointIdentifier;
  using CellIdentifier = TCellIdentifier;
  using CellFeatureIdentifier = TCellFeatureIdentifier;
  using PointType = TPoint;
  using PointsContainer = TPointsContainer;
  using UsingCellsContainer = TUsingCellsContainer;
  using PointIdIterator = PointIdentifier *;

  using PointIdConstIterator = const PointIdentifier *;
};

#define itkMakeCellTraitsMacro                                           \
  CellTraitsInfo < Self::PointDimension, CoordRepType, \
  InterpolationWeightType,                                               \
  PointIdentifier, CellIdentifier, CellFeatureIdentifier,                \
  PointType, PointsContainer, UsingCellsContainer >
} // end namespace itk

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

#endif