itkMesh.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMesh.h,v $
  Language:  C++
  Date:      $Date: 2002/10/01 20:44:45 $
  Version:   $Revision: 1.75 $

  Copyright (c) 2002 Insight 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 TPixelType,
  unsigned int VDimension = 3,
  typename TMeshTraits = DefaultStaticMeshTraits< TPixelType , VDimension, VDimension >
  >
class 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;
    
  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  enum {     BoundariesAllocationMethodUndefined,
                      BoundariesAllocatedAsStaticArray, 
                      BoundariesAllocatedAsADynamicArray,
                      BoundariesAllocatedDynamicallyCellByCell
                                                } BoundariesAllocationMethodType;

  typedef typename MeshTraits::CoordRepType            CoordRepType;  
  typedef typename MeshTraits::InterpolationWeightType InterpolationWeightType;
  typedef typename MeshTraits::PointIdentifier         PointIdentifier;
  typedef typename MeshTraits::CellIdentifier          CellIdentifier;
  typedef typename MeshTraits::BoundaryIdentifier      BoundaryIdentifier;
  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 typename MeshTraits::BoundariesContainer     BoundariesContainer;
  typedef typename MeshTraits::BoundaryDataContainer   BoundaryDataContainer;
  
  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 BoundariesContainer::Pointer   BoundariesContainerPointer;
  typedef typename BoundaryDataContainer::Pointer BoundaryDataContainerPointer;
  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
          BoundariesContainer::ConstIterator    BoundariesContainerIterator;
  typedef typename
          BoundaryDataContainer::ConstIterator  BoundaryDataContainerIterator;
  typedef typename
     PointCellLinksContainer::const_iterator  PointCellLinksContainerIterator;
    
  typedef CellFeatureIdentifier  CellFeatureCount;
  
  typedef CellInterface<CellPixelType,CellTraits>  CellType;
  typedef typename CellType::CellAutoPointer       CellAutoPointer;
  
  typedef CellType          BoundaryType;
  typedef CellAutoPointer   BoundaryAutoPointer;
    
  typedef typename CellType::MultiVisitor CellMultiVisitorType;

protected:
  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

  CellsContainerPointer  m_CellsContainer;
  
  CellDataContainerPointer  m_CellDataContainer;

  CellLinksContainerPointer  m_CellLinksContainer;
  
  typedef std::vector<BoundariesContainerPointer> BoundariesContainerVector;
  typedef std::vector< BoundaryDataContainerPointer >
        BoundaryDataContainerVector;
  typedef MapContainer< BoundaryAssignmentIdentifier , BoundaryIdentifier >
        BoundaryAssignmentsContainer;
  typedef typename BoundaryAssignmentsContainer::Pointer
        BoundaryAssignmentsContainerPointer;
  typedef std::vector< BoundaryAssignmentsContainerPointer >
        BoundaryAssignmentsContainerVector;
  
  mutable BoundariesContainerVector  m_BoundariesContainers;

  BoundaryDataContainerVector  m_BoundaryDataContainers;

  BoundaryAssignmentsContainerVector  m_BoundaryAssignmentsContainers;
  
public:
  unsigned long GetNumberOfCells(void);
  void PassStructure(Self* inputMesh);
  virtual void Initialize(void);
  
  void SetCellLinks(CellLinksContainer*);
  CellLinksContainerPointer GetCellLinks(void);
  void SetCells(CellsContainer*);
  CellsContainerPointer GetCells(void);
  void SetCellData(CellDataContainer*);
  CellDataContainerPointer GetCellData(void);
  void SetBoundaries(int dimension, BoundariesContainer*);
  BoundariesContainerPointer GetBoundaries(int dimension);
  void SetBoundaryData(int dimension, BoundaryDataContainer*);
  BoundaryDataContainerPointer GetBoundaryData(int dimension);
  void SetBoundaryAssignments(int dimension,
                              BoundaryAssignmentsContainer*);
  BoundaryAssignmentsContainerPointer
  GetBoundaryAssignments(int dimension);
    
  void SetCell(CellIdentifier, CellAutoPointer & );
  bool GetCell(CellIdentifier, CellAutoPointer & ) const;
  
  void SetCellData(CellIdentifier, CellPixelType);
  bool GetCellData(CellIdentifier, CellPixelType*) const;
    
  void SetBoundary(int dimension, BoundaryIdentifier, BoundaryAutoPointer & );
  bool GetBoundary(int dimension, BoundaryIdentifier, BoundaryAutoPointer & ) const;
    
  void SetBoundaryData(int dimension, BoundaryIdentifier, CellPixelType);
  bool GetBoundaryData(int dimension, BoundaryIdentifier, CellPixelType*) const;
  
  void SetBoundaryAssignment(int dimension, CellIdentifier cellId,
                             CellFeatureIdentifier featureId,
                             BoundaryIdentifier);
  bool GetBoundaryAssignment(int dimension, CellIdentifier cellId,
                             CellFeatureIdentifier featureId,
                             BoundaryIdentifier*) const;
  bool RemoveBoundaryAssignment(int dimension, CellIdentifier cellId,
                                CellFeatureIdentifier featureId);
  
  CellFeatureCount GetNumberOfCellBoundaryFeatures(int dimension,
                                                   CellIdentifier) const;
  bool GetCellBoundaryFeature(int dimension, CellIdentifier,
                       CellFeatureIdentifier, BoundaryAutoPointer & ) const;
  unsigned long GetCellBoundaryFeatureNeighbors(
    int dimension, CellIdentifier, CellFeatureIdentifier,
    std::set<CellIdentifier>* cellSet);
  
  bool GetAssignedCellBoundaryIfOneExists(int dimension, CellIdentifier,
                                          CellFeatureIdentifier,
                                          BoundaryAutoPointer& ) const;
  void BuildCellLinks(void);
    
  BoundingBoxPointer GetCellBoundingBox(CellIdentifier cellId, 
                                        BoundingBoxPointer bbox);
  
  virtual void Accept(CellMultiVisitorType* mv);

  virtual void UpdateOutputInformation();
  virtual void SetRequestedRegionToLargestPossibleRegion();
  virtual void CopyInformation(const DataObject *data);
  virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
  virtual bool VerifyRequestedRegion();
  
  int GetMaximumNumberOfRegions() const
    {return m_MaximumNumberOfRegions;}
      
  virtual void SetRequestedRegion(DataObject *data);

  itkSetMacro( CellsAllocationMethod, CellsAllocationMethodType );  
  itkGetConstMacro( CellsAllocationMethod, CellsAllocationMethodType );  

  itkSetMacro( BoundariesAllocationMethod, BoundariesAllocationMethodType );  
  itkGetConstMacro( BoundariesAllocationMethod, BoundariesAllocationMethodType );  


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

  void ReleaseBoundariesMemory(void);

  void ReleaseBoundariesMemory( unsigned int dimension );
  
private:
  Mesh(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented
  
  CellsAllocationMethodType             m_CellsAllocationMethod;
  BoundariesAllocationMethodType        m_BoundariesAllocationMethod;

}; // End Class: Mesh

} // end namespace itk
  
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkMesh.txx"
#endif
  
#endif

---