itkAutomaticTopologyMeshSource.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkAutomaticTopologyMeshSource.h,v $
  Language:  C++
  Date:      $Date: 2007-12-21 15:25:33 $
  Version:   $Revision: 1.16 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkAutomaticTopologyMeshSource_h
#define __itkAutomaticTopologyMeshSource_h

#include "itkArray.h"
#include "itkDefaultStaticMeshTraits.h"
#include "itk_hash_map.h"
#include "itkHexahedronCell.h"
#include "itkLineCell.h"
#include "itkMesh.h"
#include "itkMeshSource.h"
#include "itkQuadrilateralCell.h"
#include "itkStructHashFunction.h"
#include "itkTriangleCell.h"
#include "itkTetrahedronCell.h"
#include "itkVertexCell.h"

namespace itk
{
template <class TOutputMesh>
class ITK_EXPORT 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 VertexCell< CellType >             VertexCell;
  typedef LineCell< CellType >               LineCell;
  typedef TriangleCell< CellType >           TriangleCell;
  typedef QuadrilateralCell< CellType >      QuadrilateralCell;
  typedef TetrahedronCell< CellType >        TetrahedronCell;
  typedef HexahedronCell< CellType >         HexahedronCell;

  typedef unsigned long IdentifierType;

  typedef Array< IdentifierType >              IdentifierArrayType;

  typedef itk::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:
    unsigned long operator()( Array< unsigned long > identifierArray) const
      {
      typedef unsigned long Ulong;

      Ulong size = identifierArray.Size();

      std::sort( identifierArray.begin(), identifierArray.end() );

      Ulong hash = 0;
      Ulong* id = &identifierArray[ 0 ];

      while( size-- )
        {
        hash += *id++;
        hash = (hash << 7) | (hash >> 25); // Rotate left by 7.
        }

      return hash;
      }
    };

  class IdentifierArrayEqualsFunction
    {
  public:
    bool operator()(
      Array< unsigned long > identifierArray1,
      Array< unsigned long > identifierArray2
      ) const
      {
      typedef unsigned long Ulong;

      
      Ulong size1 = identifierArray1.Size();
      Ulong 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() {}; // GenerateData is a no-op, since the entries 
                          // are controlled manually

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

  typedef itk::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.txx"
#endif

#endif // __itkAutomaticTopologyMeshSource_h

---