0
# Mesh Processing
1
2
ITK provides comprehensive support for mesh data structures and geometric processing operations. The mesh framework includes general meshes, advanced QuadEdge mesh topology, point sets, and various mesh processing algorithms.
3
4
## Core Mesh Classes
5
6
### Mesh
7
8
General mesh structure supporting vertices, edges, and faces.
9
10
```cpp { .api }
11
template<typename TPixelType, unsigned int VDimension>
12
class Mesh : public PointSet<TPixelType, VDimension>
13
{
14
public:
15
typedef Mesh Self;
16
typedef PointSet<TPixelType, VDimension> Superclass;
17
typedef SmartPointer<Self> Pointer;
18
typedef SmartPointer<const Self> ConstPointer;
19
20
static Pointer New();
21
22
// Cell management
23
void SetCell(CellIdentifier cellId, CellAutoPointer & cellPointer);
24
bool GetCell(CellIdentifier cellId, CellAutoPointer & cellPointer) const;
25
void SetCellData(CellIdentifier cellId, CellPixelType cellData);
26
bool GetCellData(CellIdentifier cellId, CellPixelType * cellData) const;
27
28
// Cell containers
29
void SetCells(CellsContainer * cells);
30
CellsContainer * GetCells();
31
const CellsContainer * GetCells() const;
32
33
void SetCellData(CellDataContainer * cellData);
34
CellDataContainer * GetCellData();
35
const CellDataContainer * GetCellData() const;
36
37
// Boundaries
38
void SetBoundaryAssignments(BoundaryAssignmentsContainer * boundaryAssignments);
39
BoundaryAssignmentsContainer * GetBoundaryAssignments();
40
const BoundaryAssignmentsContainer * GetBoundaryAssignments() const;
41
42
// Cell links
43
void SetCellLinks(CellLinksContainer * cellLinks);
44
CellLinksContainer * GetCellLinks();
45
const CellLinksContainer * GetCellLinks() const;
46
47
// Mesh queries
48
unsigned long GetNumberOfCells() const;
49
bool GetAssignedCellBoundaryIfOneExists(int dimension,
50
CellIdentifier cellId,
51
CellFeatureIdentifier featureId,
52
CellAutoPointer & boundaryPtr) const;
53
54
// Cell iteration
55
void SetCellsAllocationMethod(CellsAllocationMethodType cellsAllocationMethod);
56
CellsAllocationMethodType GetCellsAllocationMethod() const;
57
58
protected:
59
virtual void PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;
60
virtual void ReleaseCellsMemory();
61
};
62
```
63
64
### QuadEdgeMesh
65
66
Advanced mesh topology using QuadEdge data structure.
67
68
```cpp { .api }
69
template<typename TPixel, unsigned int VDimension>
70
class QuadEdgeMesh : public Mesh<TPixel, VDimension>
71
{
72
public:
73
typedef QuadEdgeMesh Self;
74
typedef Mesh<TPixel, VDimension> Superclass;
75
typedef SmartPointer<Self> Pointer;
76
typedef SmartPointer<const Self> ConstPointer;
77
78
static Pointer New();
79
80
// Edge operations
81
QEPrimal * AddEdge(const PointIdentifier & orgPid, const PointIdentifier & destPid);
82
QEPrimal * AddEdgeWithSecurePointList(const PointIdentifier & orgPid, const PointIdentifier & destPid);
83
84
virtual QEPrimal * AddEdge(const PointType & orgPt, const PointType & destPt);
85
virtual void DeleteEdge(QEPrimal * e);
86
virtual void LightWeightDeleteEdge(EdgeCellType * edgeCell);
87
virtual void LightWeightDeleteEdge(QEPrimal * e);
88
89
// Face operations
90
QEPrimal * AddFace(const PointIdList & PointIdList);
91
QEPrimal * AddFaceWithSecurePointList(const PointIdList & PointIdList);
92
QEPrimal * AddFaceTriangle(const PointIdentifier & aPid,
93
const PointIdentifier & bPid,
94
const PointIdentifier & cPid);
95
96
void DeleteFace(FaceCellType * faceCell);
97
void LightWeightDeleteFace(FaceCellType * faceCell);
98
99
// Topology queries
100
bool FindEdge(const PointIdentifier & pid0, const PointIdentifier & pid1) const;
101
QEPrimal * FindEdge(const PointIdentifier & pid0, const PointIdentifier & pid1);
102
unsigned long GetNumberOfFaces() const;
103
unsigned long GetNumberOfEdges() const;
104
105
// Euler operations
106
PointIdentifier Splice(QEPrimal * a, QEPrimal * b);
107
void EulerOperatorJoinVertexInFaceSplitEdge(QEPrimal * e, QEPrimal * f);
108
void EulerOperatorSplitVertexInEdgeJoinFace(QEPrimal * e, QEPrimal * f);
109
void EulerOperatorDeleteCenterVertexInTriangularFaceSplitEdge(QEPrimal * e);
110
111
// Mesh validation
112
bool CheckEdge(QEPrimal * e) const;
113
virtual void DeletePoint(const PointIdentifier & pid);
114
virtual void DeleteEdge(const PointIdentifier & orgPid, const PointIdentifier & destPid);
115
116
protected:
117
virtual void CopyInformation(const DataObject * data) ITK_OVERRIDE;
118
virtual void Graft(const DataObject * data) ITK_OVERRIDE;
119
};
120
```
121
122
### PointSet
123
124
Base class for point cloud data structures.
125
126
```cpp { .api }
127
template<typename TPixelType, unsigned int VDimension>
128
class PointSet : public DataObject
129
{
130
public:
131
typedef PointSet Self;
132
typedef DataObject Superclass;
133
typedef SmartPointer<Self> Pointer;
134
typedef SmartPointer<const Self> ConstPointer;
135
136
static Pointer New();
137
138
// Point management
139
void SetPoint(PointIdentifier pointId, PointType point);
140
bool GetPoint(PointIdentifier pointId, PointType * point) const;
141
PointType GetPoint(PointIdentifier pointId) const;
142
143
// Point data
144
void SetPointData(PointIdentifier pointId, PixelType data);
145
bool GetPointData(PointIdentifier pointId, PixelType * data) const;
146
PixelType GetPointData(PointIdentifier pointId) const;
147
148
// Container access
149
void SetPoints(PointsContainer * points);
150
PointsContainer * GetPoints();
151
const PointsContainer * GetPoints() const;
152
153
void SetPointData(PointDataContainer * pointData);
154
PointDataContainer * GetPointData();
155
const PointDataContainer * GetPointData() const;
156
157
// Point queries
158
PointIdentifier GetNumberOfPoints() const;
159
bool RequestedRegionIsOutsideOfTheBufferedRegion() ITK_OVERRIDE;
160
void Initialize() ITK_OVERRIDE;
161
162
// Bounding box
163
const BoundingBoxType * GetBoundingBox() const;
164
165
protected:
166
virtual void PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;
167
virtual void PassThroughInformation(const DataObject * inputPointSet);
168
virtual void DeepCopy(const DataObject * inputPointSet);
169
};
170
```
171
172
## Mesh Cell Types
173
174
### CellInterface
175
176
Base interface for mesh cells (vertices, edges, faces).
177
178
```cpp { .api }
179
template<typename TPixelType, typename TCellTraits>
180
class CellInterface
181
{
182
public:
183
typedef CellInterface Self;
184
typedef TPixelType PixelType;
185
typedef TCellTraits CellTraits;
186
187
// Cell type information
188
virtual CellGeometry GetType() const = 0;
189
virtual void MakeCopy(CellAutoPointer & cell) const = 0;
190
virtual unsigned int GetDimension() const = 0;
191
virtual unsigned int GetInterpolationOrder() const;
192
virtual unsigned int GetNumberOfPoints() const = 0;
193
virtual unsigned int GetNumberOfBoundaryFeatures(int dimension) const = 0;
194
virtual bool GetBoundaryFeature(int dimension, CellFeatureIdentifier featureId,
195
CellAutoPointer & cell) = 0;
196
197
// Point list access
198
virtual void SetPointIds(PointIdConstIterator first) = 0;
199
virtual void SetPointIds(PointIdConstIterator first, PointIdConstIterator last) = 0;
200
201
virtual void SetPointId(int localId, PointIdentifier ptId) = 0;
202
virtual PointIdIterator PointIdsBegin() = 0;
203
virtual PointIdConstIterator PointIdsBegin() const = 0;
204
virtual PointIdIterator PointIdsEnd() = 0;
205
virtual PointIdConstIterator PointIdsEnd() const = 0;
206
207
// Visiting and evaluation
208
virtual bool EvaluatePosition(CoordRepType * position,
209
PointsContainer * points,
210
CoordRepType * closestPoint,
211
CoordRepType pcoords[],
212
double * dist2,
213
InterpolationWeightType * weights) = 0;
214
215
virtual void EvaluateShapeFunctions(const ParametricCoordArrayType & parametricCoordinates,
216
ShapeFunctionsArrayType & weights) const = 0;
217
218
// Destruction
219
virtual ~CellInterface() {}
220
};
221
```
222
223
### TriangleCell
224
225
Triangle cell for 2D mesh faces.
226
227
```cpp { .api }
228
template<typename TCellInterface>
229
class TriangleCell : public TCellInterface
230
{
231
public:
232
typedef TriangleCell Self;
233
typedef TCellInterface Superclass;
234
typedef typename Superclass::PixelType PixelType;
235
typedef typename Superclass::CellType CellType;
236
typedef typename Superclass::CellAutoPointer CellAutoPointer;
237
typedef typename Superclass::CellConstAutoPointer CellConstAutoPointer;
238
typedef typename Superclass::CellRawPointer CellRawPointer;
239
typedef typename Superclass::CellConstRawPointer CellConstRawPointer;
240
241
// Cell type information
242
itkCellCommonTypedefs(TriangleCell);
243
itkCellInheritedTypedefs(TCellInterface);
244
245
itkTypeMacro(TriangleCell, CellInterface);
246
247
// Overridden methods
248
virtual CellGeometry GetType() const ITK_OVERRIDE { return Superclass::TRIANGLE_CELL; }
249
virtual void MakeCopy(CellAutoPointer & cell) const ITK_OVERRIDE;
250
virtual unsigned int GetDimension() const ITK_OVERRIDE { return 2; }
251
virtual unsigned int GetNumberOfPoints() const ITK_OVERRIDE { return 3; }
252
virtual unsigned int GetNumberOfBoundaryFeatures(int dimension) const ITK_OVERRIDE;
253
virtual bool GetBoundaryFeature(int dimension, CellFeatureIdentifier featureId,
254
CellAutoPointer & cell) ITK_OVERRIDE;
255
256
// Point management
257
virtual void SetPointIds(PointIdConstIterator first) ITK_OVERRIDE;
258
virtual void SetPointIds(PointIdConstIterator first, PointIdConstIterator last) ITK_OVERRIDE;
259
virtual void SetPointId(int localId, PointIdentifier ptId) ITK_OVERRIDE;
260
261
// Shape functions
262
virtual void EvaluateShapeFunctions(const ParametricCoordArrayType & parametricCoordinates,
263
ShapeFunctionsArrayType & weights) const ITK_OVERRIDE;
264
265
// Area computation
266
virtual CoordRepType ComputeArea(PointsContainer * points);
267
268
// Constructors
269
TriangleCell();
270
~TriangleCell() {}
271
272
protected:
273
PointIdentifier m_PointIds[3];
274
};
275
```
276
277
### TetrahedronCell
278
279
Tetrahedron cell for 3D mesh elements.
280
281
```cpp { .api }
282
template<typename TCellInterface>
283
class TetrahedronCell : public TCellInterface
284
{
285
public:
286
typedef TetrahedronCell Self;
287
typedef TCellInterface Superclass;
288
289
// Cell type information
290
itkCellCommonTypedefs(TetrahedronCell);
291
itkCellInheritedTypedefs(TCellInterface);
292
293
itkTypeMacro(TetrahedronCell, CellInterface);
294
295
// Overridden methods
296
virtual CellGeometry GetType() const ITK_OVERRIDE { return Superclass::TETRAHEDRON_CELL; }
297
virtual void MakeCopy(CellAutoPointer & cell) const ITK_OVERRIDE;
298
virtual unsigned int GetDimension() const ITK_OVERRIDE { return 3; }
299
virtual unsigned int GetNumberOfPoints() const ITK_OVERRIDE { return 4; }
300
virtual unsigned int GetNumberOfBoundaryFeatures(int dimension) const ITK_OVERRIDE;
301
virtual bool GetBoundaryFeature(int dimension, CellFeatureIdentifier featureId,
302
CellAutoPointer & cell) ITK_OVERRIDE;
303
304
// Point management
305
virtual void SetPointIds(PointIdConstIterator first) ITK_OVERRIDE;
306
virtual void SetPointIds(PointIdConstIterator first, PointIdConstIterator last) ITK_OVERRIDE;
307
virtual void SetPointId(int localId, PointIdentifier ptId) ITK_OVERRIDE;
308
309
// Shape functions
310
virtual void EvaluateShapeFunctions(const ParametricCoordArrayType & parametricCoordinates,
311
ShapeFunctionsArrayType & weights) const ITK_OVERRIDE;
312
313
// Volume computation
314
virtual CoordRepType ComputeVolume(PointsContainer * points);
315
316
// Constructors
317
TetrahedronCell();
318
~TetrahedronCell() {}
319
320
protected:
321
PointIdentifier m_PointIds[4];
322
};
323
```
324
325
## Mesh Processing Filters
326
327
### BinaryMaskToNarrowBandPointSetFilter
328
329
Converts binary masks to narrow band point sets.
330
331
```cpp { .api }
332
template<typename TInputImage, typename TOutputMesh>
333
class BinaryMaskToNarrowBandPointSetFilter : public ImageToMeshFilter<TInputImage, TOutputMesh>
334
{
335
public:
336
typedef BinaryMaskToNarrowBandPointSetFilter Self;
337
typedef ImageToMeshFilter<TInputImage, TOutputMesh> Superclass;
338
typedef SmartPointer<Self> Pointer;
339
typedef SmartPointer<const Self> ConstPointer;
340
341
static Pointer New();
342
343
// Band width control
344
void SetBandWidth(float bandWidth);
345
itkGetConstMacro(BandWidth, float);
346
347
// Distance computation
348
void SetDistanceFromObject(float distanceFromObject);
349
itkGetConstMacro(DistanceFromObject, float);
350
351
protected:
352
virtual void GenerateData() ITK_OVERRIDE;
353
virtual void PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;
354
};
355
```
356
357
### MeshToMeshFilter
358
359
Base class for mesh-to-mesh processing filters.
360
361
```cpp { .api }
362
template<typename TInputMesh, typename TOutputMesh>
363
class MeshToMeshFilter : public MeshSource<TOutputMesh>
364
{
365
public:
366
typedef MeshToMeshFilter Self;
367
typedef MeshSource<TOutputMesh> Superclass;
368
typedef SmartPointer<Self> Pointer;
369
typedef SmartPointer<const Self> ConstPointer;
370
371
// Input handling
372
using Superclass::SetInput;
373
void SetInput(const InputMeshType * input);
374
const InputMeshType * GetInput() const;
375
const InputMeshType * GetInput(unsigned int idx) const;
376
377
protected:
378
virtual void GenerateInputRequestedRegion() ITK_OVERRIDE;
379
virtual void CopyInputMeshToOutputMeshPoints();
380
virtual void CopyInputMeshToOutputMeshPointData();
381
virtual void CopyInputMeshToOutputMeshCells();
382
virtual void CopyInputMeshToOutputMeshCellData();
383
};
384
```
385
386
### TriangleMeshToSimplexMeshFilter
387
388
Converts triangle meshes to simplex meshes.
389
390
```cpp { .api }
391
template<typename TInputMesh, typename TOutputMesh>
392
class TriangleMeshToSimplexMeshFilter : public MeshToMeshFilter<TInputMesh, TOutputMesh>
393
{
394
public:
395
typedef TriangleMeshToSimplexMeshFilter Self;
396
typedef MeshToMeshFilter<TInputMesh, TOutputMesh> Superclass;
397
typedef SmartPointer<Self> Pointer;
398
typedef SmartPointer<const Self> ConstPointer;
399
400
static Pointer New();
401
402
protected:
403
virtual void GenerateData() ITK_OVERRIDE;
404
virtual void PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;
405
406
void Initialize();
407
void CreateSimplexPoints();
408
void CreateEdgeForTrianglePair(CellIdentifier pointIndex, CellIdentifier boundaryId);
409
void CreateSimplexNeighbors();
410
void CreateCells();
411
};
412
```
413
414
## Mesh Utilities
415
416
### MeshSpatialObject
417
418
Spatial object representation of meshes.
419
420
```cpp { .api }
421
template<typename TMesh>
422
class MeshSpatialObject : public SpatialObject<TMesh::PointDimension>
423
{
424
public:
425
typedef MeshSpatialObject Self;
426
typedef SpatialObject<TMesh::PointDimension> Superclass;
427
typedef SmartPointer<Self> Pointer;
428
typedef SmartPointer<const Self> ConstPointer;
429
430
static Pointer New();
431
432
// Mesh access
433
void SetMesh(MeshType * mesh);
434
MeshType * GetMesh();
435
const MeshType * GetMesh() const;
436
437
// Bounding box computation
438
virtual bool ComputeLocalBoundingBox() const ITK_OVERRIDE;
439
440
// Spatial object queries
441
virtual bool IsEvaluableAt(const PointType & point,
442
unsigned int depth = 0,
443
char * name = ITK_NULLPTR) const ITK_OVERRIDE;
444
445
virtual bool ValueAt(const PointType & point, double & value,
446
unsigned int depth = 0,
447
char * name = ITK_NULLPTR) const ITK_OVERRIDE;
448
449
virtual bool IsInside(const PointType & point,
450
unsigned int depth,
451
char * name) const ITK_OVERRIDE;
452
453
protected:
454
virtual void PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;
455
};
456
```
457
458
### QuadEdgeMeshExtendedTraits
459
460
Extended traits for QuadEdge meshes with additional data.
461
462
```cpp { .api }
463
template<typename TPixelType, unsigned int VPointDimension, typename TPData, typename TDData,
464
typename TCoordRep, typename TInterpolationWeightType>
465
class QuadEdgeMeshExtendedTraits
466
{
467
public:
468
typedef TPixelType PixelType;
469
typedef TCoordRep CoordRepType;
470
typedef TInterpolationWeightType InterpolationWeightType;
471
472
itkStaticConstMacro(PointDimension, unsigned int, VPointDimension);
473
itkStaticConstMacro(MaxTopologicalDimension, unsigned int, VPointDimension);
474
475
typedef TPData PrimalDataType;
476
typedef TDData DualDataType;
477
typedef GeometricalQuadEdge<PrimalDataType, DualDataType, true, true> QEPrimal;
478
typedef typename QEPrimal::DualType QEDual;
479
typedef typename QEPrimal::OriginRefType QEOriginRefType;
480
481
// Points
482
typedef Point<CoordRepType, VPointDimension> PointType;
483
typedef MapContainer<PointIdentifier, PointType> PointsContainer;
484
typedef PointsContainer::Iterator PointsContainerIterator;
485
typedef PointsContainer::ConstIterator PointsContainerConstIterator;
486
487
// Cells
488
typedef QuadEdgeMeshLineCell<CellType> LineCellType;
489
typedef QuadEdgeMeshPolygonCell<CellType> PolygonCellType;
490
typedef MapContainer<CellIdentifier, CellType *> CellsContainer;
491
typedef CellsContainer::Iterator CellsContainerIterator;
492
typedef CellsContainer::ConstIterator CellsContainerConstIterator;
493
494
// Cell data
495
typedef MapContainer<CellIdentifier, PixelType> CellDataContainer;
496
typedef CellDataContainer::Iterator CellDataContainerIterator;
497
typedef CellDataContainer::ConstIterator CellDataContainerConstIterator;
498
};
499
```
500
501
## Common Usage Patterns
502
503
### Creating a Triangle Mesh
504
505
```cpp
506
// Define mesh type
507
typedef itk::Mesh<float, 3> MeshType;
508
MeshType::Pointer mesh = MeshType::New();
509
510
// Add points
511
MeshType::PointType point;
512
point[0] = 0.0; point[1] = 0.0; point[2] = 0.0;
513
mesh->SetPoint(0, point);
514
515
point[0] = 1.0; point[1] = 0.0; point[2] = 0.0;
516
mesh->SetPoint(1, point);
517
518
point[0] = 0.5; point[1] = 1.0; point[2] = 0.0;
519
mesh->SetPoint(2, point);
520
521
// Create triangle cell
522
typedef MeshType::CellType CellType;
523
typedef itk::TriangleCell<CellType> TriangleCellType;
524
525
CellType::CellAutoPointer triangle;
526
triangle.TakeOwnership(new TriangleCellType);
527
528
// Set triangle vertices
529
triangle->SetPointId(0, 0);
530
triangle->SetPointId(1, 1);
531
triangle->SetPointId(2, 2);
532
533
// Add triangle to mesh
534
mesh->SetCell(0, triangle);
535
536
std::cout << "Number of points: " << mesh->GetNumberOfPoints() << std::endl;
537
std::cout << "Number of cells: " << mesh->GetNumberOfCells() << std::endl;
538
```
539
540
### QuadEdge Mesh Operations
541
542
```cpp
543
// Define QuadEdge mesh type
544
typedef itk::QuadEdgeMesh<float, 3> QEMeshType;
545
QEMeshType::Pointer qeMesh = QEMeshType::New();
546
547
// Add points
548
QEMeshType::PointType p0, p1, p2, p3;
549
p0[0] = 0.0; p0[1] = 0.0; p0[2] = 0.0;
550
p1[0] = 1.0; p1[1] = 0.0; p1[2] = 0.0;
551
p2[0] = 1.0; p2[1] = 1.0; p2[2] = 0.0;
552
p3[0] = 0.0; p3[1] = 1.0; p3[2] = 0.0;
553
554
QEMeshType::PointIdentifier pid0 = qeMesh->AddPoint(p0);
555
QEMeshType::PointIdentifier pid1 = qeMesh->AddPoint(p1);
556
QEMeshType::PointIdentifier pid2 = qeMesh->AddPoint(p2);
557
QEMeshType::PointIdentifier pid3 = qeMesh->AddPoint(p3);
558
559
// Add triangular faces
560
qeMesh->AddFaceTriangle(pid0, pid1, pid2);
561
qeMesh->AddFaceTriangle(pid0, pid2, pid3);
562
563
std::cout << "Number of points: " << qeMesh->GetNumberOfPoints() << std::endl;
564
std::cout << "Number of faces: " << qeMesh->GetNumberOfFaces() << std::endl;
565
std::cout << "Number of edges: " << qeMesh->GetNumberOfEdges() << std::endl;
566
```
567
568
## Type Definitions
569
570
```cpp { .api }
571
// Common mesh instantiations
572
typedef Mesh<float, 2> Mesh2D;
573
typedef Mesh<float, 3> Mesh3D;
574
typedef Mesh<double, 2> DoubleMesh2D;
575
typedef Mesh<double, 3> DoubleMesh3D;
576
577
typedef QuadEdgeMesh<float, 2> QEMesh2D;
578
typedef QuadEdgeMesh<float, 3> QEMesh3D;
579
typedef QuadEdgeMesh<double, 2> QEDoubleMesh2D;
580
typedef QuadEdgeMesh<double, 3> QEDoubleMesh3D;
581
582
typedef PointSet<float, 2> PointSet2D;
583
typedef PointSet<float, 3> PointSet3D;
584
585
// Cell types
586
typedef TriangleCell<CellInterface<float, CellTraitsInfo<2>>> TriangleCell2D;
587
typedef TriangleCell<CellInterface<float, CellTraitsInfo<3>>> TriangleCell3D;
588
typedef TetrahedronCell<CellInterface<float, CellTraitsInfo<3>>> TetrahedronCell3D;
589
typedef LineCell<CellInterface<float, CellTraitsInfo<2>>> LineCell2D;
590
typedef LineCell<CellInterface<float, CellTraitsInfo<3>>> LineCell3D;
591
592
// Container types
593
typedef MapContainer<PointIdentifier, Point<float, 2>> PointsContainer2D;
594
typedef MapContainer<PointIdentifier, Point<float, 3>> PointsContainer3D;
595
typedef MapContainer<CellIdentifier, CellInterface<float, CellTraitsInfo<2>> *> CellsContainer2D;
596
typedef MapContainer<CellIdentifier, CellInterface<float, CellTraitsInfo<3>> *> CellsContainer3D;
597
598
// Identifiers
599
typedef unsigned long PointIdentifier;
600
typedef unsigned long CellIdentifier;
601
typedef unsigned long CellFeatureIdentifier;
602
603
// Cell geometry types
604
enum CellGeometry {
605
VERTEX_CELL = 0,
606
LINE_CELL = 1,
607
TRIANGLE_CELL = 2,
608
QUADRILATERAL_CELL = 3,
609
POLYGON_CELL = 4,
610
TETRAHEDRON_CELL = 5,
611
HEXAHEDRON_CELL = 6,
612
QUADRATIC_EDGE_CELL = 7,
613
QUADRATIC_TRIANGLE_CELL = 8,
614
LAST_ITK_CELL,
615
MAX_ITK_CELLS = 255
616
};
617
```
618
619
ITK's mesh processing framework provides comprehensive support for geometric data structures and processing operations, enabling sophisticated mesh-based analysis and modeling in medical imaging applications.