ITK  6.0.0
Insight Toolkit
itkQuadEdgeMeshEulerOperatorsTestHelper.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 itkQuadEdgeMeshEulerOperatorsTestHelper_h
19 #define itkQuadEdgeMeshEulerOperatorsTestHelper_h
20 
21 #include "itkQuadEdgeMeshTopologyChecker.h"
22 #include "itkQuadEdgeMeshPolygonCell.h"
23 
24 using IdentifierType = unsigned long;
25 
26 template <typename TMesh>
27 bool
28 AssertTopologicalInvariants(TMesh * mesh,
29  IdentifierType NumVertices,
30  IdentifierType NumFaces,
31  IdentifierType NumEdges,
32  IdentifierType NumBorders,
33  IdentifierType Genus)
34 {
35  using CheckerType = itk::QuadEdgeMeshTopologyChecker<TMesh>;
36  auto check = CheckerType::New();
37  check->SetMesh(mesh);
38  check->SetExpectedNumberOfPoints(NumVertices);
39  check->SetExpectedNumberOfEdges(NumFaces);
40  check->SetExpectedNumberOfFaces(NumEdges);
41  check->SetExpectedNumberOfBoundaries(NumBorders);
42  check->SetExpectedGenus(Genus);
43  return (check->ValidateEulerCharacteristic());
44 }
45 
46 //----------------------------------------------------------------------------
47 template <typename TMesh>
48 std::vector<typename TMesh::PointType>
49 GeneratePointCoordinates(const unsigned int iN)
50 {
51  using PointType = typename TMesh::PointType;
52  using CoordinateType = typename PointType::CoordinateType;
53  std::vector<PointType> oPt(iN * iN);
54 
55  for (unsigned int i = 0; i < iN; ++i)
56  {
57  for (unsigned int j = 0; j < iN; ++j)
58  {
59  oPt[i * iN + j][0] = static_cast<CoordinateType>(j);
60  oPt[i * iN + j][1] = static_cast<CoordinateType>(i);
61  oPt[i * iN + j][2] = static_cast<CoordinateType>(0.);
62  }
63  }
64 
65  return oPt;
66 }
67 
68 //----------------------------------------------------------------------------
69 template <typename TMesh>
70 void
71 CreateSquareQuadMesh(typename TMesh::Pointer mesh)
72 {
73  using MeshType = TMesh;
74  using CellType = typename MeshType::CellType;
75 
76  using QEPolygonCellType = itk::QuadEdgeMeshPolygonCell<CellType>;
77 
78  if (mesh->GetNumberOfPoints())
79  {
80  mesh->Clear();
81  mesh->ClearFreePointAndCellIndexesLists();
82  }
83 
85  constexpr int expectedNumPts = 25;
86  constexpr int expectedNumCells = 16;
87  const int simpleSquareCells[64] = { 0, 1, 6, 5, 1, 2, 7, 6, 2, 3, 8, 7, 3, 4, 9, 8,
88  5, 6, 11, 10, 6, 7, 12, 11, 7, 8, 13, 12, 8, 9, 14, 13,
89  10, 11, 16, 15, 11, 12, 17, 16, 12, 13, 18, 17, 13, 14, 19, 18,
90  15, 16, 21, 20, 16, 17, 22, 21, 17, 18, 23, 22, 18, 19, 24, 23 };
91 
92  using PointType = typename MeshType::PointType;
93 
94  std::vector<PointType> pts = GeneratePointCoordinates<MeshType>(5);
95 
96  for (int i = 0; i < expectedNumPts; ++i)
97  {
98  mesh->SetPoint(i, pts[i]);
99  }
100 
101  typename CellType::CellAutoPointer cellpointer;
102  QEPolygonCellType * poly;
103 
104  for (int i = 0; i < expectedNumCells; ++i)
105  {
106  poly = new QEPolygonCellType(4);
107  cellpointer.TakeOwnership(poly);
108  cellpointer->SetPointId(0, simpleSquareCells[4 * i]);
109  cellpointer->SetPointId(1, simpleSquareCells[4 * i + 1]);
110  cellpointer->SetPointId(2, simpleSquareCells[4 * i + 2]);
111  cellpointer->SetPointId(3, simpleSquareCells[4 * i + 3]);
112  mesh->SetCell(i, cellpointer);
113  }
114 }
115 
116 //----------------------------------------------------------------------------
117 template <typename TMesh>
118 void
119 CreateSquareTriangularMesh(typename TMesh::Pointer mesh)
120 {
121  using MeshType = TMesh;
122  using CellType = typename MeshType::CellType;
123 
124  using QEPolygonCellType = itk::QuadEdgeMeshPolygonCell<CellType>;
125 
126  if (mesh->GetNumberOfPoints())
127  {
128  mesh->Clear();
129  mesh->ClearFreePointAndCellIndexesLists();
130  }
131 
133  constexpr int expectedNumPts = 25;
134  constexpr int expectedNumCells = 32;
135  const int simpleSquareCells[96] = { 0, 1, 6, 0, 6, 5, 1, 2, 7, 1, 7, 6, 2, 3, 8, 2, 8, 7, 3, 4,
136  9, 3, 9, 8, 5, 6, 11, 5, 11, 10, 6, 7, 12, 6, 12, 11, 7, 8, 13, 7,
137  13, 12, 8, 9, 14, 8, 14, 13, 10, 11, 16, 10, 16, 15, 11, 12, 17, 11, 17, 16,
138  12, 13, 18, 12, 18, 17, 13, 14, 19, 13, 19, 18, 15, 16, 21, 15, 21, 20, 16, 17,
139  22, 16, 22, 21, 17, 18, 23, 17, 23, 22, 18, 19, 24, 18, 24, 23 };
140 
141  using PointType = typename TMesh::PointType;
142  std::vector<PointType> pts = GeneratePointCoordinates<TMesh>(5);
143 
144  for (int i = 0; i < expectedNumPts; ++i)
145  {
146  mesh->SetPoint(i, pts[i]);
147  }
148 
149  typename CellType::CellAutoPointer cellpointer;
150  QEPolygonCellType * poly;
151 
152  for (int i = 0; i < expectedNumCells; ++i)
153  {
154  poly = new QEPolygonCellType(3);
155  cellpointer.TakeOwnership(poly);
156  cellpointer->SetPointId(0, simpleSquareCells[3 * i]);
157  cellpointer->SetPointId(1, simpleSquareCells[3 * i + 1]);
158  cellpointer->SetPointId(2, simpleSquareCells[3 * i + 2]);
159  mesh->SetCell(i, cellpointer);
160  }
161 }
162 
163 //----------------------------------------------------------------------------
164 template <typename TMesh>
165 void
166 CreateTetraedronMesh(typename TMesh::Pointer mesh)
167 {
168  using MeshType = TMesh;
169  using CellType = typename MeshType::CellType;
170 
171  using QEPolygonCellType = itk::QuadEdgeMeshPolygonCell<CellType>;
172 
173  if (mesh->GetNumberOfPoints())
174  {
175  mesh->Clear();
176  mesh->ClearFreePointAndCellIndexesLists();
177  }
178 
180  constexpr int expectedNumPts = 4;
181  constexpr int expectedNumCells = 4;
182  const int simpleSquareCells[12] = { 0, 1, 2, 1, 0, 3, 1, 3, 2, 2, 3, 0 };
183 
184  using PointType = typename TMesh::PointType;
185  std::vector<PointType> pts(4);
186  {
187  int i(0);
188  pts[i][0] = 0.;
189  pts[i][1] = 1.;
190  pts[i++][2] = 0.;
191  pts[i][0] = 0.;
192  pts[i][1] = -1.;
193  pts[i++][2] = 0.;
194  pts[i][0] = -1.;
195  pts[i][1] = 0.;
196  pts[i++][2] = 0.;
197  pts[i][0] = 0.;
198  pts[i][1] = 0.;
199  pts[i++][2] = 1.;
200  }
201  for (int i = 0; i < expectedNumPts; ++i)
202  {
203  mesh->SetPoint(i, pts[i]);
204  }
205 
206  typename CellType::CellAutoPointer cellpointer;
207 
208  for (int i = 0; i < expectedNumCells; ++i)
209  {
210  QEPolygonCellType * poly = new QEPolygonCellType(3);
211  cellpointer.TakeOwnership(poly);
212  cellpointer->SetPointId(0, simpleSquareCells[3 * i]);
213  cellpointer->SetPointId(1, simpleSquareCells[3 * i + 1]);
214  cellpointer->SetPointId(2, simpleSquareCells[3 * i + 2]);
215  mesh->SetCell(i, cellpointer);
216  }
217 }
218 
219 
220 //----------------------------------------------------------------------------
221 template <typename TMesh>
222 void
223 CreateSamosa(typename TMesh::Pointer mesh)
224 {
225  using MeshType = TMesh;
226  using CellType = typename MeshType::CellType;
227 
228  using QEPolygonCellType = itk::QuadEdgeMeshPolygonCell<CellType>;
229 
230  if (mesh->GetNumberOfPoints())
231  {
232  mesh->Clear();
233  mesh->ClearFreePointAndCellIndexesLists();
234  }
235 
237  constexpr int expectedNumPts = 3;
238  constexpr int expectedNumCells = 2;
239  const int simpleSquareCells[6] = { 0, 1, 2, 1, 0, 2 };
240 
241  using PointType = typename TMesh::PointType;
242  std::vector<PointType> pts(3);
243  {
244  int i(0);
245  pts[i][0] = 0.;
246  pts[i][1] = 1.;
247  pts[i++][2] = 0.;
248  pts[i][0] = 0.;
249  pts[i][1] = -1.;
250  pts[i++][2] = 0.;
251  pts[i][0] = -1.;
252  pts[i][1] = 0.;
253  pts[i++][2] = 0.;
254  }
255  for (int i = 0; i < expectedNumPts; ++i)
256  {
257  mesh->SetPoint(i, pts[i]);
258  }
259 
260  typename CellType::CellAutoPointer cellpointer;
261  for (int i = 0; i < expectedNumCells; ++i)
262  {
263  QEPolygonCellType * poly = new QEPolygonCellType(3);
264  cellpointer.TakeOwnership(poly);
265  cellpointer->SetPointId(0, simpleSquareCells[3 * i]);
266  cellpointer->SetPointId(1, simpleSquareCells[3 * i + 1]);
267  cellpointer->SetPointId(2, simpleSquareCells[3 * i + 2]);
268  mesh->SetCell(i, cellpointer);
269  }
270 }
271 
272 
273 #endif
Pointer
SmartPointer< Self > Pointer
Definition: itkAddImageFilter.h:93
IdentifierType
unsigned long IdentifierType
Definition: itkQuadEdgeMeshEulerOperatorsTestHelper.h:24
CreateSamosa
void CreateSamosa(typename TMesh::Pointer mesh)
Definition: itkQuadEdgeMeshEulerOperatorsTestHelper.h:223
itkQuadEdgeMeshTopologyChecker.h
itk::GTest::TypedefsAndConstructors::Dimension2::PointType
ImageBaseType::PointType PointType
Definition: itkGTestTypedefsAndConstructors.h:51
CreateSquareTriangularMesh
void CreateSquareTriangularMesh(typename TMesh::Pointer mesh)
Definition: itkQuadEdgeMeshEulerOperatorsTestHelper.h:119
CreateTetraedronMesh
void CreateTetraedronMesh(typename TMesh::Pointer mesh)
Definition: itkQuadEdgeMeshEulerOperatorsTestHelper.h:166
itk::QuadEdgeMeshPolygonCell
Definition: itkQuadEdgeMeshPolygonCell.h:39
itkQuadEdgeMeshPolygonCell.h
itk::QuadEdgeMeshTopologyChecker
Make some basic checks in order to verify that the considered mesh is not degenerated and correctly r...
Definition: itkQuadEdgeMeshTopologyChecker.h:42
AssertTopologicalInvariants
bool AssertTopologicalInvariants(TMesh *mesh, IdentifierType NumVertices, IdentifierType NumFaces, IdentifierType NumEdges, IdentifierType NumBorders, IdentifierType Genus)
Definition: itkQuadEdgeMeshEulerOperatorsTestHelper.h:28
GeneratePointCoordinates
std::vector< typename TMesh::PointType > GeneratePointCoordinates(const unsigned int iN)
Definition: itkQuadEdgeMeshEulerOperatorsTestHelper.h:49
New
static Pointer New()
CreateSquareQuadMesh
void CreateSquareQuadMesh(typename TMesh::Pointer mesh)
Definition: itkQuadEdgeMeshEulerOperatorsTestHelper.h:71
Tarballs of the nightly generated Doxygen documentation are available for the html, xml, and tag file. Previous versions of this documentation for version: 5.3, 5.2, 5.1, 5.0, 4.13, 3.20.
Generated on unknown for ITK by   doxygen 1.8.16