ITK  4.6.0
Insight Segmentation and Registration Toolkit
itkQuadEdgeMeshFrontIterator.h
Go to the documentation of this file.
1 /*=========================================================================
2  *
3  * Copyright Insight Software Consortium
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  * http://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  typedef typename MeshTypeArg::QEDual QEDualType; \
29  typedef typename MeshTypeArg::QEPrimal QEPrimalType; \
30  typedef QuadEdgeMeshFrontIterator< MeshTypeArg, \
31  QEDualType > FrontDualIterator; \
32  typedef QuadEdgeMeshConstFrontIterator< MeshTypeArg, \
33  QEDualType > \
34  ConstFrontDualIterator; \
35  typedef QuadEdgeMeshFrontIterator< MeshTypeArg, \
36  QEPrimalType > FrontIterator; \
37  typedef QuadEdgeMeshConstFrontIterator< MeshTypeArg, \
38  QEPrimalType > \
39  ConstFrontIterator; \
40  \
41  virtual FrontIterator BeginFront(QEPrimalType * seed = (QEPrimalType *)0) \
42  { \
43  return ( FrontIterator(this, true, seed) ); \
44  } \
45  \
46  virtual ConstFrontIterator BeginFront(QEPrimalType * seed) const \
47  { return ( ConstFrontIterator(this, true, seed) ); } \
48  \
49  virtual FrontIterator EndFront() \
50  { \
51  return ( FrontIterator(this, false) ); \
52  } \
53  \
54  virtual ConstFrontIterator EndFront() const \
55  { return ( ConstFrontIterator(this, false) ); } \
56  \
57  virtual FrontDualIterator BeginDualFront(QEDualType * seed = (QEDualType *)0) \
58  { \
59  return ( FrontDualIterator(this, true, seed) ); \
60  } \
61  \
62  virtual ConstFrontDualIterator BeginDualFront(QEDualType * seed) const \
63  { return ( ConstFrontDualIterator(this, true, seed) ); } \
64  \
65  virtual FrontDualIterator EndDualFront() \
66  { \
67  return ( FrontDualIterator(this, false) ); \
68  } \
69  \
70  virtual ConstFrontDualIterator EndDualFront() const \
71  { return ( ConstFrontDualIterator(this, false) ); }
72 
73 namespace itk
74 {
88 template< typename TMesh, typename TQE >
90 {
91 public:
92  // Hierarchy typedefs & values.
94 
95  // Template types
96  typedef TMesh MeshType;
97  typedef TQE QEType;
98 
99 protected:
100  // Mesh types
101  typedef typename MeshType::CoordRepType CoordRepType;
102  // QE types
103  typedef typename QEType::OriginRefType QEOriginType;
104 
114  class FrontAtom
115  {
116 public:
117  FrontAtom(QEType *e = (QEType *)0, const CoordRepType c = 0):
118  m_Edge(e), m_Cost(c)
119  {}
120  virtual ~FrontAtom() {}
122  { m_Edge = r.m_Edge; m_Cost = r.m_Cost; return *this; }
123  bool operator==(const FrontAtom & r) const
124  { return ( m_Edge == r.m_Edge ); }
125  bool operator!=(const FrontAtom & r) const
126  { return ( m_Edge != r.m_Edge ); }
127  bool operator<(const FrontAtom & r) const
128  { return ( m_Cost < r.m_Cost ); }
130 
131 public:
134  };
135 
139  typedef std::list< FrontAtom > FrontType;
140  typedef typename FrontType::iterator FrontTypeIterator;
142 
148 
149 public:
152  bool start = true,
153  QEType *seed = (QEType *)0);
156 
157  Self & operator=(const Self & r)
158  {
159  if(this != &r)
160  {
161  m_Mesh = r.m_Mesh;
162  m_Start = r.m_Start;
163  m_Seed = r.m_Seed;
164  m_Front = r.m_Front;
167  }
168  return ( *this );
169  }
170 
171  // Iteration methods.
172  bool operator==(Self & r)
173  {
174  return ( m_Start == r.m_Start );
175  }
176 
177  bool operator==(const Self & r) const
178  {
179  return ( m_Start == r.m_Start );
180  }
181 
182  bool operator!=(Self & r)
183  {
184  return ( !( this->operator==(r) ) );
185  }
186 
187  bool operator!=(const Self & r) const
188  {
189  return ( !( this->operator==(r) ) );
190  }
191 
192  Self & operator++();
193 
194  Self & operator++(int) { return ( this->operator++() ); }
195 
196  MeshType * GetMesh() const { return this->m_Mesh; }
197 
198 protected:
203 
207  virtual CoordRepType GetCost(QEType *edge){ (void)edge; return ( 1 ); }
208 
209 protected:
212 
215 
217  bool m_Start;
218 
221 
224 
227 };
228 
235 template< typename TMesh, typename TQE >
237  public QuadEdgeMeshFrontBaseIterator< TMesh, TQE >
238 {
239 public:
240 
244  typedef typename Superclass::MeshType MeshType;
245  typedef typename Superclass::QEType QEType;
246 
247 public:
250  bool start = true,
251  QEType *seed = (QEType *)0):
252  Superclass(mesh, start, seed) {}
254  QEType * Value() { return ( this->m_CurrentEdge ); }
255 };
257 
264 template< typename TMesh, typename TQE = typename TMesh::QEType >
266  public QuadEdgeMeshFrontBaseIterator< TMesh, TQE >
267 {
268 public:
269 
273  typedef typename Superclass::QEType QEType;
274  typedef typename Superclass::MeshType MeshType;
276 
277 public:
280  bool start = true,
281  QEType *seed = (QEType *)0)
282  {
283  (void)mesh;
284  (void)start;
285  (void)seed;
286  }
288 
292  {
293  this->m_Mesh = r.GetMesh();
294  return ( *this );
295  }
297 
298  const QEType * Value() const { return ( this->m_CurrentEdge ); }
299 };
300 }
301 
302 #include "itkQuadEdgeMeshFrontIterator.hxx"
303 
304 #endif
IsVisitedContainerType::Pointer IsVisitedPointerType
A wrapper of the STL &quot;map&quot; container.
MapContainer< QEOriginType, bool > IsVisitedContainerType
static const double e
The base of the natural logarithm or Euler&#39;s number
Definition: itkMath.h:45
FrontAtom(QEType *e=(QEType *) 0, const CoordRepType c=0)
QuadEdgeMeshFrontIterator< MeshType, QEType > NoConstType
Const quad edge mesh front iterator.
QuadEdgeMeshConstFrontIterator(const MeshType *mesh=(MeshType *) 0, bool start=true, QEType *seed=(QEType *) 0)
QuadEdgeMeshFrontBaseIterator< TMesh, TQE > Superclass
QuadEdgeMeshFrontIterator(MeshType *mesh=(MeshType *) 0, bool start=true, QEType *seed=(QEType *) 0)
QuadEdgeMeshFrontBaseIterator(MeshType *mesh=(MeshType *) 0, bool start=true, QEType *seed=(QEType *) 0)
Atomic information associated to each edge of the front.
QuadEdgeMeshFrontBaseIterator< TMesh, TQE > Superclass
Non const quad edge front iterator.
virtual CoordRepType GetCost(QEType *edge)