itkQuadEdgeMeshPolygonCell.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkQuadEdgeMeshPolygonCell.h,v $
  Language:  C++
  Date:      $Date: 2007/08/28 15:53:46 $
  Version:   $Revision: 1.14 $

  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 __itkQuadEdgeMeshPolygonCell_h
#define __itkQuadEdgeMeshPolygonCell_h

namespace itk
{

template< class TCellInterface >
class QuadEdgeMeshPolygonCell : public TCellInterface
{
public:
  // itkCellCommonTypedefs
  typedef QuadEdgeMeshPolygonCell   Self;
  typedef AutoPointer< const Self > ConstSelfAutoPointer;
  typedef AutoPointer< Self >       SelfAutoPointer;
  typedef Self*                     RawPointer;
  typedef const Self*               ConstRawPointer;

  // itkCellInheritedTypedefs
  typedef TCellInterface                                Superclass;
  typedef typename Superclass::PixelType                PixelType;
  typedef typename Superclass::CellType                 CellType;
  typedef typename Superclass::CellAutoPointer          CellAutoPointer;
  typedef typename Superclass::CellConstAutoPointer     CellConstAutoPointer;
  typedef typename Superclass::CellRawPointer           CellRawPointer;
  typedef typename Superclass::CellConstRawPointer      CellConstRawPointer;
  typedef typename Superclass::CellTraits               CellTraits;
  typedef typename Superclass::CoordRepType             CoordRepType;
  typedef typename Superclass::InterpolationWeightType  InterpolationWeightType;
  typedef typename Superclass::PointIdentifier          PointIdentifier;
  typedef typename Superclass::CellIdentifier           CellIdentifier;
  typedef typename Superclass::CellFeatureIdentifier    CellFeatureIdentifier;
  typedef typename Superclass::CellFeatureIdentifier    CellFeatureCount;
  typedef typename Superclass::PointType                PointType;
  typedef typename Superclass::PointsContainer          PointsContainer;
  typedef typename Superclass::UsingCellsContainer      UsingCellsContainer;
  typedef typename Superclass::CellGeometry             CellGeometry;
  typedef typename Superclass::ParametricCoordArrayType ParametricCoordArrayType;
  typedef typename Superclass::ShapeFunctionsArrayType  ShapeFunctionsArrayType;
  itkStaticConstMacro( PointDimension, unsigned int, Superclass::PointDimension );
  itkStaticConstMacro( CellDimension, unsigned int, 2 );
  
  typedef typename CellType::MultiVisitor MultiVisitor;

  typedef QuadEdgeMeshLineCell< CellType >               EdgeCellType;
  typedef std::vector< EdgeCellType* >                   EdgeCellListType; 

  typedef typename CellTraits::PointIdIterator              PointIdIterator;
  typedef typename CellTraits::PointIdConstIterator         PointIdConstIterator;
  typedef typename CellTraits::PointIdInternalIterator      PointIdInternalIterator;
  typedef typename CellTraits::PointIdInternalConstIterator PointIdInternalConstIterator;

  typedef typename CellTraits::QuadEdgeType              QuadEdgeType;
  typedef typename QuadEdgeType::OriginRefType           VertexRefType;
  typedef typename QuadEdgeType::DualOriginRefType       FaceRefType;
  typedef typename QuadEdgeType::PrimalDataType          PrimalDataType;
  typedef typename QuadEdgeType::DualDataType            DualDataType;
  typedef typename QuadEdgeType::DualType                QEDual;

public:
  itkTypeMacro( QuadEdgeMeshPolygonCell, TCellInterface );

  QuadEdgeMeshPolygonCell( PointIdentifier nPoints = 0 );
  QuadEdgeMeshPolygonCell( QuadEdgeType* e );
  virtual ~QuadEdgeMeshPolygonCell();

  void SetIdent( CellIdentifier cid ) { m_Ident = cid; }
  CellIdentifier GetIdent()          { return( m_Ident ); }

