itkCellInterface.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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 "itkCellInterfaceVisitor.h"
#include "itkAutoPointer.h"
#include "itkArray.h"
#include "itkCommonEnums.h"
 
#include <map>
 
// 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 constexpr CellGeometryEnum 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 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_MOVE(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;
 
  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<CellGeometryEnum, VisitorPointer>::value_type;
 
  public:
    VisitorType *
    GetVisitor(CellGeometryEnum id)
    {
      if (id < CellGeometryEnum::LAST_ITK_CELL)
      {
        return m_Visitors[static_cast<int>(id)];
      }
      else
      {
        auto pos = m_UserDefined.find(id);
        if (pos != m_UserDefined.end())
        {
          return (*pos).second;
        }
      }
      return nullptr;
    }
 
    void
    AddVisitor(VisitorType * v)
    {
      CellGeometryEnum id = v->GetCellTopologyId();
 
      if (id < CellGeometryEnum::LAST_ITK_CELL)
      {
        m_Visitors[static_cast<int>(id)] = v;
      }
      else
      {
        m_UserDefined.insert(VisitorPointerValueType(id, v));
      }
    }
 
    ~MultiVisitor() override = default;
 
  protected:
    VisitorPointer m_Visitors[static_cast<int>(CellGeometryEnum::LAST_ITK_CELL)]; // fixed array set to the
                                                                                  // size
                                                                                  // from the enum
    std::map<CellGeometryEnum, VisitorPointer> m_UserDefined;                     // user defined cell types
                                                                                  // go here
  };
 
  virtual void
  Accept(CellIdentifier cellId, MultiVisitor *) = 0;
 
  virtual ::itk::CommonEnums::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;
 
#if !defined(ITK_LEGACY_REMOVE)
 
  constexpr static CommonEnums::CellGeometry VERTEX_CELL = CommonEnums::CellGeometry::VERTEX_CELL;
  constexpr static CommonEnums::CellGeometry LINE_CELL = CommonEnums::CellGeometry::LINE_CELL;
  constexpr static CommonEnums::CellGeometry TRIANGLE_CELL = CommonEnums::CellGeometry::TRIANGLE_CELL;
  constexpr static CommonEnums::CellGeometry QUADRILATERAL_CELL = CommonEnums::CellGeometry::QUADRILATERAL_CELL;
  constexpr static CommonEnums::CellGeometry POLYGON_CELL = CommonEnums::CellGeometry::POLYGON_CELL;
  constexpr static CommonEnums::CellGeometry TETRAHEDRON_CELL = CommonEnums::CellGeometry::TETRAHEDRON_CELL;
  constexpr static CommonEnums::CellGeometry HEXAHEDRON_CELL = CommonEnums::CellGeometry::HEXAHEDRON_CELL;
  constexpr static CommonEnums::CellGeometry QUADRATIC_EDGE_CELL = CommonEnums::CellGeometry::QUADRATIC_EDGE_CELL;
  constexpr static CommonEnums::CellGeometry QUADRATIC_TRIANGLE_CELL =
    CommonEnums::CellGeometry::QUADRATIC_TRIANGLE_CELL;
  constexpr static CommonEnums::CellGeometry LAST_ITK_CELL = CommonEnums::CellGeometry::LAST_ITK_CELL;
  constexpr static CommonEnums::CellGeometry MAX_ITK_CELLS = CommonEnums::CellGeometry::MAX_ITK_CELLS;
#endif
 
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