itkTriangleMeshToSimplexMeshFilter.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 itkTriangleMeshToSimplexMeshFilter_h
#define itkTriangleMeshToSimplexMeshFilter_h

#include "itkMapContainer.h"
#include "itkSimplexMesh.h"
#include "itkMeshToMeshFilter.h"
#include "itkVectorContainer.h"

#include "itkPolygonCell.h"
namespace itk
{
template< typename TInputMesh, typename TOutputMesh >
class ITK_TEMPLATE_EXPORT TriangleMeshToSimplexMeshFilter:public MeshToMeshFilter< TInputMesh, TOutputMesh >
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(TriangleMeshToSimplexMeshFilter);

  using Self = TriangleMeshToSimplexMeshFilter;

  using Superclass = MeshToMeshFilter< TInputMesh, TOutputMesh >;

  using Pointer = SmartPointer< Self >;
  using ConstPointer = SmartPointer< const Self >;

  itkNewMacro(Self);

  itkTypeMacro(TriangleMeshToSimplexMeshFilter, MeshToMeshFilter);

  using InputMeshType = TInputMesh;
  using InputMeshPointer = typename TInputMesh::Pointer;
  using InputPointType = typename TInputMesh::PointType;

  using InputBoundaryAssignmentsContainerPointer = typename TInputMesh::BoundaryAssignmentsContainerPointer;

  using InputPointsContainer = typename TInputMesh::PointsContainer;
  using InputPointsContainerPointer = typename InputPointsContainer::Pointer;
  using InputPointsContainerIterator = typename InputPointsContainer::Iterator;
  using InputPointsContainerConstIterator = typename InputPointsContainer::ConstIterator;

  using OutputMeshPointer = typename TOutputMesh::Pointer;
  using OutputPointType = typename TOutputMesh::PointType;
  using OutputPixelType = typename TOutputMesh::PixelType;
  using OutputPointsContainer = typename TOutputMesh::PointsContainer;
  using OutputPointsContainerPointer = typename OutputPointsContainer::Pointer;
  using OutputPointsContainerIterator = typename TOutputMesh::PointsContainer::Iterator;

  using InputBoundnaryAssignmentIdentifier = typename TInputMesh::BoundaryAssignmentIdentifier;

  using InputCellType = typename TInputMesh::CellType;
  using InputCellAutoPointer = typename InputCellType::CellAutoPointer;
  using CellAutoPointer = typename TInputMesh::CellAutoPointer;
  using LineType = itk::LineCell< InputCellType >;
  using PolygonType = itk::PolygonCell< InputCellType >;
  using TriangleType = itk::TriangleCell< InputCellType >;
  using VertexType = itk::VertexCell< InputCellType >;

  using CellIdentifier = typename TOutputMesh::CellIdentifier;
  using PointIdentifier = typename TOutputMesh::PointIdentifier;
  using CellFeatureIdentifier = typename TOutputMesh::CellFeatureIdentifier;

  using EdgeIdentifierType = std::pair< CellIdentifier, CellIdentifier >;
  using IndexSetType = std::set< CellIdentifier >;

  using EdgeNeighborListType = itk::MapContainer< CellIdentifier, EdgeIdentifierType >;
  using LineCellIndexType = itk::MapContainer< EdgeIdentifierType, CellIdentifier >;

  using VertexNeighborListType = itk::MapContainer< PointIdentifier, IndexSetType >;
  using EdgeMapType = itk::MapContainer< EdgeIdentifierType, CellIdentifier >;
  using EdgeMapPointer = typename EdgeMapType::Pointer;

  using IdVectorType = itk::VectorContainer< CellIdentifier, CellIdentifier >;
  using IdVectorPointer = typename IdVectorType::Pointer;

  using OutputCellType = typename TOutputMesh::CellType;
  using OutputCellAutoPointer = typename TOutputMesh::CellAutoPointer;
  using OutputLineType = itk::LineCell< OutputCellType >;
  using OutputPolygonType = itk::PolygonCell< OutputCellType >;

protected:

  TriangleMeshToSimplexMeshFilter();
  ~TriangleMeshToSimplexMeshFilter() override;

  void PrintSelf(std::ostream & os, Indent indent) const override;

  void GenerateData() override;

  void Initialize();

  void CreateSimplexPoints();

  void CreateEdgeForTrianglePair(CellIdentifier pointIndex,
                                 CellIdentifier boundaryId,
                                 TOutputMesh *outputMesh);

  void CreateSimplexNeighbors();

  void CreateCells();

  void CreateNewEdge(CellIdentifier currentCellId, CellFeatureIdentifier featureId,
                     PointIdentifier startPointId, PointIdentifier endPointId,
                     const InputMeshType *input);


  InputPointType ComputeFaceCenter(CellIdentifier faceId, const InputMeshType *inputMesh);

  IndexSetType *m_FaceSet;

  EdgeMapPointer m_Edges;

  typename EdgeNeighborListType::Pointer m_EdgeNeighborList;

  typename VertexNeighborListType::Pointer m_VertexNeighborList;

  typename LineCellIndexType::Pointer m_LineCellIndices;

  CellIdentifier m_CellIdxOffset;

  PointIdentifier m_IdOffset;

  CellIdentifier m_EdgeCellId;

  IdVectorPointer m_HandledEdgeIds;

  InputCellAutoPointer m_NewInputMeshCellPointer;

  OutputCellAutoPointer m_NewSimplexCellPointer;
};
} //end of namespace

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTriangleMeshToSimplexMeshFilter.hxx"
#endif

#endif