itkQuadEdgeMeshFrontIterator.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.
 *
 *=========================================================================*/
#ifndef __itkQuadEdgeMeshFrontIterator_h
#define __itkQuadEdgeMeshFrontIterator_h

#include "itkMapContainer.h"

// -------------------------------------------------------------------------
#define itkQEDefineFrontIteratorMethodsMacro(MeshTypeArg)                       \
  /* Dual definition placed before others because of .NET that cannot */        \
  /* cope with definition of FrontIterator (that further hides the    */        \
  /* definition 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 ITK_EXPORT 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; return *this; }
    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++() ); }

  MeshType * GetMesh() const { return this->m_Mesh; }
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 ITK_EXPORT 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 ITK_EXPORT 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.hxx"

#endif