itkQuadEdgeMesh.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
 *
 *         https://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 itkQuadEdgeMesh_h
#define itkQuadEdgeMesh_h
 
#include <cstdarg>
#include <queue>
#include <vector>
#include <list>
 
#include "itkMesh.h"
 
#include "itkQuadEdgeMeshTraits.h"
#include "itkQuadEdgeMeshLineCell.h"
#include "itkQuadEdgeMeshPolygonCell.h"
 
#include "itkQuadEdgeMeshFrontIterator.h"
#include "itkConceptChecking.h"
 
 
namespace itk
{
template <typename TPixel,
          unsigned int VDimension,
          typename TTraits = QuadEdgeMeshTraits<TPixel, VDimension, bool, bool>>
class ITK_TEMPLATE_EXPORT QuadEdgeMesh : public Mesh<TPixel, VDimension, TTraits>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(QuadEdgeMesh);
 
  using Traits = TTraits;
  using PixelType = TPixel;
 
  using Self = QuadEdgeMesh;
  using Superclass = Mesh<TPixel, VDimension, Traits>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  static constexpr unsigned int PointDimension = Traits::PointDimension;
  static constexpr unsigned int MaxTopologicalDimension = Traits::MaxTopologicalDimension;
 
  using typename Superclass::CellPixelType;
  using typename Superclass::CoordRepType;
  using typename Superclass::PointIdentifier;
  using typename Superclass::PointHashType;
  using typename Superclass::PointType;
  using typename Superclass::CellTraits;
 
  using PointIdInternalIterator = typename CellTraits::PointIdInternalIterator;
  using PointIdIterator = typename CellTraits::PointIdIterator;
 
  // Point section:
  using typename Superclass::PointsContainer;
  using typename Superclass::PointsContainerPointer;
  using CoordRepArrayType = CoordRepType[Self::PointDimension];
 
  // Point data section:
  using typename Superclass::PointDataContainer;
  using typename Superclass::PointDataContainerPointer;
  using typename Superclass::PointDataContainerIterator;
  using typename Superclass::PointsContainerConstIterator;
  using typename Superclass::PointsContainerIterator;
 
  // Cell section:
  using typename Superclass::CellIdentifier;
  using typename Superclass::CellType;
  using typename Superclass::CellAutoPointer;
  using typename Superclass::CellFeatureIdentifier;
  using typename Superclass::CellFeatureCount;
  using typename Superclass::CellMultiVisitorType;
  using typename Superclass::CellsContainer;
  using typename Superclass::CellsContainerPointer;
 
  using typename Superclass::CellsContainerConstIterator;
  using typename Superclass::CellsContainerIterator;
 
  using typename Superclass::CellLinksContainer;
  using typename Superclass::CellLinksContainerPointer;
  using typename Superclass::CellLinksContainerIterator;
 
  // Cell data section:
  using typename Superclass::CellDataContainer;
  using typename Superclass::CellDataContainerPointer;
  using typename Superclass::CellDataContainerIterator;
 
  // Point / Cell correspondence section:
  using typename Superclass::PointCellLinksContainer;
  using typename Superclass::PointCellLinksContainerIterator;
 
  // BoundaryAssignments section:
  using typename Superclass::BoundaryAssignmentsContainer;
  using typename Superclass::BoundaryAssignmentsContainerPointer;
  using typename Superclass::BoundaryAssignmentsContainerVector;
 
  // Miscellaneous section:
  using typename Superclass::BoundingBoxPointer;
  using typename Superclass::BoundingBoxType;
  using typename Superclass::RegionType;
  using typename Superclass::InterpolationWeightType;
 
  using PrimalDataType = typename Traits::PrimalDataType;
  using DualDataType = typename Traits::DualDataType;
  using QEPrimal = typename Traits::QEPrimal;
  using QEDual = typename Traits::QEDual;
  using QEType = typename Traits::QEPrimal;
  // See the TODO entry dated from 2005-05-28
  // struct QEType : public QEPrimal, public QEDual {}
  using VertexRefType = typename Traits::VertexRefType;
  using FaceRefType = typename Traits::FaceRefType;
  using VectorType = typename Traits::VectorType;
 
  using EdgeCellType = QuadEdgeMeshLineCell<CellType>;
  using PolygonCellType = QuadEdgeMeshPolygonCell<CellType>;
 