  QuadEdgeType* GetEdgeRingEntry() const      { return( m_EdgeRingEntry ); }
  void SetEdgeRingEntry( QuadEdgeType* entry ) { m_EdgeRingEntry = entry; }

  SelfAutoPointer New();

  virtual void Accept( unsigned long cellId, MultiVisitor* mv );
  virtual CellGeometry GetType() const { return( Superclass::POLYGON_CELL );}

  static int GetTopologyId()
    {
    return( Superclass::POLYGON_CELL );
    }
  virtual unsigned int GetDimension() const 
    { 
    return( Self::CellDimension );
    }
  virtual unsigned int GetNumberOfPoints() const;
  virtual CellFeatureCount GetNumberOfBoundaryFeatures( int dimension ) const;
  virtual bool GetBoundaryFeature( int dimension,
                                   CellFeatureIdentifier cellId,
                                   CellAutoPointer& cell );

  virtual void MakeCopy( CellAutoPointer& cell ) const 
    { 
    const unsigned long numberOfPoints = this->GetNumberOfPoints();
    Self * newPolygonCell = new Self( numberOfPoints );
    cell.TakeOwnership( newPolygonCell );
    if ( numberOfPoints ) 
      {
      for( unsigned long i = 0; i < numberOfPoints; i++ )
        { 
        newPolygonCell->SetPointId( i, this->GetPointId( i ) );
        }
      }
    }

  
  virtual void SetPointIds( PointIdConstIterator first );
  virtual void SetPointIds( PointIdConstIterator first,
                            PointIdConstIterator last );
  virtual void SetPointId( int localId, PointIdentifier pId );

  virtual PointIdentifier GetPointId( int localId ) const;

  virtual PointIdIterator PointIdsBegin()
    {
    if (m_PointIds.size() >0)
      {
      return &*(m_PointIds.begin());
      }
    else
      {
      return NULL;
      }
    }

  virtual PointIdIterator PointIdsEnd()
    {
    if (m_PointIds.size() >0)
      {
      return &m_PointIds[m_PointIds.size()-1] + 1;
      }
    else
      {
      return NULL;
      }
    }

  virtual PointIdConstIterator PointIdsBegin() const
    {
    if (m_PointIds.size() >0)
      {
      return &*(m_PointIds.begin());
      }
    else
      {
      return NULL;
      }

    }

  virtual PointIdConstIterator PointIdsEnd() const
    {
    if (m_PointIds.size() >0)
      {
      return &m_PointIds[m_PointIds.size()-1] + 1;
      }
    else
      {
      return NULL;
      }
    }

  virtual void InternalSetPointIds( PointIdInternalConstIterator first );
  virtual void InternalSetPointIds( PointIdInternalConstIterator first,
                            PointIdInternalConstIterator last );

  virtual PointIdInternalIterator InternalPointIdsBegin();
  virtual PointIdInternalIterator InternalPointIdsEnd();

  virtual PointIdInternalConstIterator InternalGetPointIds() const;
  virtual PointIdInternalConstIterator InternalPointIdsBegin() const;
  virtual PointIdInternalConstIterator InternalPointIdsEnd() const;

protected:
  std::vector<PointIdentifier>  m_PointIds;
  //std::vector<EdgeInfo> m_Edges;

private:
  QuadEdgeMeshPolygonCell( const Self& ); // Not impl.
  void operator=( const Self& ); // Not impl.

  void MakePointIds()
    {
    if( !this->GetNumberOfPoints( ) )
      {
      return;
      }

    // NOTE ALEX: very inefficient way of doing it ...
    for( PointIdentifier i = 0; i < this->GetNumberOfPoints( ); i++ )
      {
      m_PointIds.push_back( GetPointId( i ) );
      }
    }

  CellIdentifier m_Ident;

  QuadEdgeType * m_EdgeRingEntry;

  EdgeCellListType m_EdgeCellList;

};

} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkQuadEdgeMeshPolygonCell.txx"
#endif

#endif

---