itkMesh.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.
 *
 *=========================================================================*/
/*=========================================================================
 *
 *  Portions of this file are subject to the VTK Toolkit Version 3 copyright.
 *
 *  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 *
 *  For complete copyright, license and disclaimer of warranty information
 *  please refer to the NOTICE file at the top of the ITK source tree.
 *
 *=========================================================================*/
#ifndef itkMesh_h
#define itkMesh_h


#include "itkPointSet.h"

#include "itkBoundingBox.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;

  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::PointHashType           PointHashType;
  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 BoundingBox< PointIdentifier, itkGetStaticConstMacro(PointDimension),
                       CoordRepType, PointsContainer >   BoundingBoxType;

  typedef typename PointsContainer::Pointer         PointsContainerPointer;
  typedef typename CellsContainer::Pointer          CellsContainerPointer;
  typedef typename CellsContainer::ConstPointer     CellsContainerConstPointer;
  typedef typename CellLinksContainer::Pointer      CellLinksContainerPointer;
  typedef typename PointDataContainer::Pointer      PointDataContainerPointer;
  typedef typename CellDataContainer::Pointer       CellDataContainerPointer;
  typedef typename CellDataContainer::ConstPointer  CellDataContainerConstPointer;
  typedef typename BoundingBoxType::Pointer         BoundingBoxPointer;
  typedef typename CellLinksContainer::ConstPointer CellLinksContainerConstPointer;

  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;

  mutable CellLinksContainerPointer m_CellLinksContainer;

  BoundaryAssignmentsContainerVector m_BoundaryAssignmentsContainers;

public:
  CellIdentifier GetNumberOfCells() const;

  void PassStructure(Self *inputMesh);

  virtual void Initialize() ITK_OVERRIDE;

  virtual void CopyInformation(const DataObject *data) ITK_OVERRIDE;

  virtual void Graft(const DataObject *data) ITK_OVERRIDE;

  const BoundingBoxType * GetBoundingBox() const;

  void SetCellLinks(CellLinksContainer *);

  CellLinksContainer * GetCellLinks();

  const CellLinksContainer * GetCellLinks() const;

  void SetCells(CellsContainer *);

  CellsContainer * GetCells();

  const CellsContainer * GetCells() const;

  void SetCellData(CellDataContainer *);

  CellDataContainer *  GetCellData();

  const CellDataContainer * GetCellData() const;

#if !defined( CABLE_CONFIGURATION )

  void SetBoundaryAssignments(int dimension,
                              BoundaryAssignmentsContainer *);


  BoundaryAssignmentsContainerPointer GetBoundaryAssignments(int dimension);

  const BoundaryAssignmentsContainerPointer GetBoundaryAssignments(
    int dimension) const;
#endif

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

  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;

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

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

  CellIdentifier GetCellNeighbors(CellIdentifier cellId,
                                 std::set< CellIdentifier > *cellSet);

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

  void BuildCellLinks() const;

  virtual void Accept(CellMultiVisitorType *mv) const;

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

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

  void ReleaseCellsMemory();

  BoundingBoxPointer m_BoundingBox;

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.hxx"
#endif
#endif

#endif