itkAutomaticTopologyMeshSource.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 itkAutomaticTopologyMeshSource_h
#define itkAutomaticTopologyMeshSource_h

#include "itkArray.h"
#include "itkDefaultStaticMeshTraits.h"
#include "itksys/hash_map.hxx"
#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 AutomaticTopologyMeshSource:public MeshSource< TOutputMesh >
{
public:
  typedef AutomaticTopologyMeshSource Self;
  typedef MeshSource< TOutputMesh >   Superclass;
  typedef SmartPointer< Self >        Pointer;
  typedef SmartPointer< const Self >  ConstPointer;

  typedef          TOutputMesh               MeshType;
  typedef typename MeshType::PointHashType   PointHashType;
  typedef typename MeshType::PointType       PointType;
  typedef typename MeshType::CellType        CellType;
  typedef typename MeshType::Pointer         MeshPointer;
  typedef typename PointType::CoordRepType   CoordinateType;
  typedef typename CellType::CellAutoPointer CellAutoPointer;

  typedef::itk::VertexCell< CellType >        VertexCell;
  typedef::itk::LineCell< CellType >          LineCell;
  typedef::itk::TriangleCell< CellType >      TriangleCell;
  typedef::itk::QuadrilateralCell< CellType > QuadrilateralCell;
  typedef::itk::TetrahedronCell< CellType >   TetrahedronCell;
  typedef::itk::HexahedronCell< CellType >    HexahedronCell;

  typedef ::itk::IdentifierType IdentifierType;

  typedef Array< IdentifierType > IdentifierArrayType;

  typedef itksys::hash_map<
    PointType,
    IdentifierType,
    StructHashFunction< PointHashType > >          PointHashMap;

  itkStaticConstMacro(PointDimension, unsigned int,
                      MeshType::PointDimension);
  itkStaticConstMacro(MaxTopologicalDimension, unsigned int,
                      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
    {
      typedef IdentifierType IdType;

      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
    {
      typedef IdentifierType IdType;

      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();

  void GenerateData() ITK_OVERRIDE {}  // GenerateData is a no-op, since the entries ITK_OVERRIDE
                          // are controlled manually

private:
  AutomaticTopologyMeshSource(const Self &);  //purposely not implemented
  void operator=(const Self &);               //purposely not implemented

  typedef itksys::hash_map<
    Array< IdentifierType >,
    IdentifierType,
    IdentifierArrayHashFunction,
    IdentifierArrayEqualsFunction >          CellHashMap;

  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