itkQuadEdgeMeshFrontIterator.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkQuadEdgeMeshFrontIterator.h,v $
  Language:  C++
  Date:      $Date: 2007/06/27 19:06:04 $
  Version:   $Revision: 1.4 $

  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.

=========================================================================*/
// -------------------------------------------------------------------------
// This code is an implementation of the well known quad edge (QE) data
// structure in the ITK library. Although the original QE can handle non
// orientable 2-manifolds and its dual and its mirror, this implementation
// is specifically dedicated to handle orientable 2-manifolds along with
// their dual.
//
// Any comment, criticism and/or donation is welcome.
//
// Please contact any member of the team:
//
// - The frog master (Eric Boix)       eboix@ens-lyon.fr
// - The duck master (Alex Gouaillard) alexandre.gouaillard@sun.com
// - The cow  master (Leonardo Florez) florez@creatis.insa-lyon.fr
// -------------------------------------------------------------------------

#ifndef __itkQuadEdgeMeshFrontIterator_h
#define __itkQuadEdgeMeshFrontIterator_h

// -------------------------------------------------------------------------
#define itkQEDefineFrontIteratorMethodsMacro( MeshTypeArg )                  \
    /* Dual definition placed before others because of .NET that cannot */   \
    /* cope with definition of FrontIterator (that further hides the    */   \
    /* defintion of the template).                                      */   \
    typedef typename MeshTypeArg::QEDual QEDualType;                         \
    typedef typename MeshTypeArg::QEPrimal QEPrimalType;                     \
    typedef QuadEdgeMeshFrontIterator< MeshTypeArg,                          \
                                             QEDualType > FrontDualIterator; \
    typedef QuadEdgeMeshConstFrontIterator< MeshTypeArg,                     \
                                                  QEDualType >               \
                                                     ConstFrontDualIterator; \
    typedef QuadEdgeMeshFrontIterator< MeshTypeArg,                          \
                                             QEPrimalType >   FrontIterator; \
    typedef QuadEdgeMeshConstFrontIterator< MeshTypeArg,                     \
                                                  QEPrimalType >             \
                                                         ConstFrontIterator; \
                                                                             \
    virtual FrontIterator BeginFront( QEPrimalType* seed =(QEPrimalType*)0 ) \
    { return( FrontIterator( this, true, seed ) ); }                         \
                                                                             \
    virtual ConstFrontIterator BeginFront( QEPrimalType* seed ) const        \
    { return( ConstFrontIterator( this, true, seed ) ); }                    \
                                                                             \
    virtual FrontIterator EndFront( )                                        \
    { return( FrontIterator( this, false ) ); }                              \
                                                                             \
    virtual ConstFrontIterator EndFront( ) const                             \
    { return( ConstFrontIterator( this, false ) ); }                         \
                                                                             \
    virtual FrontDualIterator BeginDualFront( QEDualType* seed =(QEDualType*) 0 )    \
    { return( FrontDualIterator( this, true, seed ) ); }                     \
                                                                             \
    virtual ConstFrontDualIterator BeginDualFront( QEDualType* seed ) const      \
    { return( ConstFrontDualIterator( this, true, seed ) ); }                \
                                                                             \
    virtual FrontDualIterator EndDualFront( )                                \
    { return( FrontDualIterator( this, false ) ); }                          \
                                                                             \
    virtual ConstFrontDualIterator EndDualFront( ) const                     \
    { return( ConstFrontDualIterator( this, false ) ); }

namespace itk
{

template< typename TMesh, typename TQE >
class QuadEdgeMeshFrontBaseIterator
{
public:
  // Hierarchy typedefs & values.
  typedef QuadEdgeMeshFrontBaseIterator Self;

  // Template types
  typedef TMesh  MeshType;
  typedef TQE    QEType;

protected:
  // Mesh types
  typedef typename MeshType::CoordRepType    CoordRepType;
  // QE types
  typedef typename QEType::OriginRefType     QEOriginType;

  class FrontAtom
    {
    public:
    FrontAtom( QEType* e = (QEType*)0, const CoordRepType c = 0 )
      : m_Edge( e ), m_Cost( c )
      { }
      virtual ~FrontAtom( ) { }
      FrontAtom& operator=( const FrontAtom& r )
      { m_Edge = r.m_Edge; m_Cost = r.m_Cost; }
      bool operator==( const FrontAtom& r ) const
      { return( m_Edge == r.m_Edge ); }
      bool operator!=( const FrontAtom& r ) const
      { return( m_Edge != r.m_Edge ); }
      bool operator<( const FrontAtom& r ) const
      { return( m_Cost < r.m_Cost ); }

