itkMesh.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMesh.h,v $
  Language:  C++
  Date:      $Date: 2007/01/13 21:05:15 $
  Version:   $Revision: 1.94 $

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

  Portions of this code are covered under the VTK copyright.
  See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.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 __itkMesh_h
#define __itkMesh_h

#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif

#include "itkPointSet.h"
#include "itkCellInterface.h"
#include "itkMapContainer.h"
#include <vector>
#include <set>


namespace itk
{

template <typename TMesh>
struct GetMeshDimension
{
itkStaticConstMacro(MaxTopologicalDimension, unsigned int, TMesh::MaxTopologicalDimension); 
itkStaticConstMacro(PointDimension, unsigned int,  TMesh::PointDimension);
}; 


template <
  typename TPixelType,
  unsigned int VDimension = 3,
  typename TMeshTraits = DefaultStaticMeshTraits< TPixelType , VDimension, VDimension >
  >
class ITK_EXPORT Mesh : public PointSet<TPixelType, VDimension, TMeshTraits>
{
public:
  typedef Mesh                Self;
  typedef PointSet<TPixelType, VDimension, TMeshTraits>  Superclass;
  typedef SmartPointer<Self>  Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  typedef typename Superclass::RegionType RegionType;

  itkNewMacro(Self);

  itkTypeMacro(Mesh, PointSet);

  typedef TMeshTraits   MeshTraits;
  typedef typename MeshTraits::PixelType                PixelType;  
  typedef typename MeshTraits::CellPixelType            CellPixelType;  

  itkStaticConstMacro(PointDimension, unsigned int,
                      TMeshTraits::PointDimension);
  itkStaticConstMacro(MaxTopologicalDimension, unsigned int,
                      TMeshTraits::MaxTopologicalDimension);

  typedef  enum {     CellsAllocationMethodUndefined,
                      CellsAllocatedAsStaticArray, 
                      CellsAllocatedAsADynamicArray,
                      CellsAllocatedDynamicallyCellByCell
                                                } CellsAllocationMethodType;

  typedef typename MeshTraits::CoordRepType            CoordRepType;  
  typedef typename MeshTraits::InterpolationWeightType InterpolationWeightType;
  typedef typename MeshTraits::PointIdentifier         PointIdentifier;
  typedef typename MeshTraits::CellIdentifier          CellIdentifier;
  typedef typename MeshTraits::CellFeatureIdentifier   CellFeatureIdentifier;
  typedef typename MeshTraits::PointType               PointType;
  typedef typename MeshTraits::PointsContainer         PointsContainer;
  typedef typename MeshTraits::CellTraits              CellTraits;
  typedef typename MeshTraits::CellsContainer          CellsContainer;
  typedef typename MeshTraits::PointCellLinksContainer PointCellLinksContainer;
  typedef typename MeshTraits::CellLinksContainer      CellLinksContainer;
  typedef typename MeshTraits::PointDataContainer      PointDataContainer;
  typedef typename MeshTraits::CellDataContainer       CellDataContainer;  

  typedef PointLocator<PointIdentifier,itkGetStaticConstMacro(PointDimension),
                       CoordRepType,PointsContainer>  PointLocatorType;
  typedef BoundingBox<PointIdentifier,itkGetStaticConstMacro(PointDimension),
                      CoordRepType,PointsContainer>   BoundingBoxType;

  typedef typename PointsContainer::Pointer       PointsContainerPointer;
  typedef typename CellsContainer::Pointer        CellsContainerPointer;
  typedef typename CellLinksContainer::Pointer    CellLinksContainerPointer;
  typedef typename PointDataContainer::Pointer    PointDataContainerPointer;
  typedef typename CellDataContainer::Pointer     CellDataContainerPointer;
  typedef typename PointLocatorType::Pointer      PointLocatorPointer;
  typedef typename BoundingBoxType::Pointer       BoundingBoxPointer;

  typedef typename
          PointsContainer::ConstIterator        PointsContainerConstIterator;
  typedef typename
          PointsContainer::Iterator             PointsContainerIterator;
  typedef typename
          CellsContainer::ConstIterator         CellsContainerConstIterator;
  typedef typename
          CellsContainer::Iterator              CellsContainerIterator;
  typedef typename
          CellLinksContainer::ConstIterator     CellLinksContainerIterator;
  typedef typename
          PointDataContainer::ConstIterator     PointDataContainerIterator;
  typedef typename
          CellDataContainer::ConstIterator      CellDataContainerIterator;
  typedef typename
     PointCellLinksContainer::const_iterator  PointCellLinksContainerIterator;

  typedef CellFeatureIdentifier  CellFeatureCount;

  typedef CellInterface<CellPixelType,CellTraits>  CellType;
  typedef typename CellType::CellAutoPointer       CellAutoPointer;

  typedef typename CellType::MultiVisitor CellMultiVisitorType;



  class BoundaryAssignmentIdentifier
  {
  public:

    typedef BoundaryAssignmentIdentifier Self;

