ITK  5.2.0
Insight Toolkit
itkQuadEdgeMesh.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  * 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 itkQuadEdgeMesh_h
19 #define itkQuadEdgeMesh_h
20 
21 #include <cstdarg>
22 #include <queue>
23 #include <vector>
24 #include <list>
25 
26 #include "itkMesh.h"
27 
28 #include "itkQuadEdgeMeshTraits.h"
31 
33 #include "itkConceptChecking.h"
34 
35 
36 namespace itk
37 {
50 template <typename TPixel,
51  unsigned int VDimension,
52  typename TTraits = QuadEdgeMeshTraits<TPixel, VDimension, bool, bool>>
53 class ITK_TEMPLATE_EXPORT QuadEdgeMesh : public Mesh<TPixel, VDimension, TTraits>
54 {
55 public:
56  ITK_DISALLOW_COPY_AND_MOVE(QuadEdgeMesh);
57 
59  using Traits = TTraits;
60  using PixelType = TPixel;
61 
63  using Self = QuadEdgeMesh;
67 
69  static constexpr unsigned int PointDimension = Traits::PointDimension;
70  static constexpr unsigned int MaxTopologicalDimension = Traits::MaxTopologicalDimension;
71 
73  using CellPixelType = typename Superclass::CellPixelType;
74  using CoordRepType = typename Superclass::CoordRepType;
75  using PointIdentifier = typename Superclass::PointIdentifier;
76  using PointHashType = typename Superclass::PointHashType;
77  using PointType = typename Superclass::PointType;
78  using CellTraits = typename Superclass::CellTraits;
79 
80  using PointIdInternalIterator = typename CellTraits::PointIdInternalIterator;
81  using PointIdIterator = typename CellTraits::PointIdIterator;
82 
83  // Point section:
84  using PointsContainer = typename Superclass::PointsContainer;
85  using PointsContainerPointer = typename Superclass::PointsContainerPointer;
86  using CoordRepArrayType = CoordRepType[Self::PointDimension];
87 
88  // Point data section:
89  using PointDataContainer = typename Superclass::PointDataContainer;
90  using PointDataContainerPointer = typename Superclass::PointDataContainerPointer;
91  using PointDataContainerIterator = typename Superclass::PointDataContainerIterator;
92  using PointsContainerConstIterator = typename Superclass::PointsContainerConstIterator;
93  using PointsContainerIterator = typename Superclass::PointsContainerIterator;
94 
95  // Cell section:
97  using CellType = typename Superclass::CellType;
98  using CellAutoPointer = typename Superclass::CellAutoPointer;
99  using CellFeatureIdentifier = typename Superclass::CellFeatureIdentifier;
100  using CellFeatureCount = typename Superclass::CellFeatureCount;
101  using CellMultiVisitorType = typename Superclass::CellMultiVisitorType;
102  using CellsContainer = typename Superclass::CellsContainer;
104 
105  using CellsContainerConstIterator = typename Superclass::CellsContainerConstIterator;
106  using CellsContainerIterator = typename Superclass::CellsContainerIterator;
107 
108  using CellLinksContainer = typename Superclass::CellLinksContainer;
109  using CellLinksContainerPointer = typename Superclass::CellLinksContainerPointer;
110  using CellLinksContainerIterator = typename Superclass::CellLinksContainerIterator;
111 
112  // Cell data section:
113  using CellDataContainer = typename Superclass::CellDataContainer;
114  using CellDataContainerPointer = typename Superclass::CellDataContainerPointer;
115  using CellDataContainerIterator = typename Superclass::CellDataContainerIterator;
116 
117  // Point / Cell correspondence section:
118  using PointCellLinksContainer = typename Superclass::PointCellLinksContainer;
119  using PointCellLinksContainerIterator = typename Superclass::PointCellLinksContainerIterator;
120 
121  // BoundaryAssignMents section:
122  using BoundaryAssignmentsContainer = typename Superclass::BoundaryAssignmentsContainer;
123  using BoundaryAssignmentsContainerPointer = typename Superclass::BoundaryAssignmentsContainerPointer;
124  using BoundaryAssignmentsContainerVector = typename Superclass::BoundaryAssignmentsContainerVector;
125 
126  // Miscellaneous section:
127  using BoundingBoxPointer = typename Superclass::BoundingBoxPointer;
128  using BoundingBoxType = typename Superclass::BoundingBoxType;
130  using InterpolationWeightType = typename Superclass::InterpolationWeightType;
131 
133  using PrimalDataType = typename Traits::PrimalDataType;
134  using DualDataType = typename Traits::DualDataType;
135  using QEPrimal = typename Traits::QEPrimal;
136  using QEDual = typename Traits::QEDual;
137  using QEType = typename Traits::QEPrimal;
138  // See the TODO entry dated from 2005-05-28
139  // struct QEType : public QEPrimal, public QEDual {}
140  using VertexRefType = typename Traits::VertexRefType;
141  using FaceRefType = typename Traits::FaceRefType;
142  using VectorType = typename Traits::VectorType;
143 
147 
149  using FreePointIndexesType = std::queue<PointIdentifier>;
150  using FreeCellIndexesType = std::queue<CellIdentifier>;
151 
153  using PointIdList = std::vector<PointIdentifier>;
154  using EdgeListType = std::list<QEPrimal *>;
156 
158 
161 
163  static const CellIdentifier m_NoFace;
164 
165 public:
167  itkNewMacro(Self);
168  itkTypeMacro(QuadEdgeMesh, Mesh);
170 
171 #if !defined(ITK_WRAPPING_PARSER)
172 
174 #endif
175 
176 public:
177  // Multithreading framework: not tested yet.
178  bool
180  {
181  return (false);
182  }
183 
184  void
185  Initialize() override;
186 
188  virtual void
189  Clear();
190 
191  CellsContainer *
193  {
194  return m_EdgeCellsContainer;
195  }
196  const CellsContainer *
197  GetEdgeCells() const
198  {
199  return m_EdgeCellsContainer;
200  }
201  void
203  {
204  m_EdgeCellsContainer = edgeCells;
205  }
206  void
208  {
209  m_EdgeCellsContainer->InsertElement(cellId, cellPointer.ReleaseOwnership());
210  }
211 
218  void
219  CopyInformation(const DataObject * data) override
220  {
221  (void)data;
222  }
223  void
224  Graft(const DataObject * data) override;
226 
228  void
229  SqueezePointsIds();
230 
232  void
234  {}
235 
236 #if !defined(ITK_WRAPPING_PARSER)
237 
238  void
240  {
241  (void)dimension;
242  (void)container;
243  }
245 
247  BoundaryAssignmentsContainerPointer
248  GetBoundaryAssignments(int dimension)
249  {
250  (void)dimension;
251  return (nullptr);
252  }
254 
256  const BoundaryAssignmentsContainerPointer
257  GetBoundaryAssignments(int dimension) const
258  {
259  (void)dimension;
260  return (nullptr);
261  }
263 
264 #endif
265 
267  void
268  SetBoundaryAssignment(int dimension,
269  CellIdentifier cellId,
270  CellFeatureIdentifier featureId,
271  CellIdentifier boundaryId)
272  {
273  (void)dimension;
274  (void)cellId;
275  (void)featureId;
276  (void)boundaryId;
277  }
279 
281  bool
282  GetBoundaryAssignment(int dimension,
283  CellIdentifier cellId,
284  CellFeatureIdentifier featureId,
285  CellIdentifier * boundaryId) const
286  {
287  (void)dimension;
288  (void)cellId;
289  (void)featureId;
290  (void)boundaryId;
291  return (false); // ALEX: is it the good way?
292  }
294 
296  bool
298  {
299  (void)dimension;
300  (void)cellId;
301  (void)featureId;
302  return (false); // ALEX: is it the good way?
303  }
305 
307  bool
308  GetCellBoundaryFeature(int dimension,
309  CellIdentifier cellId,
310  CellFeatureIdentifier featureId,
311  CellAutoPointer & cellAP) const
312  {
313  (void)dimension;
314  (void)cellId;
315  (void)featureId;
316  (void)cellAP;
317  return (false);
318  }
320 
322  CellIdentifier
324  CellIdentifier cellId,
325  CellFeatureIdentifier featureId,
326  std::set<CellIdentifier> * cellSet)
327  {
328  (void)dimension;
329  (void)cellId;
330  (void)featureId;
331  (void)cellSet;
333  }
335 
337  CellIdentifier
338  GetCellNeighbors(CellIdentifier itkNotUsed(cellId), std::set<CellIdentifier> * itkNotUsed(cellSet))
339  {
341  }
342 
344  bool
346  CellIdentifier cellId,
347  CellFeatureIdentifier featureId,
348  CellAutoPointer & cellAP) const
349  {
350  (void)dimension;
351  (void)cellId;
352  (void)featureId;
353  (void)cellAP;
354  return (false); // ALEX: is it the good way?
355  }
357 
359  void
360  SetCell(CellIdentifier cId, CellAutoPointer & cell);
361 
363  virtual PointIdentifier
364  FindFirstUnusedPointIndex();
365 
366  virtual CellIdentifier
367  FindFirstUnusedCellIndex();
368 
369  virtual void
370  PushOnContainer(EdgeCellType * newEdge);
371 
372  // Adding Point/Edge/Face methods
373  virtual PointIdentifier
374  AddPoint(const PointType & p);
375 
377  virtual QEPrimal *
378  AddEdge(const PointIdentifier & orgPid, const PointIdentifier & destPid);
379 
380  virtual QEPrimal *
381  AddEdgeWithSecurePointList(const PointIdentifier & orgPid, const PointIdentifier & destPid);
382 
384  virtual void
385  AddFace(QEPrimal * e);
386 
391  virtual QEPrimal *
392  AddFace(const PointIdList & points);
393 
394  virtual QEPrimal *
395  AddFaceWithSecurePointList(const PointIdList & points);
396 
397  virtual QEPrimal *
398  AddFaceWithSecurePointList(const PointIdList & points, bool CheckEdges);
399 
401  virtual QEPrimal *
402  AddFaceTriangle(const PointIdentifier & aPid, const PointIdentifier & bPid, const PointIdentifier & cPid);
403 
405  virtual void
406  DeletePoint(const PointIdentifier & pid);
407 
408  virtual void
409  DeleteEdge(const PointIdentifier & orgPid, const PointIdentifier & destPid);
410 
411  virtual void
412  DeleteEdge(QEPrimal * e);
413 
414  virtual void
415  LightWeightDeleteEdge(EdgeCellType * e);
416 
417  virtual void
418  LightWeightDeleteEdge(QEPrimal * e);
419 
420  virtual void
421  DeleteFace(FaceRefType faceToDelete);
422 
423  //
424  bool
426  {
427  return (Superclass::GetPoint(pid, pt));
428  }
429 
430  virtual PointType
431  GetPoint(const PointIdentifier & pid) const;
432 
433  virtual VectorType
434  GetVector(const PointIdentifier & pid) const;
435 
436  virtual QEPrimal *
437  GetEdge() const;
438 
439  virtual QEPrimal *
440  GetEdge(const CellIdentifier & eid) const;
441 
442  virtual QEPrimal *
443  FindEdge(const PointIdentifier & pid0) const;
444 
445  virtual QEPrimal *
446  FindEdge(const PointIdentifier & pid0, const PointIdentifier & pid1) const;
447 
448  virtual EdgeCellType *
449  FindEdgeCell(const PointIdentifier & pid0, const PointIdentifier & pid1) const;
450 
452  CoordRepType
453  ComputeEdgeLength(QEPrimal * e);
454 
455  PointIdentifier
456  ComputeNumberOfPoints() const;
457 
458  CellIdentifier
459  ComputeNumberOfFaces() const;
460 
461  CellIdentifier
462  ComputeNumberOfEdges() const;
463 
464  PointIdentifier
465  Splice(QEPrimal * a, QEPrimal * b);
466 
467 #ifdef ITK_USE_CONCEPT_CHECKING
468  // Begin concept checking
469  // End concept checking
470 #endif
471 
472  // for reusability of a mesh in the MeshToMesh filter
473  void
475  {
476  while (!this->m_FreePointIndexes.empty())
477  {
478  this->m_FreePointIndexes.pop();
479  }
480  while (!this->m_FreeCellIndexes.empty())
481  {
482  this->m_FreeCellIndexes.pop();
483  }
484  }
485 
486  CellIdentifier
488  {
489  return (m_NumberOfFaces);
490  }
491  CellIdentifier
493  {
494  return (m_NumberOfEdges);
495  }
496 
497 protected:
499  QuadEdgeMesh();
500  ~QuadEdgeMesh() override;
502 
504  virtual void
505  ClearCellsContainer();
506 
508 
509 private:
512 
513 protected:
516 };
517 } // namespace itk
518 
519 #ifndef ITK_MANUAL_INSTANTIATION
520 # include "itkQuadEdgeMesh.hxx"
521 #endif
522 
523 #endif
itk::QuadEdgeMesh::PointType
typename Superclass::PointType PointType
Definition: itkQuadEdgeMesh.h:77
itk::QuadEdgeMesh::GetCellBoundaryFeatureNeighbors
CellIdentifier GetCellBoundaryFeatureNeighbors(int dimension, CellIdentifier cellId, CellFeatureIdentifier featureId, std::set< CellIdentifier > *cellSet)
Definition: itkQuadEdgeMesh.h:323
itk::QuadEdgeMesh::PixelType
TPixel PixelType
Definition: itkQuadEdgeMesh.h:60
itk::QuadEdgeMesh::CellMultiVisitorType
typename Superclass::CellMultiVisitorType CellMultiVisitorType
Definition: itkQuadEdgeMesh.h:101
itk::QuadEdgeMesh::m_NumberOfEdges
CellIdentifier m_NumberOfEdges
Definition: itkQuadEdgeMesh.h:511
itk::QuadEdgeMesh::BoundaryAssignmentsContainer
typename Superclass::BoundaryAssignmentsContainer BoundaryAssignmentsContainer
Definition: itkQuadEdgeMesh.h:122
itk::QuadEdgeMesh::PointDataContainerIterator
typename Superclass::PointDataContainerIterator PointDataContainerIterator
Definition: itkQuadEdgeMesh.h:91
itk::QuadEdgeMesh::GetAssignedCellBoundaryIfOneExists
bool GetAssignedCellBoundaryIfOneExists(int dimension, CellIdentifier cellId, CellFeatureIdentifier featureId, CellAutoPointer &cellAP) const
Definition: itkQuadEdgeMesh.h:345
itk::QuadEdgeMesh::FaceRefType
typename Traits::FaceRefType FaceRefType
Definition: itkQuadEdgeMesh.h:141
itk::QuadEdgeMesh::RegionType
typename Superclass::RegionType RegionType
Definition: itkQuadEdgeMesh.h:129
itk::QuadEdgeMesh::CellsContainerPointer
typename Superclass::CellsContainerPointer CellsContainerPointer
Definition: itkQuadEdgeMesh.h:103
itk::QuadEdgeMesh::RequestedRegionIsOutsideOfTheBufferedRegion
bool RequestedRegionIsOutsideOfTheBufferedRegion() override
Definition: itkQuadEdgeMesh.h:179
itk::QuadEdgeMesh::DualDataType
typename Traits::DualDataType DualDataType
Definition: itkQuadEdgeMesh.h:134
itk::QuadEdgeMesh::GetCellNeighbors
CellIdentifier GetCellNeighbors(CellIdentifier, std::set< CellIdentifier > *)
Definition: itkQuadEdgeMesh.h:338
itk::QuadEdgeMesh::PrimalDataType
typename Traits::PrimalDataType PrimalDataType
Definition: itkQuadEdgeMesh.h:133
itk::QuadEdgeMesh::m_FreePointIndexes
FreePointIndexesType m_FreePointIndexes
Definition: itkQuadEdgeMesh.h:514
itk::QuadEdgeMesh::CellLinksContainer
typename Superclass::CellLinksContainer CellLinksContainer
Definition: itkQuadEdgeMesh.h:108
itk::QuadEdgeMesh::PointsContainer
typename Superclass::PointsContainer PointsContainer
Definition: itkQuadEdgeMesh.h:84
itk::QuadEdgeMesh::PointsContainerPointer
typename Superclass::PointsContainerPointer PointsContainerPointer
Definition: itkQuadEdgeMesh.h:85
itk::QuadEdgeMesh::SetEdgeCell
void SetEdgeCell(CellIdentifier cellId, CellAutoPointer &cellPointer)
Definition: itkQuadEdgeMesh.h:207
itk::GTest::TypedefsAndConstructors::Dimension2::VectorType
ImageBaseType::SpacingType VectorType
Definition: itkGTestTypedefsAndConstructors.h:53
itk::GTest::TypedefsAndConstructors::Dimension2::PointType
ImageBaseType::PointType PointType
Definition: itkGTestTypedefsAndConstructors.h:51
itk::QuadEdgeMesh::QEDual
typename Traits::QEDual QEDual
Definition: itkQuadEdgeMesh.h:136
itk::QuadEdgeMesh::CellLinksContainerPointer
typename Superclass::CellLinksContainerPointer CellLinksContainerPointer
Definition: itkQuadEdgeMesh.h:109
itk::QuadEdgeMesh::BoundaryAssignmentsContainerVector
typename Superclass::BoundaryAssignmentsContainerVector BoundaryAssignmentsContainerVector
Definition: itkQuadEdgeMesh.h:124
itk::QuadEdgeMesh::PointCellLinksContainerIterator
typename Superclass::PointCellLinksContainerIterator PointCellLinksContainerIterator
Definition: itkQuadEdgeMesh.h:119
itkConceptChecking.h
itk::QuadEdgeMesh::PointCellLinksContainer
typename Superclass::PointCellLinksContainer PointCellLinksContainer
Definition: itkQuadEdgeMesh.h:118
itk::QuadEdgeMesh::CellDataContainerPointer
typename Superclass::CellDataContainerPointer CellDataContainerPointer
Definition: itkQuadEdgeMesh.h:114
itk::QuadEdgeMesh::CellType
typename Superclass::CellType CellType
Definition: itkQuadEdgeMesh.h:97
itk::Mesh::CellsContainerPointer
typename CellsContainer::Pointer CellsContainerPointer
Definition: itkMesh.h:179
itk::QuadEdgeMesh::Traits
TTraits Traits
Definition: itkQuadEdgeMesh.h:59
itk::SmartPointer< Self >
itk::QuadEdgeMesh::CellDataContainer
typename Superclass::CellDataContainer CellDataContainer
Definition: itkQuadEdgeMesh.h:113
itk::QuadEdgeMesh::GetCellBoundaryFeature
bool GetCellBoundaryFeature(int dimension, CellIdentifier cellId, CellFeatureIdentifier featureId, CellAutoPointer &cellAP) const
Definition: itkQuadEdgeMesh.h:308
itk::QuadEdgeMesh::QEPrimal
typename Traits::QEPrimal QEPrimal
Definition: itkQuadEdgeMesh.h:135
itk::QuadEdgeMesh::PointDataContainerPointer
typename Superclass::PointDataContainerPointer PointDataContainerPointer
Definition: itkQuadEdgeMesh.h:90
itk::QuadEdgeMesh::m_NoFace
static const CellIdentifier m_NoFace
Definition: itkQuadEdgeMesh.h:163
itk::QuadEdgeMesh::m_FreeCellIndexes
FreeCellIndexesType m_FreeCellIndexes
Definition: itkQuadEdgeMesh.h:515
itk::QuadEdgeMesh::CellsContainerIterator
typename Superclass::CellsContainerIterator CellsContainerIterator
Definition: itkQuadEdgeMesh.h:106
itk::QuadEdgeMesh::RemoveBoundaryAssignment
bool RemoveBoundaryAssignment(int dimension, CellIdentifier cellId, CellFeatureIdentifier featureId)
Definition: itkQuadEdgeMesh.h:297
itk::QuadEdgeMesh::CellTraits
typename Superclass::CellTraits CellTraits
Definition: itkQuadEdgeMesh.h:78
itk::QuadEdgeMesh::FreePointIndexesType
std::queue< PointIdentifier > FreePointIndexesType
Definition: itkQuadEdgeMesh.h:149
itk::QuadEdgeMesh::m_EdgeCellsContainer
CellsContainerPointer m_EdgeCellsContainer
Definition: itkQuadEdgeMesh.h:507
itk::Mesh::CellIdentifier
typename MeshTraits::CellIdentifier CellIdentifier
Definition: itkMesh.h:162
itk::QuadEdgeMesh::GetNumberOfFaces
CellIdentifier GetNumberOfFaces() const
Definition: itkQuadEdgeMesh.h:487
itk::QuadEdgeMesh::VertexRefType
typename Traits::VertexRefType VertexRefType
Definition: itkQuadEdgeMesh.h:140
itk::QuadEdgeMesh::CellsContainerConstIterator
typename Superclass::CellsContainerConstIterator CellsContainerConstIterator
Definition: itkQuadEdgeMesh.h:105
itk::MeshEnums::MeshClassCellsAllocationMethod
MeshClassCellsAllocationMethod
Definition: itkCommonEnums.h:197
itk::QuadEdgeMesh::EdgeListType
std::list< QEPrimal * > EdgeListType
Definition: itkQuadEdgeMesh.h:154
itk::QuadEdgeMesh::BuildCellLinks
void BuildCellLinks() const
Definition: itkQuadEdgeMesh.h:233
itk::QuadEdgeMesh::PointIdIterator
typename CellTraits::PointIdIterator PointIdIterator
Definition: itkQuadEdgeMesh.h:81
itk::QuadEdgeMesh::GetEdgeCells
const CellsContainer * GetEdgeCells() const
Definition: itkQuadEdgeMesh.h:197
itk::QuadEdgeMesh::GetBoundaryAssignments
BoundaryAssignmentsContainerPointer GetBoundaryAssignments(int dimension)
Definition: itkQuadEdgeMesh.h:248
itk::QuadEdgeMesh::SetBoundaryAssignments
void SetBoundaryAssignments(int dimension, BoundaryAssignmentsContainer *container)
Definition: itkQuadEdgeMesh.h:239
itk::QuadEdgeMesh::PointsContainerIterator
typename Superclass::PointsContainerIterator PointsContainerIterator
Definition: itkQuadEdgeMesh.h:93
itk::QuadEdgeMesh::PointDataContainer
typename Superclass::PointDataContainer PointDataContainer
Definition: itkQuadEdgeMesh.h:89
itk::QuadEdgeMesh
Mesh class for 2D manifolds embedded in ND space.
Definition: itkQuadEdgeMesh.h:53
itk::QuadEdgeMesh::PointIdList
std::vector< PointIdentifier > PointIdList
Definition: itkQuadEdgeMesh.h:153
itk::QuadEdgeMesh::CellLinksContainerIterator
typename Superclass::CellLinksContainerIterator CellLinksContainerIterator
Definition: itkQuadEdgeMesh.h:110
itk::QuadEdgeMesh::GetPoint
bool GetPoint(PointIdentifier pid, PointType *pt) const
Definition: itkQuadEdgeMesh.h:425
itk::GTest::TypedefsAndConstructors::Dimension2::RegionType
ImageBaseType::RegionType RegionType
Definition: itkGTestTypedefsAndConstructors.h:54
itk::QuadEdgeMeshPolygonCell
Definition: itkQuadEdgeMeshPolygonCell.h:39
itk::QuadEdgeMesh::PointIdInternalIterator
typename CellTraits::PointIdInternalIterator PointIdInternalIterator
Definition: itkQuadEdgeMesh.h:80
itk::QuadEdgeMesh::GetEdgeCells
CellsContainer * GetEdgeCells()
Definition: itkQuadEdgeMesh.h:192
itkMesh.h
itk::QuadEdgeMeshLineCell
Class that connects the QuadEdgeMesh with the Mesh.
Definition: itkQuadEdgeMeshLineCell.h:39
itkQuadEdgeMeshPolygonCell.h
itk::QuadEdgeMesh::PointIdentifier
typename Superclass::PointIdentifier PointIdentifier
Definition: itkQuadEdgeMesh.h:75
itkQuadEdgeMeshFrontIterator.h
itk::QuadEdgeMesh::CellsContainer
typename Superclass::CellsContainer CellsContainer
Definition: itkQuadEdgeMesh.h:102
itk::QuadEdgeMesh::CellPixelType
typename Superclass::CellPixelType CellPixelType
Definition: itkQuadEdgeMesh.h:73
itk::QuadEdgeMesh::GetBoundaryAssignments
const BoundaryAssignmentsContainerPointer GetBoundaryAssignments(int dimension) const
Definition: itkQuadEdgeMesh.h:257
itk::QuadEdgeMesh::m_NoPoint
static const PointIdentifier m_NoPoint
Definition: itkQuadEdgeMesh.h:160
itk::QuadEdgeMesh::CellFeatureIdentifier
typename Superclass::CellFeatureIdentifier CellFeatureIdentifier
Definition: itkQuadEdgeMesh.h:99
itk::QuadEdgeMesh::SetBoundaryAssignment
void SetBoundaryAssignment(int dimension, CellIdentifier cellId, CellFeatureIdentifier featureId, CellIdentifier boundaryId)
Definition: itkQuadEdgeMesh.h:268
itk::QuadEdgeMesh::m_NumberOfFaces
CellIdentifier m_NumberOfFaces
Definition: itkQuadEdgeMesh.h:510
itk::NumericTraits::ZeroValue
static T ZeroValue()
Definition: itkNumericTraits.h:148
itk::QuadEdgeMesh::CellDataContainerIterator
typename Superclass::CellDataContainerIterator CellDataContainerIterator
Definition: itkQuadEdgeMesh.h:115
itk::QuadEdgeMesh::CoordRepArrayType
CoordRepType[Self::PointDimension] CoordRepArrayType
Definition: itkQuadEdgeMesh.h:86
itk::QuadEdgeMesh::VectorType
typename Traits::VectorType VectorType
Definition: itkQuadEdgeMesh.h:142
itk::QuadEdgeMesh::InterpolationWeightType
typename Superclass::InterpolationWeightType InterpolationWeightType
Definition: itkQuadEdgeMesh.h:130
itk::QuadEdgeMesh::FreeCellIndexesType
std::queue< CellIdentifier > FreeCellIndexesType
Definition: itkQuadEdgeMesh.h:150
itk::QuadEdgeMesh::EdgeListPointerType
EdgeListType * EdgeListPointerType
Definition: itkQuadEdgeMesh.h:155
itk::QuadEdgeMesh::GetNumberOfEdges
CellIdentifier GetNumberOfEdges() const
Definition: itkQuadEdgeMesh.h:492
itk
The "itk" namespace contains all Insight Segmentation and Registration Toolkit (ITK) classes....
Definition: itkAnnulusOperator.h:24
itkQuadEdgeMeshLineCell.h
itk::Mesh
Implements the N-dimensional mesh structure.
Definition: itkMesh.h:114
itk::QuadEdgeMesh::SetEdgeCells
void SetEdgeCells(CellsContainer *edgeCells)
Definition: itkQuadEdgeMesh.h:202
itk::QuadEdgeMesh::CoordRepType
typename Superclass::CoordRepType CoordRepType
Definition: itkQuadEdgeMesh.h:74
itk::Object
Base class for most ITK classes.
Definition: itkObject.h:62
itk::QuadEdgeMesh::BoundingBoxPointer
typename Superclass::BoundingBoxPointer BoundingBoxPointer
Definition: itkQuadEdgeMesh.h:127
itk::Math::e
static constexpr double e
Definition: itkMath.h:54
itk::QuadEdgeMesh::CellAutoPointer
typename Superclass::CellAutoPointer CellAutoPointer
Definition: itkQuadEdgeMesh.h:98
itk::QuadEdgeMesh::PointHashType
typename Superclass::PointHashType PointHashType
Definition: itkQuadEdgeMesh.h:76
itk::QuadEdgeMesh::CellFeatureCount
typename Superclass::CellFeatureCount CellFeatureCount
Definition: itkQuadEdgeMesh.h:100
itk::QuadEdgeMesh::GetBoundaryAssignment
bool GetBoundaryAssignment(int dimension, CellIdentifier cellId, CellFeatureIdentifier featureId, CellIdentifier *boundaryId) const
Definition: itkQuadEdgeMesh.h:282
itk::QuadEdgeMesh::PointsContainerConstIterator
typename Superclass::PointsContainerConstIterator PointsContainerConstIterator
Definition: itkQuadEdgeMesh.h:92
itkQEDefineFrontIteratorMethodsMacro
#define itkQEDefineFrontIteratorMethodsMacro(MeshTypeArg)
Definition: itkQuadEdgeMeshFrontIterator.h:24
itk::QuadEdgeMesh::CellIdentifier
typename Superclass::CellIdentifier CellIdentifier
Definition: itkQuadEdgeMesh.h:96
itk::QuadEdgeMesh::QEType
typename Traits::QEPrimal QEType
Definition: itkQuadEdgeMesh.h:137
itk::QuadEdgeMesh::BoundaryAssignmentsContainerPointer
typename Superclass::BoundaryAssignmentsContainerPointer BoundaryAssignmentsContainerPointer
Definition: itkQuadEdgeMesh.h:123
itk::QuadEdgeMesh::CopyInformation
void CopyInformation(const DataObject *data) override
Definition: itkQuadEdgeMesh.h:219
itk::QuadEdgeMesh::ClearFreePointAndCellIndexesLists
void ClearFreePointAndCellIndexesLists()
Definition: itkQuadEdgeMesh.h:474
itk::DataObject
Base class for all data objects in ITK.
Definition: itkDataObject.h:293
itkQuadEdgeMeshTraits.h
itk::QuadEdgeMesh::BoundingBoxType
typename Superclass::BoundingBoxType BoundingBoxType
Definition: itkQuadEdgeMesh.h:128