  using FreePointIndexesType = std::queue<PointIdentifier>;
  using FreeCellIndexesType = std::queue<CellIdentifier>;
 
  using PointIdList = std::vector<PointIdentifier>;
  using EdgeListType = std::list<QEPrimal *>;
  using EdgeListPointerType = EdgeListType *;
 
  using MeshClassCellsAllocationMethodEnum = itk::MeshEnums::MeshClassCellsAllocationMethod;
 
  static const PointIdentifier m_NoPoint;
 
  static const CellIdentifier m_NoFace;
 
public:
  itkNewMacro(Self);
  itkOverrideGetNameOfClassMacro(QuadEdgeMesh);
#if !defined(ITK_WRAPPING_PARSER)
 
  itkQEDefineFrontIteratorMethodsMacro(Self);
#endif
 
public:
  // Multithreading framework: not tested yet.
  bool
  RequestedRegionIsOutsideOfTheBufferedRegion() override
  {
    return (false);
  }
 
  void
  Initialize() override;
 
  virtual void
  Clear();
 
  CellsContainer *
  GetEdgeCells()
  {
    return m_EdgeCellsContainer;
  }
  const CellsContainer *
  GetEdgeCells() const
  {
    return m_EdgeCellsContainer;
  }
  void
  SetEdgeCells(CellsContainer * edgeCells)
  {
    m_EdgeCellsContainer = edgeCells;
  }
  void
  SetEdgeCell(CellIdentifier cellId, CellAutoPointer & cellPointer)
  {
    m_EdgeCellsContainer->InsertElement(cellId, cellPointer.ReleaseOwnership());
  }
 
  void
  CopyInformation(const DataObject * data) override
  {
    (void)data;
  }
  void
  Graft(const DataObject * data) override;
  void
  SqueezePointsIds();
 
  void
  BuildCellLinks() const
  {}
 
#if !defined(ITK_WRAPPING_PARSER)
 
  void
  SetBoundaryAssignments(int dimension, BoundaryAssignmentsContainer * container)
  {
    (void)dimension;
    (void)container;
  }
  BoundaryAssignmentsContainerPointer
  GetBoundaryAssignments(int dimension)
  {
    (void)dimension;
    return (nullptr);
  }
  const BoundaryAssignmentsContainerPointer
  GetBoundaryAssignments(int dimension) const
  {
    (void)dimension;
    return (nullptr);
  }
#endif
 
  void
  SetBoundaryAssignment(int                   dimension,
                        CellIdentifier        cellId,
                        CellFeatureIdentifier featureId,
                        CellIdentifier        boundaryId)
  {
    (void)dimension;
    (void)cellId;
    (void)featureId;
    (void)boundaryId;
  }
  bool
  GetBoundaryAssignment(int                   dimension,
                        CellIdentifier        cellId,
                        CellFeatureIdentifier featureId,
                        CellIdentifier *      boundaryId) const
  {
    (void)dimension;
    (void)cellId;
    (void)featureId;
    (void)boundaryId;
    return (false); // ALEX: is it the good way?
  }
  bool
  RemoveBoundaryAssignment(int dimension, CellIdentifier cellId, CellFeatureIdentifier featureId)
  {
    (void)dimension;
    (void)cellId;
    (void)featureId;
    return (false); // ALEX: is it the good way?
  }
  bool
  GetCellBoundaryFeature(int                   dimension,
                         CellIdentifier        cellId,
                         CellFeatureIdentifier featureId,
                         CellAutoPointer &     cellAP) const
  {
    (void)dimension;
    (void)cellId;
    (void)featureId;
    (void)cellAP;
    return (false);
  }
  CellIdentifier
  GetCellBoundaryFeatureNeighbors(int                        dimension,
                                  CellIdentifier             cellId,
                                  CellFeatureIdentifier      featureId,
                                  std::set<CellIdentifier> * cellSet)
  {
    (void)dimension;
    (void)cellId;
    (void)featureId;
    (void)cellSet;
    return CellIdentifier{};
  }
  CellIdentifier
  GetCellNeighbors(CellIdentifier itkNotUsed(cellId), std::set<CellIdentifier> * itkNotUsed(cellSet))
  {
    return CellIdentifier{};
  }
 
