itkQuadEdgeMeshFrontIterator.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://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).                                     */                                              \
  using QEDualType = typename MeshTypeArg::QEDual;                                                                    \
  using QEPrimalType = typename MeshTypeArg::QEPrimal;                                                                \
  using FrontDualIterator = QuadEdgeMeshFrontIterator<MeshTypeArg, QEDualType>;                                       \
  using ConstFrontDualIterator = QuadEdgeMeshConstFrontIterator<MeshTypeArg, QEDualType>;                             \
  using FrontIterator = QuadEdgeMeshFrontIterator<MeshTypeArg, QEPrimalType>;                                         \
  using ConstFrontIterator = QuadEdgeMeshConstFrontIterator<MeshTypeArg, QEPrimalType>;                               \
                                                                                                                      \
  virtual FrontIterator BeginFront(QEPrimalType * seed = (QEPrimalType *)nullptr)                                     \
  {                                                                                                                   \
    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)); }               \
                                                                                                                      \
  ITK_MACROEND_NOOP_STATEMENT
 
namespace itk
{
template <typename TMesh, typename TQE>
class ITK_TEMPLATE_EXPORT QuadEdgeMeshFrontBaseIterator
{
public:
  // Hierarchy type alias & values.
  using Self = QuadEdgeMeshFrontBaseIterator;
 
  // Template types
  using MeshType = TMesh;
  using QEType = TQE;
 
protected:
  // Mesh types
  using CoordRepType = typename MeshType::CoordRepType;
  // QE types
  using QEOriginType = typename QEType::OriginRefType;
 
  class FrontAtom
  {
  public:
    FrontAtom(QEType * e = (QEType *)0, const CoordRepType c = 0)
      : m_Edge(e)
      , m_Cost(c)
    {}
    virtual ~FrontAtom() = default;
    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);
    }
    ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(FrontAtom);
 
    bool
    operator<(const FrontAtom & r) const
    {
      return (m_Cost < r.m_Cost);
    }
 
  public:
    QEType *     m_Edge;
    CoordRepType m_Cost;
  };
 
  using FrontType = std::list<FrontAtom>;
  using FrontTypeIterator = typename FrontType::iterator;
  using FrontTypePointer = FrontType *;
 
  using IsVisitedContainerType = MapContainer<QEOriginType, bool>;
  using IsVisitedPointerType = typename IsVisitedContainerType::Pointer;
 
public:
  QuadEdgeMeshFrontBaseIterator(MeshType * mesh = (MeshType *)nullptr,
                                bool       start = true,
                                QEType *   seed = (QEType *)nullptr);
  virtual ~QuadEdgeMeshFrontBaseIterator();
  Self &
  operator=(const Self & r)
  {
    if (this != &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==(const Self & r) const
  {
    return (m_Start == r.m_Start);
  }
 
  ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(Self);
 
  Self &
  operator++();
 
  Self &
  operator++(int)
  {
    return (this->operator++());
  }
 
  MeshType *
  GetMesh() const
  {
    return this->m_Mesh;
  }
 
protected:
  QEType *
  FindDefaultSeed();
 
  virtual CoordRepType
  GetCost(QEType * itkNotUsed(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_TEMPLATE_EXPORT QuadEdgeMeshFrontIterator : public QuadEdgeMeshFrontBaseIterator<TMesh, TQE>
{
public:
 
  using Self = QuadEdgeMeshFrontIterator;
  using Superclass = QuadEdgeMeshFrontBaseIterator<TMesh, TQE>;
  using typename Superclass::MeshType;
  using typename Superclass::QEType;
 
public:
  QuadEdgeMeshFrontIterator(MeshType * mesh = (MeshType *)0, bool start = true, QEType * seed = (QEType *)nullptr)
    : Superclass(mesh, start, seed)
  {}
  ~QuadEdgeMeshFrontIterator() override = default;
  QEType *
  Value()
  {
    return (this->m_CurrentEdge);
  }
};
template <typename TMesh, typename TQE = typename TMesh::QEType>
class ITK_TEMPLATE_EXPORT QuadEdgeMeshConstFrontIterator : public QuadEdgeMeshFrontBaseIterator<TMesh, TQE>
{
public:
 
  using Self = QuadEdgeMeshConstFrontIterator;
  using Superclass = QuadEdgeMeshFrontBaseIterator<TMesh, TQE>;
  using typename Superclass::QEType;
  using typename Superclass::MeshType;
  using NoConstType = QuadEdgeMeshFrontIterator<MeshType, QEType>;
 
public:
  QuadEdgeMeshConstFrontIterator(const MeshType * itkNotUsed(mesh) = (MeshType *)0,
                                 bool             itkNotUsed(start) = true,
                                 QEType *         itkNotUsed(seed) = (QEType *)nullptr)
  {}
 
  ~QuadEdgeMeshConstFrontIterator() override = default;
  Self &
  operator=(const NoConstType & r)
  {
    this->m_Mesh = r.GetMesh();
    return (*this);
  }
  const QEType *
  Value() const
  {
    return (this->m_CurrentEdge);
  }
};
} // namespace itk
 
#include "itkQuadEdgeMeshFrontIterator.hxx"
 
#endif