    public:
      QEType*      m_Edge;
      CoordRepType m_Cost;
  };

  typedef std::list< FrontAtom >       FrontType;
  typedef typename FrontType::iterator FrontTypeIterator;
  typedef FrontType*                   FrontTypePointer;

  typedef MapContainer< QEOriginType, bool >       IsVisitedContainerType;
  typedef typename IsVisitedContainerType::Pointer IsVisitedPointerType;

public:
  QuadEdgeMeshFrontBaseIterator( MeshType* mesh  = (MeshType*)0,
                                 bool      start = true,
                                 QEType*   seed  = (QEType*)0 );
  virtual ~QuadEdgeMeshFrontBaseIterator( ) { }

  Self& operator=( const Self& r )
    {
    m_Mesh  = r.m_Mesh;
    m_Start = r.m_Start;
    m_Seed  = r.m_Seed;
    m_Front = r.m_Front;
    m_IsPointVisited = r.m_IsPointVisited;
    m_CurrentEdge = r.m_CurrentEdge;
    return( *this );
    }

  // Iteration methods.
  bool operator==( Self & r )
    {
    return( m_Start == r.m_Start );
    }

  bool operator==( const Self & r ) const
    {
    return( m_Start == r.m_Start );
    }

  bool operator!=( Self & r )
    {
    return( !( this->operator==( r ) ) );
    }

  bool operator!=( const Self & r ) const
    {
    return( !( this->operator==( r ) ) );
    }

  Self & operator++( );

  Self & operator++( int ) { return( this->operator++( ) ); }

protected:
  QEType* FindDefaultSeed( );

  virtual CoordRepType GetCost( QEType* edge ){ (void)edge; return( 1 ); }

protected:
  MeshType* m_Mesh;
  QEType* m_Seed;
  bool m_Start;
  FrontTypePointer m_Front;
  IsVisitedPointerType m_IsPointVisited;
  QEType* m_CurrentEdge;
};

template< typename TMesh, typename TQE >
class QuadEdgeMeshFrontIterator
  : public QuadEdgeMeshFrontBaseIterator< TMesh, TQE  >
{
public:

  typedef QuadEdgeMeshFrontIterator                   Self;
  typedef QuadEdgeMeshFrontBaseIterator< TMesh, TQE > Superclass;
  typedef typename Superclass::MeshType               MeshType;
  typedef typename Superclass::QEType                 QEType;

public:
  QuadEdgeMeshFrontIterator( MeshType* mesh = (MeshType*)0,
                             bool      start = true,
                             QEType*   seed  = (QEType*)0 )
    : Superclass( mesh, start, seed ) { }
  virtual ~QuadEdgeMeshFrontIterator( ) { }
  QEType* Value( ) { return( this->m_CurrentEdge ); }
};

template< class TMesh, class TQE = typename TMesh::QEType >
class QuadEdgeMeshConstFrontIterator
  : public QuadEdgeMeshFrontBaseIterator< TMesh, TQE >
{
public:

  typedef QuadEdgeMeshConstFrontIterator                Self;
  typedef QuadEdgeMeshFrontBaseIterator< TMesh, TQE >   Superclass;
  typedef typename Superclass::QEType                   QEType;
  typedef typename Superclass::MeshType                 MeshType;
  typedef QuadEdgeMeshFrontIterator< MeshType, QEType > NoConstType;

public:
  QuadEdgeMeshConstFrontIterator( const MeshType* mesh = (MeshType*)0,
                                  bool     start = true,
                                  QEType*  seed  = (QEType*)0 )
    {
    (void)mesh;
    (void)start;
    (void)seed;
    }

  virtual ~QuadEdgeMeshConstFrontIterator( ) { }
  Self& operator=( const NoConstType& r )
    {
    this->m_Mesh  = r.GetMesh( );
    return( *this );
    }
  const QEType* Value( ) const { return( this->m_CurrentEdge ); }
};

} 

#include "itkQuadEdgeMeshFrontIterator.txx"

#endif 

---