ITK  5.4.0
Insight Toolkit
itkQuadEdgeMeshFrontIterator.h
Go to the documentation of this file.
1/*=========================================================================
2 *
3 * Copyright NumFOCUS
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * https://www.apache.org/licenses/LICENSE-2.0.txt
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *=========================================================================*/
18#ifndef itkQuadEdgeMeshFrontIterator_h
19#define itkQuadEdgeMeshFrontIterator_h
20
21#include "itkMapContainer.h"
22
23// -------------------------------------------------------------------------
24#define itkQEDefineFrontIteratorMethodsMacro(MeshTypeArg) \
25 /* Dual definition placed before others because of .NET that cannot */ \
26 /* cope with definition of FrontIterator (that further hides the */ \
27 /* definition of the template). */ \
28 using QEDualType = typename MeshTypeArg::QEDual; \
29 using QEPrimalType = typename MeshTypeArg::QEPrimal; \
30 using FrontDualIterator = QuadEdgeMeshFrontIterator<MeshTypeArg, QEDualType>; \
31 using ConstFrontDualIterator = QuadEdgeMeshConstFrontIterator<MeshTypeArg, QEDualType>; \
32 using FrontIterator = QuadEdgeMeshFrontIterator<MeshTypeArg, QEPrimalType>; \
33 using ConstFrontIterator = QuadEdgeMeshConstFrontIterator<MeshTypeArg, QEPrimalType>; \
34 \
35 virtual FrontIterator BeginFront(QEPrimalType * seed = (QEPrimalType *)0) \
36 { \
37 return (FrontIterator(this, true, seed)); \
38 } \
39 \
40 virtual ConstFrontIterator BeginFront(QEPrimalType * seed) const { return (ConstFrontIterator(this, true, seed)); } \
41 \
42 virtual FrontIterator EndFront() { return (FrontIterator(this, false)); } \
43 \
44 virtual ConstFrontIterator EndFront() const { return (ConstFrontIterator(this, false)); } \
45 \
46 virtual FrontDualIterator BeginDualFront(QEDualType * seed = (QEDualType *)0) \
47 { \
48 return (FrontDualIterator(this, true, seed)); \
49 } \
50 \
51 virtual ConstFrontDualIterator BeginDualFront(QEDualType * seed) const \
52 { \
53 return (ConstFrontDualIterator(this, true, seed)); \
54 } \
55 \
56 virtual FrontDualIterator EndDualFront() { return (FrontDualIterator(this, false)); } \
57 \
58 virtual ConstFrontDualIterator EndDualFront() const { return (ConstFrontDualIterator(this, false)); }
59
60namespace itk
61{
75template <typename TMesh, typename TQE>
76class ITK_TEMPLATE_EXPORT QuadEdgeMeshFrontBaseIterator
77{
78public:
79 // Hierarchy type alias & values.
81
82 // Template types
83 using MeshType = TMesh;
84 using QEType = TQE;
85
86protected:
87 // Mesh types
88 using CoordRepType = typename MeshType::CoordRepType;
89 // QE types
90 using QEOriginType = typename QEType::OriginRefType;
91
102 {
103 public:
104 FrontAtom(QEType * e = (QEType *)0, const CoordRepType c = 0)
105 : m_Edge(e)
106 , m_Cost(c)
107 {}
108 virtual ~FrontAtom() = default;
109 FrontAtom &
111 {
112 m_Edge = r.m_Edge;
113 m_Cost = r.m_Cost;
114 return *this;
115 }
116 bool
117 operator==(const FrontAtom & r) const
118 {
119 return (m_Edge == r.m_Edge);
120 }
124
125 bool
126 operator<(const FrontAtom & r) const
127 {
128 return (m_Cost < r.m_Cost);
129 }
130
131 public:
134 };
135
139 using FrontType = std::list<FrontAtom>;
140 using FrontTypeIterator = typename FrontType::iterator;
142
148
149public:
152 bool start = true,
153 QEType * seed = (QEType *)nullptr);
157 Self &
158 operator=(const Self & r)
159 {
160 if (this != &r)
161 {
162 m_Mesh = r.m_Mesh;
163 m_Start = r.m_Start;
164 m_Seed = r.m_Seed;
165 m_Front = r.m_Front;
166 m_IsPointVisited = r.m_IsPointVisited;
167 m_CurrentEdge = r.m_CurrentEdge;
168 }
169 return (*this);
170 }
171
172 // Iteration methods.
173 bool
174 operator==(const Self & r) const
175 {
176 return (m_Start == r.m_Start);
177 }
178
180
181 Self &
183
184 Self &
186 {
187 return (this->operator++());
188 }
189
190 MeshType *
191 GetMesh() const
192 {
193 return this->m_Mesh;
194 }
195
196protected:
200 QEType *
202
206 virtual CoordRepType
208 {
209 (void)edge;
210 return (1);
211 }
214protected:
216 MeshType * m_Mesh{};
217
219 QEType * m_Seed{};
220
222 bool m_Start{};
223
226
228 IsVisitedPointerType m_IsPointVisited{};
229
231 QEType * m_CurrentEdge{};
232};
233
240template <typename TMesh, typename TQE>
241class ITK_TEMPLATE_EXPORT QuadEdgeMeshFrontIterator : public QuadEdgeMeshFrontBaseIterator<TMesh, TQE>
242{
243public:
244
248 using typename Superclass::MeshType;
249 using typename Superclass::QEType;
250
251public:
253 QuadEdgeMeshFrontIterator(MeshType * mesh = (MeshType *)0, bool start = true, QEType * seed = (QEType *)nullptr)
254 : Superclass(mesh, start, seed)
255 {}
256 ~QuadEdgeMeshFrontIterator() override = default;
257 QEType *
259 {
260 return (this->m_CurrentEdge);
261 }
262};
271template <typename TMesh, typename TQE = typename TMesh::QEType>
272class ITK_TEMPLATE_EXPORT QuadEdgeMeshConstFrontIterator : public QuadEdgeMeshFrontBaseIterator<TMesh, TQE>
273{
274public:
275
279 using typename Superclass::QEType;
280 using typename Superclass::MeshType;
282
283public:
286 bool start = true,
287 QEType * seed = (QEType *)nullptr)
288 {
289 (void)mesh;
290 (void)start;
291 (void)seed;
292 }
297 Self &
299 {
300 this->m_Mesh = r.GetMesh();
301 return (*this);
302 }
305 const QEType *
306 Value() const
307 {
308 return (this->m_CurrentEdge);
309 }
310};
311} // namespace itk
312
313#include "itkQuadEdgeMeshFrontIterator.hxx"
314
315#endif
A wrapper of the STL "map" container.
Const quad edge mesh front iterator.
QuadEdgeMeshConstFrontIterator(const MeshType *mesh=(MeshType *) 0, bool start=true, QEType *seed=(QEType *) nullptr)
~QuadEdgeMeshConstFrontIterator() override=default
Atomic information associated to each edge of the front.
FrontAtom(QEType *e=(QEType *) 0, const CoordRepType c=0)
QuadEdgeMeshFrontBaseIterator(MeshType *mesh=(MeshType *) nullptr, bool start=true, QEType *seed=(QEType *) nullptr)
typename FrontType::iterator FrontTypeIterator
typename MeshType::CoordRepType CoordRepType
typename IsVisitedContainerType::Pointer IsVisitedPointerType
virtual CoordRepType GetCost(QEType *edge)
typename QEType::OriginRefType QEOriginType
Non const quad edge front iterator.
QuadEdgeMeshFrontIterator(MeshType *mesh=(MeshType *) 0, bool start=true, QEType *seed=(QEType *) nullptr)
~QuadEdgeMeshFrontIterator() override=default
SmartPointer< Self > Pointer
static constexpr double e
Definition: itkMath.h:56
The "itk" namespace contains all Insight Segmentation and Registration Toolkit (ITK) classes....
bool operator<(const Index< VDimension > &one, const Index< VDimension > &two)
Definition: itkIndex.h:559