ITK  6.0.0
Insight Toolkit
itkMeshIOTestHelper.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 itkMeshIOTestHelper_h
19 #define itkMeshIOTestHelper_h
20 
21 #include "itkArray.h"
22 #include "itkCommonEnums.h"
23 #include "itkCovariantVector.h"
24 #include "itkFixedArray.h"
25 #include "itkDiffusionTensor3D.h"
26 #include "itkMacro.h"
27 #include "itkMatrix.h"
28 #include "itkMeshIOBase.h"
29 #include "itkRGBAPixel.h"
30 #include "itkRGBPixel.h"
31 #include "itkSymmetricSecondRankTensor.h"
32 #include "itkVariableLengthVector.h"
33 #include "itkVariableSizeMatrix.h"
34 #include "itkVector.h"
35 #include <complex>
36 #include <iostream>
37 
38 
39 // Define a local macro for variable to command testing to avoid including
40 // itkTestingMacros.h, which causes link issues as the module hosting this
41 // file is not a testing module.
42 #define LOCAL_ITK_TEST_SET_GET_VALUE(variable, command) \
43  ITK_GCC_PRAGMA_PUSH \
44  ITK_GCC_SUPPRESS_Wfloat_equal \
45  if (variable != command) \
46  { \
47  std::cerr << "Error in " << #command << std::endl; \
48  std::cerr << " In " __FILE__ ", line " << __LINE__ << std::endl; \
49  std::cerr << "Expected " << variable << std::endl; \
50  std::cerr << "but got " << command << std::endl; \
51  return EXIT_FAILURE; \
52  } \
53  ITK_GCC_PRAGMA_POP \
54  ITK_MACROEND_NOOP_STATEMENT
55 
56 
57 template <typename TMeshIO>
58 int
59 TestBaseClassMethodsMeshIO(typename TMeshIO::Pointer meshIO)
60 {
61  using FloatType = float;
62 
63  constexpr FloatType floatValue = 1.0;
64  bool usePointPixel = true;
65  meshIO->SetPixelType(floatValue, usePointPixel);
66  LOCAL_ITK_TEST_SET_GET_VALUE(1, meshIO->GetNumberOfPointPixelComponents());
67  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
68  meshIO->GetPointPixelComponentType());
69  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::SCALAR, meshIO->GetPointPixelType());
70 
71  usePointPixel = false;
72  meshIO->SetPixelType(floatValue, usePointPixel);
73  LOCAL_ITK_TEST_SET_GET_VALUE(1, meshIO->GetNumberOfCellPixelComponents());
74  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
75  meshIO->GetCellPixelComponentType());
76  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::SCALAR, meshIO->GetCellPixelType());
77 
78 
79  using RGBPixelType = itk::RGBPixel<FloatType>;
80 
81  const RGBPixelType rgbValue{ 1.0 };
82  usePointPixel = true;
83  meshIO->SetPixelType(rgbValue, usePointPixel);
84  LOCAL_ITK_TEST_SET_GET_VALUE(3, meshIO->GetNumberOfPointPixelComponents());
85  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
86  meshIO->GetPointPixelComponentType());
87  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::RGB, meshIO->GetPointPixelType());
88 
89  usePointPixel = false;
90  meshIO->SetPixelType(rgbValue, usePointPixel);
91  LOCAL_ITK_TEST_SET_GET_VALUE(3, meshIO->GetNumberOfCellPixelComponents());
92  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
93  meshIO->GetCellPixelComponentType());
94  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::RGB, meshIO->GetCellPixelType());
95 
96 
97  using RGBAPixelType = itk::RGBAPixel<FloatType>;
98 
99  auto rgbaValue = itk::MakeFilled<RGBAPixelType>(1.0);
100  usePointPixel = true;
101  meshIO->SetPixelType(rgbaValue, usePointPixel);
102  LOCAL_ITK_TEST_SET_GET_VALUE(4, meshIO->GetNumberOfPointPixelComponents());
103  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
104  meshIO->GetPointPixelComponentType());
105  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::RGBA, meshIO->GetPointPixelType());
106 
107  usePointPixel = false;
108  meshIO->SetPixelType(rgbaValue, usePointPixel);
109  LOCAL_ITK_TEST_SET_GET_VALUE(4, meshIO->GetNumberOfCellPixelComponents());
110  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
111  meshIO->GetCellPixelComponentType());
112  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::RGBA, meshIO->GetCellPixelType());
113 
114 
115  constexpr itk::SizeValueType length = 5;
116  using VectorPixelType = itk::Vector<FloatType, length>;
117 
118  auto vectorValue = itk::MakeFilled<VectorPixelType>(1.0);
119  usePointPixel = true;
120  meshIO->SetPixelType(vectorValue, usePointPixel);
121  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfPointPixelComponents());
122  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
123  meshIO->GetPointPixelComponentType());
124  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::VECTOR, meshIO->GetPointPixelType());
125 
126  usePointPixel = false;
127  meshIO->SetPixelType(vectorValue, usePointPixel);
128  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfCellPixelComponents());
129  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
130  meshIO->GetCellPixelComponentType());
131  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::VECTOR, meshIO->GetCellPixelType());
132 
133 
134  using CovariantVectorPixelType = itk::CovariantVector<FloatType, length>;
135 
136  auto covariantVectorValue = itk::MakeFilled<CovariantVectorPixelType>(1.0);
137  usePointPixel = true;
138  meshIO->SetPixelType(covariantVectorValue, usePointPixel);
139  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfPointPixelComponents());
140  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
141  meshIO->GetPointPixelComponentType());
142  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::COVARIANTVECTOR, meshIO->GetPointPixelType());
143 
144  usePointPixel = false;
145  meshIO->SetPixelType(covariantVectorValue, usePointPixel);
146  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfCellPixelComponents());
147  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
148  meshIO->GetCellPixelComponentType());
149  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::COVARIANTVECTOR, meshIO->GetCellPixelType());
150 
151 
152  using FixedArrayPixelType = itk::FixedArray<FloatType, length>;
153 
154  auto fixedArrayValue = itk::MakeFilled<FixedArrayPixelType>(1.0);
155  usePointPixel = true;
156  meshIO->SetPixelType(fixedArrayValue, usePointPixel);
157  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfPointPixelComponents());
158  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
159  meshIO->GetPointPixelComponentType());
160  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::FIXEDARRAY, meshIO->GetPointPixelType());
161 
162  usePointPixel = false;
163  meshIO->SetPixelType(fixedArrayValue, usePointPixel);
164  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfCellPixelComponents());
165  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
166  meshIO->GetCellPixelComponentType());
167  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::FIXEDARRAY, meshIO->GetCellPixelType());
168 
169 
170  using SymmetricSecondRankTensorPixelType = itk::SymmetricSecondRankTensor<FloatType, length>;
171 
172  auto symmetricSecondRankTensorValue = itk::MakeFilled<SymmetricSecondRankTensorPixelType>(1.0);
173  usePointPixel = true;
174  meshIO->SetPixelType(symmetricSecondRankTensorValue, usePointPixel);
175  LOCAL_ITK_TEST_SET_GET_VALUE(length * (length + 1) / 2, meshIO->GetNumberOfPointPixelComponents());
176  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
177  meshIO->GetPointPixelComponentType());
178  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::SYMMETRICSECONDRANKTENSOR, meshIO->GetPointPixelType());
179 
180  usePointPixel = false;
181  meshIO->SetPixelType(symmetricSecondRankTensorValue, usePointPixel);
182  LOCAL_ITK_TEST_SET_GET_VALUE(length * (length + 1) / 2, meshIO->GetNumberOfCellPixelComponents());
183  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
184  meshIO->GetCellPixelComponentType());
185  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::SYMMETRICSECONDRANKTENSOR, meshIO->GetCellPixelType());
186 
187 
188  using DiffusionTensor3DPixelType = itk::DiffusionTensor3D<FloatType>;
189 
190  auto diffusionTensor3DPixelValue = itk::MakeFilled<DiffusionTensor3DPixelType>(1.0);
191  usePointPixel = true;
192  meshIO->SetPixelType(diffusionTensor3DPixelValue, usePointPixel);
193  LOCAL_ITK_TEST_SET_GET_VALUE(6, meshIO->GetNumberOfPointPixelComponents());
194  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
195  meshIO->GetPointPixelComponentType());
196  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::DIFFUSIONTENSOR3D, meshIO->GetPointPixelType());
197 
198  usePointPixel = false;
199  meshIO->SetPixelType(diffusionTensor3DPixelValue, usePointPixel);
200  LOCAL_ITK_TEST_SET_GET_VALUE(6, meshIO->GetNumberOfCellPixelComponents());
201  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
202  meshIO->GetCellPixelComponentType());
203  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::DIFFUSIONTENSOR3D, meshIO->GetCellPixelType());
204 
205 
206  constexpr itk::SizeValueType rows = 2;
207  constexpr itk::SizeValueType cols = 2;
208  using MatrixPixelType = itk::Matrix<FloatType, rows, cols>;
209 
210  auto matrixPixelValue = itk::MakeFilled<MatrixPixelType>(1.0);
211  usePointPixel = true;
212  meshIO->SetPixelType(matrixPixelValue, usePointPixel);
213  LOCAL_ITK_TEST_SET_GET_VALUE(rows * cols, meshIO->GetNumberOfPointPixelComponents());
214  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
215  meshIO->GetPointPixelComponentType());
216  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::MATRIX, meshIO->GetPointPixelType());
217 
218  usePointPixel = false;
219  meshIO->SetPixelType(matrixPixelValue, usePointPixel);
220  LOCAL_ITK_TEST_SET_GET_VALUE(rows * cols, meshIO->GetNumberOfCellPixelComponents());
221  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
222  meshIO->GetCellPixelComponentType());
223  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::MATRIX, meshIO->GetCellPixelType());
224 
225 
226  using ComplexPixelType = std::complex<FloatType>;
227 
228  const ComplexPixelType complexPixelValue(1.0, 1.0);
229  usePointPixel = true;
230  meshIO->SetPixelType(complexPixelValue, usePointPixel);
231  LOCAL_ITK_TEST_SET_GET_VALUE(2, meshIO->GetNumberOfPointPixelComponents());
232  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
233  meshIO->GetPointPixelComponentType());
234  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::COMPLEX, meshIO->GetPointPixelType());
235 
236  usePointPixel = false;
237  meshIO->SetPixelType(complexPixelValue, usePointPixel);
238  LOCAL_ITK_TEST_SET_GET_VALUE(2, meshIO->GetNumberOfCellPixelComponents());
239  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
240  meshIO->GetCellPixelComponentType());
241  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::COMPLEX, meshIO->GetCellPixelType());
242 
243 
244  using ArrayPixelType = itk::Array<FloatType>;
245 
246  const ArrayPixelType arrayPixelValue{};
247  usePointPixel = true;
248  meshIO->SetPixelType(arrayPixelValue, usePointPixel);
249  LOCAL_ITK_TEST_SET_GET_VALUE(arrayPixelValue.Size(), meshIO->GetNumberOfPointPixelComponents());
250  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
251  meshIO->GetPointPixelComponentType());
252  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::ARRAY, meshIO->GetPointPixelType());
253 
254  usePointPixel = false;
255  meshIO->SetPixelType(arrayPixelValue, usePointPixel);
256  LOCAL_ITK_TEST_SET_GET_VALUE(arrayPixelValue.Size(), meshIO->GetNumberOfCellPixelComponents());
257  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
258  meshIO->GetCellPixelComponentType());
259  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::ARRAY, meshIO->GetCellPixelType());
260 
261 
262  using VariableLengthVectorPixelType = itk::VariableLengthVector<FloatType>;
263 
264  const VariableLengthVectorPixelType variableLengthVectorValue{};
265  usePointPixel = true;
266  meshIO->SetPixelType(variableLengthVectorValue, usePointPixel);
267  LOCAL_ITK_TEST_SET_GET_VALUE(variableLengthVectorValue.Size(), meshIO->GetNumberOfPointPixelComponents());
268  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
269  meshIO->GetPointPixelComponentType());
270  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::VARIABLELENGTHVECTOR, meshIO->GetPointPixelType());
271 
272  usePointPixel = false;
273  meshIO->SetPixelType(variableLengthVectorValue, usePointPixel);
274  LOCAL_ITK_TEST_SET_GET_VALUE(variableLengthVectorValue.Size(), meshIO->GetNumberOfCellPixelComponents());
275  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
276  meshIO->GetCellPixelComponentType());
277  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::VARIABLELENGTHVECTOR, meshIO->GetCellPixelType());
278 
279 
280  using VariableSizeMatrixType = itk::VariableSizeMatrix<FloatType>;
281 
282  const VariableSizeMatrixType matrix{};
283  usePointPixel = true;
284  meshIO->SetPixelType(matrix, usePointPixel);
285  LOCAL_ITK_TEST_SET_GET_VALUE(matrix.Rows() * matrix.Cols(), meshIO->GetNumberOfPointPixelComponents());
286  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
287  meshIO->GetPointPixelComponentType());
288  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::VARIABLESIZEMATRIX, meshIO->GetPointPixelType());
289 
290  usePointPixel = false;
291  meshIO->SetPixelType(matrix, usePointPixel);
292  LOCAL_ITK_TEST_SET_GET_VALUE(matrix.Rows() * matrix.Cols(), meshIO->GetNumberOfCellPixelComponents());
293  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
294  meshIO->GetCellPixelComponentType());
295  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::VARIABLESIZEMATRIX, meshIO->GetCellPixelType());
296 
297 
298  // ToDo see how the above change the below
299  // Do this only for the last pixel type
300  const itk::IOComponentEnum floatComponent = itk::IOComponentEnum::FLOAT;
301  std::cout << "ComponentSize: " << meshIO->GetComponentSize(floatComponent) << std::endl;
302 
303  std::cout << "ComponentTypeAsString: " << meshIO->GetComponentTypeAsString(floatComponent) << std::endl;
304 
305  const itk::CommonEnums::IOPixel pixelType = itk::CommonEnums::IOPixel::SCALAR;
306  std::cout << "PixelTypeAsString: " << meshIO->GetPixelTypeAsString(pixelType) << std::endl;
307 
308  const itk::CommonEnums::IOComponent pointComponentType = itk::CommonEnums::IOComponent::FLOAT;
309  meshIO->SetPointComponentType(pointComponentType);
310  LOCAL_ITK_TEST_SET_GET_VALUE(pointComponentType, meshIO->GetPointComponentType());
311 
312  const itk::CommonEnums::IOComponent cellComponentType = itk::CommonEnums::IOComponent::FLOAT;
313  meshIO->SetCellComponentType(cellComponentType);
314  LOCAL_ITK_TEST_SET_GET_VALUE(cellComponentType, meshIO->GetCellComponentType());
315 
316  constexpr unsigned int pointDimension = 2;
317  meshIO->SetPointDimension(pointDimension);
318  LOCAL_ITK_TEST_SET_GET_VALUE(pointDimension, meshIO->GetPointDimension());
319 
320  constexpr itk::MeshIOBase::SizeValueType numberOfPoints = 400;
321  meshIO->SetNumberOfPoints(numberOfPoints);
322  LOCAL_ITK_TEST_SET_GET_VALUE(numberOfPoints, meshIO->GetNumberOfPoints());
323 
324  constexpr itk::MeshIOBase::SizeValueType numberOfCells = 100;
325  meshIO->SetNumberOfCells(numberOfCells);
326  LOCAL_ITK_TEST_SET_GET_VALUE(numberOfCells, meshIO->GetNumberOfCells());
327 
328  constexpr itk::MeshIOBase::SizeValueType numberOfPointPixels = 200;
329  meshIO->SetNumberOfPointPixels(numberOfPointPixels);
330  LOCAL_ITK_TEST_SET_GET_VALUE(numberOfPointPixels, meshIO->GetNumberOfPointPixels());
331 
332  constexpr itk::MeshIOBase::SizeValueType numberOfCellPixels = 600;
333  meshIO->SetNumberOfCellPixels(numberOfCellPixels);
334  LOCAL_ITK_TEST_SET_GET_VALUE(numberOfCellPixels, meshIO->GetNumberOfCellPixels());
335 
336  constexpr itk::MeshIOBase::SizeValueType cellBufferSize = 1000;
337  meshIO->SetCellBufferSize(cellBufferSize);
338  LOCAL_ITK_TEST_SET_GET_VALUE(cellBufferSize, meshIO->GetCellBufferSize());
339 
340  const itk::IOFileEnum fileType = itk::IOFileEnum::ASCII;
341  meshIO->SetFileType(fileType);
342  LOCAL_ITK_TEST_SET_GET_VALUE(fileType, meshIO->GetFileType());
343 
344  std::cout << "FileTypeAsString: " << meshIO->GetFileTypeAsString(fileType) << std::endl;
345 
346  const itk::IOByteOrderEnum ioByteOrder = itk::IOByteOrderEnum::BigEndian;
347  meshIO->SetByteOrder(ioByteOrder);
348  LOCAL_ITK_TEST_SET_GET_VALUE(ioByteOrder, meshIO->GetByteOrder());
349 
350  std::cout << "ByteOrderAsString: " << meshIO->GetByteOrderAsString(ioByteOrder) << std::endl;
351 
352  const itk::MeshIOBase::ArrayOfExtensionsType supportedReadExtensions = meshIO->GetSupportedReadExtensions();
353  std::cout << "SupportedReadExtensions: " << std::endl;
354  for (const auto & ext : supportedReadExtensions)
355  {
356  std::cout << ext << std::endl;
357  }
358 
359  const itk::MeshIOBase::ArrayOfExtensionsType supportedWriteExtensions = meshIO->GetSupportedWriteExtensions();
360  std::cout << "SupportedWriteExtensions: " << std::endl;
361  for (const auto & ext : supportedWriteExtensions)
362  {
363  std::cout << ext << std::endl;
364  }
365 
366 
367  return EXIT_SUCCESS;
368 }
369 
370 namespace itk
371 {
372 namespace MeshIOTestHelper
373 {
374 
375 template <typename T>
376 std::shared_ptr<void>
377 MakeSharedArray(const std::size_t bufferSize)
378 {
379  return std::shared_ptr<void>(new T[bufferSize], std::default_delete<T[]>());
380 }
381 
382 inline std::shared_ptr<void>
383 AllocateBuffer(itk::IOComponentEnum componentType, itk::SizeValueType bufferSize)
384 {
385  switch (componentType)
386  {
387  case itk::IOComponentEnum::CHAR:
388  return MakeSharedArray<char>(bufferSize);
389  case itk::IOComponentEnum::UCHAR:
390  return MakeSharedArray<unsigned char>(bufferSize);
391  case itk::IOComponentEnum::USHORT:
392  return MakeSharedArray<unsigned short>(bufferSize);
393  case itk::IOComponentEnum::SHORT:
394  return MakeSharedArray<short>(bufferSize);
395  case itk::IOComponentEnum::UINT:
396  return MakeSharedArray<unsigned int>(bufferSize);
397  case itk::IOComponentEnum::INT:
398  return MakeSharedArray<int>(bufferSize);
399  case itk::IOComponentEnum::ULONG:
400  return MakeSharedArray<unsigned long>(bufferSize);
401  case itk::IOComponentEnum::LONG:
402  return MakeSharedArray<long>(bufferSize);
403  case itk::IOComponentEnum::LONGLONG:
404  return MakeSharedArray<long long>(bufferSize);
405  case itk::IOComponentEnum::ULONGLONG:
406  return MakeSharedArray<unsigned long long>(bufferSize);
407  case itk::IOComponentEnum::FLOAT:
408  return MakeSharedArray<float>(bufferSize);
409  case itk::IOComponentEnum::DOUBLE:
410  return MakeSharedArray<double>(bufferSize);
411  case itk::IOComponentEnum::LDOUBLE:
412  return MakeSharedArray<long double>(bufferSize);
413  case itk::IOComponentEnum::UNKNOWNCOMPONENTTYPE:
414  break;
415  default:
416  break;
417  }
418 
419  return nullptr;
420 }
421 
422 } // namespace MeshIOTestHelper
423 } // namespace itk
424 
425 #endif
itk::CommonEnums::IOComponent::UNKNOWNCOMPONENTTYPE
itk::MeshIOBase::ArrayOfExtensionsType
std::vector< std::string > ArrayOfExtensionsType
Definition: itkMeshIOBase.h:84
Pointer
SmartPointer< Self > Pointer
Definition: itkAddImageFilter.h:93
itk::CommonEnums::IOComponent::FLOAT
itk::RGBPixel
Represent Red, Green and Blue components for color images.
Definition: itkRGBPixel.h:58
itkCovariantVector.h
itkRGBPixel.h
itk::MeshIOBase::SizeValueType
IdentifierType SizeValueType
Definition: itkMeshIOBase.h:89
itk::CommonEnums::IOPixel::VARIABLESIZEMATRIX
itkVariableSizeMatrix.h
itkMatrix.h
itk::CommonEnums::IOComponent::LDOUBLE
itk::CommonEnums::IOPixel::ARRAY
itk::CommonEnums::IOComponent::LONGLONG
itk::CommonEnums::IOComponent::INT
itkVariableLengthVector.h
itk::CommonEnums::IOByteOrder::BigEndian
itkDiffusionTensor3D.h
itk::Vector
A templated class holding a n-Dimensional vector.
Definition: itkVector.h:62
itk::CommonEnums::IOComponent::CHAR
itk::CommonEnums::IOComponent::SHORT
itk::DiffusionTensor3D
Represent a diffusion tensor as used in DTI images.
Definition: itkDiffusionTensor3D.h:79
itkRGBAPixel.h
itk::CommonEnums::IOFile::ASCII
itk::CommonEnums::IOComponent::DOUBLE
itk::VariableSizeMatrix
A templated class holding a M x N size Matrix.
Definition: itkVariableSizeMatrix.h:45
TestBaseClassMethodsMeshIO
int TestBaseClassMethodsMeshIO(typename TMeshIO::Pointer meshIO)
Definition: itkMeshIOTestHelper.h:59
itk::CommonEnums::IOPixel::COVARIANTVECTOR
itk::CommonEnums::IOPixel
IOPixel
Definition: itkCommonEnums.h:48
itk::CommonEnums::IOComponent
IOComponent
Definition: itkCommonEnums.h:74
itk::SymmetricSecondRankTensor
Represent a symmetric tensor of second rank.
Definition: itkSymmetricSecondRankTensor.h:75
itkMacro.h
itkSymmetricSecondRankTensor.h
itkFixedArray.h
itk::CommonEnums::IOPixel::MATRIX
itk::MeshIOBase::MapComponentType
Definition: itkMeshIOBase.h:204
itk::CommonEnums::IOFile
IOFile
Definition: itkCommonEnums.h:97
itk::CommonEnums::IOPixel::COMPLEX
itk::VariableLengthVector
Represents an array whose length can be defined at run-time.
Definition: itkConstantBoundaryCondition.h:28
itk::FixedArray
Simulate a standard C array with copy semantics.
Definition: itkFixedArray.h:53
itk::CommonEnums::IOPixel::VECTOR
itk::CommonEnums::IOPixel::VARIABLELENGTHVECTOR
itk::Matrix
A templated class holding a M x N size Matrix.
Definition: itkMatrix.h:52
itk::CommonEnums::IOComponent::ULONG
itk::CommonEnums::IOComponent::USHORT
itk::CovariantVector
A templated class holding a n-Dimensional covariant vector.
Definition: itkCovariantVector.h:70
itkArray.h
itkMeshIOBase.h
itk::MeshIOTestHelper::MakeSharedArray
std::shared_ptr< void > MakeSharedArray(const std::vcl_size_t bufferSize)
Definition: itkMeshIOTestHelper.h:377
LOCAL_ITK_TEST_SET_GET_VALUE
#define LOCAL_ITK_TEST_SET_GET_VALUE(variable, command)
Definition: itkMeshIOTestHelper.h:42
itk::RGBAPixel
Represent Red, Green, Blue and Alpha components for color images.
Definition: itkRGBAPixel.h:59
itk
The "itk" namespace contains all Insight Segmentation and Registration Toolkit (ITK) classes....
Definition: itkAnatomicalOrientation.h:29
itk::CommonEnums::IOComponent::ULONGLONG
itkCommonEnums.h
itk::CommonEnums::IOPixel::RGB
itk::MeshIOTestHelper::AllocateBuffer
std::shared_ptr< void > AllocateBuffer(itk::IOComponentEnum componentType, itk::SizeValueType bufferSize)
Definition: itkMeshIOTestHelper.h:383
itkVector.h
itk::Array
Array class with size defined at construction time.
Definition: itkArray.h:47
itk::CommonEnums::IOComponent::UCHAR
itk::CommonEnums::IOPixel::FIXEDARRAY
itk::CommonEnums::IOPixel::SCALAR
itk::CommonEnums::IOPixel::SYMMETRICSECONDRANKTENSOR
itk::CommonEnums::IOByteOrder
IOByteOrder
Definition: itkCommonEnums.h:122
itk::CommonEnums::IOComponent::LONG
itk::CommonEnums::IOPixel::RGBA
itk::CommonEnums::IOPixel::DIFFUSIONTENSOR3D
itk::SizeValueType
unsigned long SizeValueType
Definition: itkIntTypes.h:86
itk::CommonEnums::IOComponent::UINT
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