itkAutomaticTopologyMeshSource.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 itkAutomaticTopologyMeshSource_h
#define itkAutomaticTopologyMeshSource_h
 
#include "itkArray.h"
#include "itkDefaultStaticMeshTraits.h"
#include <unordered_map>
#include "itkHexahedronCell.h"
#include "itkIntTypes.h"
#include "itkMesh.h"
#include "itkMeshSource.h"
#include "itkStructHashFunction.h"
#include "itkTetrahedronCell.h"
#include "itkVertexCell.h"
 
namespace itk
{
template <typename TOutputMesh>
class ITK_TEMPLATE_EXPORT AutomaticTopologyMeshSource : public MeshSource<TOutputMesh>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(AutomaticTopologyMeshSource);
 
  using Self = AutomaticTopologyMeshSource;
  using Superclass = MeshSource<TOutputMesh>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  using MeshType = TOutputMesh;
  using PointHashType = typename MeshType::PointHashType;
  using PointType = typename MeshType::PointType;
  using CellType = typename MeshType::CellType;
  using MeshPointer = typename MeshType::Pointer;
  using CoordinateType = typename PointType::CoordRepType;
  using CellAutoPointer = typename CellType::CellAutoPointer;
 
  using VertexCell = ::itk::VertexCell<CellType>;
  using LineCell = ::itk::LineCell<CellType>;
  using TriangleCell = ::itk::TriangleCell<CellType>;
  using QuadrilateralCell = ::itk::QuadrilateralCell<CellType>;
  using TetrahedronCell = ::itk::TetrahedronCell<CellType>;
  using HexahedronCell = ::itk::HexahedronCell<CellType>;
 
  using IdentifierType = ::itk::IdentifierType;
 
  using IdentifierArrayType = Array<IdentifierType>;
 
  using PointHashMap = std::unordered_map<PointType, IdentifierType, StructHashFunction<PointHashType>>;
 
  static constexpr unsigned int PointDimension = MeshType::PointDimension;
  static constexpr unsigned int MaxTopologicalDimension = MeshType::MaxTopologicalDimension;
 
  itkNewMacro(Self);
 
  itkTypeMacro(AutomaticTopologyMeshSource, MeshSource);
 
  IdentifierType
  AddPoint(const PointType & p0);
 
  IdentifierType
  AddPoint(const CoordinateType * p0);
 
  IdentifierType
  AddPoint(CoordinateType x0 = 0,
           CoordinateType x1 = 0,
           CoordinateType x2 = 0,
           CoordinateType x3 = 0,
           CoordinateType x4 = 0,
           CoordinateType x5 = 0);
 
  IdentifierType
  AddVertex(const IdentifierArrayType & pointIDs);
 
  IdentifierType
  AddVertex(IdentifierType pointId0);
 
  IdentifierType
  AddVertex(const PointType & p0);
 
  IdentifierType
  AddVertex(const CoordinateType * p0);
 
  IdentifierType
  AddLine(const IdentifierArrayType & pointIDs);
 
  IdentifierType
  AddLine(IdentifierType pointId0, IdentifierType pointId1);
 
  IdentifierType
  AddLine(const PointType & p0, const PointType & p1);
 
  IdentifierType
  AddLine(const CoordinateType * p0, const CoordinateType * p1);
 
  IdentifierType
  AddTriangle(const IdentifierArrayType & pointIDs);
 
  IdentifierType
  AddTriangle(IdentifierType pointId0, IdentifierType pointId1, IdentifierType pointId2);
 
  IdentifierType
  AddTriangle(const PointType & p0, const PointType & p1, const PointType & p2);
 
  IdentifierType
  AddTriangle(const CoordinateType * p0, const CoordinateType * p1, const CoordinateType * p2);
 
  IdentifierType
  AddQuadrilateral(const IdentifierArrayType & pointIDs);
 
  IdentifierType
  AddQuadrilateral(IdentifierType pointId0, IdentifierType pointId1, IdentifierType pointId2, IdentifierType pointId3);
 
  IdentifierType
  AddQuadrilateral(const PointType & p0, const PointType & p1, const PointType & p2, const PointType & p3);
 
  IdentifierType
  AddQuadrilateral(const CoordinateType * p0,
                   const CoordinateType * p1,
                   const CoordinateType * p2,
                   const CoordinateType * p3);
 
  IdentifierType
  AddTetrahedron(const IdentifierArrayType & pointIDs);
 
  IdentifierType
  AddTetrahedron(IdentifierType pointId0, IdentifierType pointId1, IdentifierType pointId2, IdentifierType pointId3);
 
  IdentifierType
  AddTetrahedron(const PointType & p0, const PointType & p1, const PointType & p2, const PointType & p3);
 
  IdentifierType
  AddTetrahedron(const CoordinateType * p0,
                 const CoordinateType * p1,
                 const CoordinateType * p2,
                 const CoordinateType * p3);
 
  IdentifierType
  AddHexahedron(const IdentifierArrayType & pointIDs);
 
  IdentifierType
  AddHexahedron(IdentifierType pointId0,
                IdentifierType pointId1,
                IdentifierType pointId2,
                IdentifierType pointId3,
                IdentifierType pointId4,
                IdentifierType pointId5,
                IdentifierType pointId6,
                IdentifierType pointId7);
 
  IdentifierType
  AddHexahedron(const PointType & p0,
                const PointType & p1,
                const PointType & p2,
                const PointType & p3,
                const PointType & p4,
                const PointType & p5,
                const PointType & p6,
                const PointType & p7);
 
  IdentifierType
  AddHexahedron(const CoordinateType * p0,
                const CoordinateType * p1,
                const CoordinateType * p2,
                const CoordinateType * p3,
                const CoordinateType * p4,
                const CoordinateType * p5,
                const CoordinateType * p6,
                const CoordinateType * p7);
 
  class IdentifierArrayHashFunction
  {
  public:
    IdentifierType
    operator()(Array<IdentifierType> identifierArray) const
    {
      using IdType = IdentifierType;
 
      IdType size = identifierArray.Size();
 
      std::sort(identifierArray.begin(), identifierArray.end());
 
      IdType   hash = 0;
      IdType * id = &identifierArray[0];
 
      while (size--)
      {
        hash += *id++;
        hash = (hash << 7) | (hash >> 25); // Rotate left by 7.
      }
 
      return hash;
    }
  };
 
  class IdentifierArrayEqualsFunction
  {
  public:
    bool
    operator()(Array<IdentifierType> identifierArray1, Array<IdentifierType> identifierArray2) const
    {
      using IdType = IdentifierType;
 
      IdType size1 = identifierArray1.Size();
      IdType size2 = identifierArray2.Size();
 
      if (size1 != size2)
      {
        return false;
      }
 
      std::sort(identifierArray1.begin(), identifierArray1.end());
      std::sort(identifierArray2.begin(), identifierArray2.end());
 
      return (identifierArray1 == identifierArray2);
    }
  };
 
protected:
  AutomaticTopologyMeshSource();
  ~AutomaticTopologyMeshSource() override = default;
 
  void
  GenerateData() override
  {} // GenerateData is a no-op, since the entries override
     // are controlled manually
 
private:
  using CellHashMap = std::
    unordered_map<Array<IdentifierType>, IdentifierType, IdentifierArrayHashFunction, IdentifierArrayEqualsFunction>;
 
  PointHashMap m_PointsHashTable;
  CellHashMap  m_CellsHashTable;
  MeshPointer  m_OutputMesh; // Retained for convenience.
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkAutomaticTopologyMeshSource.hxx"
#endif
 
#endif // itkAutomaticTopologyMeshSource_h