    BoundaryAssignmentIdentifier() {}
    BoundaryAssignmentIdentifier(CellIdentifier cellId,
                                 CellFeatureIdentifier featureId):
      m_CellId(cellId), m_FeatureId(featureId) {}    

    CellIdentifier m_CellId;

    CellFeatureIdentifier  m_FeatureId;

    bool operator < (const Self& r) const
      {
      return ((m_CellId < r.m_CellId) ||
              ((m_CellId == r.m_CellId) && (m_FeatureId < r.m_FeatureId)));
      }

    bool operator == (const Self& r) const
      {
      return ((m_CellId == r.m_CellId) && (m_FeatureId == r.m_FeatureId));
      }
  }; // End Class: Mesh::BoundaryAssignmentIdentifier


  typedef MapContainer< BoundaryAssignmentIdentifier , CellIdentifier >
        BoundaryAssignmentsContainer;
  typedef typename BoundaryAssignmentsContainer::Pointer
        BoundaryAssignmentsContainerPointer;
  typedef std::vector< BoundaryAssignmentsContainerPointer >
        BoundaryAssignmentsContainerVector;


protected:

  CellsContainerPointer  m_CellsContainer;

  CellDataContainerPointer  m_CellDataContainer;

  CellLinksContainerPointer  m_CellLinksContainer;

  BoundaryAssignmentsContainerVector  m_BoundaryAssignmentsContainers;

public:
  unsigned long GetNumberOfCells() const;
  void PassStructure(Self* inputMesh);
  virtual void Initialize();

  virtual void CopyInformation(const DataObject *data);
  virtual void Graft(const DataObject *data);

  void SetCellLinks(CellLinksContainer*);
#ifndef CABLE_CONFIGURATION
  CellLinksContainerPointer GetCellLinks();
  const CellLinksContainerPointer GetCellLinks() const;

  void SetCells(CellsContainer*);

  CellsContainerPointer GetCells();
  const CellsContainerPointer GetCells() const;
#endif

  void SetCellData(CellDataContainer*);
  CellDataContainerPointer GetCellData();
  const CellDataContainerPointer GetCellData() const;

#if !defined(CABLE_CONFIGURATION)
  void SetBoundaryAssignments(int dimension,
                              BoundaryAssignmentsContainer*);
#endif

#ifndef CABLE_CONFIGURATION
  BoundaryAssignmentsContainerPointer GetBoundaryAssignments(int dimension);
  const BoundaryAssignmentsContainerPointer GetBoundaryAssignments(
    int dimension) const;

  void SetCell(CellIdentifier, CellAutoPointer & );
  bool GetCell(CellIdentifier, CellAutoPointer & ) const;
#endif

  void SetCellData(CellIdentifier, CellPixelType);
  bool GetCellData(CellIdentifier, CellPixelType*) const;

  void SetBoundaryAssignment(int dimension, CellIdentifier cellId,
                             CellFeatureIdentifier featureId,
                             CellIdentifier boundaryId);

  bool GetBoundaryAssignment(int dimension, CellIdentifier cellId,
                             CellFeatureIdentifier featureId,
                             CellIdentifier* boundaryId) const;
  bool RemoveBoundaryAssignment(int dimension, CellIdentifier cellId,
                                CellFeatureIdentifier featureId);

  CellFeatureCount GetNumberOfCellBoundaryFeatures(int dimension,
                                                   CellIdentifier) const;

#ifndef CABLE_CONFIGURATION

  bool GetCellBoundaryFeature(int dimension, CellIdentifier,
                              CellFeatureIdentifier, CellAutoPointer& ) const;
#endif

  unsigned long GetCellBoundaryFeatureNeighbors(
    int dimension, CellIdentifier, CellFeatureIdentifier,
    std::set<CellIdentifier>* cellSet);

  unsigned long GetCellNeighbors( CellIdentifier cellId,
                                  std::set<CellIdentifier>* cellSet );
#ifndef CABLE_CONFIGURATION

  bool GetAssignedCellBoundaryIfOneExists(int dimension, CellIdentifier,
                                          CellFeatureIdentifier,
                                          CellAutoPointer& ) const;
#endif

  void BuildCellLinks();

#ifndef CABLE_CONFIGURATION

  BoundingBoxPointer GetCellBoundingBox(CellIdentifier cellId, 
                                        BoundingBoxPointer bbox);

  virtual void Accept(CellMultiVisitorType* mv);
#endif

  itkSetMacro( CellsAllocationMethod, CellsAllocationMethodType );  
  itkGetConstReferenceMacro( CellsAllocationMethod, CellsAllocationMethodType );  

protected:
  Mesh();
  ~Mesh();
  void PrintSelf(std::ostream& os, Indent indent) const;

  void ReleaseCellsMemory();

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

  CellsAllocationMethodType             m_CellsAllocationMethod;

}; // End Class: Mesh

} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#ifndef CABLE_CONFIGURATION
#include "itkMesh.txx"
#endif
#endif

#endif

---