  bool
  GetAssignedCellBoundaryIfOneExists(int                   dimension,
                                     CellIdentifier        cellId,
                                     CellFeatureIdentifier featureId,
                                     CellAutoPointer &     cellAP) const
  {
    (void)dimension;
    (void)cellId;
    (void)featureId;
    (void)cellAP;
    return (false); // ALEX: is it the good way?
  }
  void
  SetCell(CellIdentifier cId, CellAutoPointer & cell);
 
  virtual PointIdentifier
  FindFirstUnusedPointIndex();
 
  virtual CellIdentifier
  FindFirstUnusedCellIndex();
 
  virtual void
  PushOnContainer(EdgeCellType * newEdge);
 
  // Adding Point/Edge/Face methods
  virtual PointIdentifier
  AddPoint(const PointType & p);
 
  virtual QEPrimal *
  AddEdge(const PointIdentifier & orgPid, const PointIdentifier & destPid);
 
  virtual QEPrimal *
  AddEdgeWithSecurePointList(const PointIdentifier & orgPid, const PointIdentifier & destPid);
 
  virtual void
  AddFace(QEPrimal * entry);
 
  virtual QEPrimal *
  AddFace(const PointIdList & points);
 
  virtual QEPrimal *
  AddFaceWithSecurePointList(const PointIdList & points);
 
  virtual QEPrimal *
  AddFaceWithSecurePointList(const PointIdList & points, bool CheckEdges);
 
  virtual QEPrimal *
  AddFaceTriangle(const PointIdentifier & aPid, const PointIdentifier & bPid, const PointIdentifier & cPid);
 
  virtual void
  DeletePoint(const PointIdentifier & pid);
 
  virtual void
  DeleteEdge(const PointIdentifier & orgPid, const PointIdentifier & destPid);
 
  virtual void
  DeleteEdge(QEPrimal * e);
 
  virtual void
  LightWeightDeleteEdge(EdgeCellType * edgeCell);
 
  virtual void
  LightWeightDeleteEdge(QEPrimal * e);
 
  virtual void
  DeleteFace(FaceRefType faceToDelete);
 
  //
  bool
  GetPoint(PointIdentifier pid, PointType * pt) const
  {
    return (Superclass::GetPoint(pid, pt));
  }
 
  virtual PointType
  GetPoint(const PointIdentifier & pid) const;
 
  virtual VectorType
  GetVector(const PointIdentifier & pid) const;
 
  virtual QEPrimal *
  GetEdge() const;
 
  virtual QEPrimal *
  GetEdge(const CellIdentifier & eid) const;
 
  virtual QEPrimal *
  FindEdge(const PointIdentifier & pid0) const;
 
  virtual QEPrimal *
  FindEdge(const PointIdentifier & pid0, const PointIdentifier & pid1) const;
 
  virtual EdgeCellType *
  FindEdgeCell(const PointIdentifier & pid0, const PointIdentifier & pid1) const;
 
  CoordRepType
  ComputeEdgeLength(QEPrimal * e);
 
  PointIdentifier
  ComputeNumberOfPoints() const;
 
  CellIdentifier
  ComputeNumberOfFaces() const;
 
  CellIdentifier
  ComputeNumberOfEdges() const;
 
  PointIdentifier
  Splice(QEPrimal * a, QEPrimal * b);
 
#ifdef ITK_USE_CONCEPT_CHECKING
  // Begin concept checking
  // End concept checking
#endif
 
  // for reusability of a mesh in the MeshToMesh filter
  void
  ClearFreePointAndCellIndexesLists()
  {
    while (!this->m_FreePointIndexes.empty())
    {
      this->m_FreePointIndexes.pop();
    }
    while (!this->m_FreeCellIndexes.empty())
    {
      this->m_FreeCellIndexes.pop();
    }
  }
 
  CellIdentifier
  GetNumberOfFaces() const
  {
    return (m_NumberOfFaces);
  }
  CellIdentifier
  GetNumberOfEdges() const
  {
    return (m_NumberOfEdges);
  }
 
protected:
  QuadEdgeMesh();
  ~QuadEdgeMesh() override;
  virtual void
  ClearCellsContainer();
 
  CellsContainerPointer m_EdgeCellsContainer{};
 
private:
  CellIdentifier m_NumberOfFaces{};
  CellIdentifier m_NumberOfEdges{};
 
protected:
  FreePointIndexesType m_FreePointIndexes{};
  FreeCellIndexesType  m_FreeCellIndexes{};
};
} // namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkQuadEdgeMesh.hxx"
#endif
 
#endif