ITK  5.4.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  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  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  RGBAPixelType rgbaValue;
100  rgbaValue.Fill(1.0);
101  usePointPixel = true;
102  meshIO->SetPixelType(rgbaValue, usePointPixel);
103  LOCAL_ITK_TEST_SET_GET_VALUE(4, meshIO->GetNumberOfPointPixelComponents());
104  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
105  meshIO->GetPointPixelComponentType());
106  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::RGBA, meshIO->GetPointPixelType());
107 
108  usePointPixel = false;
109  meshIO->SetPixelType(rgbaValue, usePointPixel);
110  LOCAL_ITK_TEST_SET_GET_VALUE(4, meshIO->GetNumberOfCellPixelComponents());
111  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
112  meshIO->GetCellPixelComponentType());
113  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::RGBA, meshIO->GetCellPixelType());
114 
115 
116  const itk::SizeValueType length = 5;
117  using VectorPixelType = itk::Vector<FloatType, length>;
118 
119  VectorPixelType vectorValue;
120  vectorValue.Fill(1.0);
121  usePointPixel = true;
122  meshIO->SetPixelType(vectorValue, usePointPixel);
123  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfPointPixelComponents());
124  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
125  meshIO->GetPointPixelComponentType());
126  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::VECTOR, meshIO->GetPointPixelType());
127 
128  usePointPixel = false;
129  meshIO->SetPixelType(vectorValue, usePointPixel);
130  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfCellPixelComponents());
131  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
132  meshIO->GetCellPixelComponentType());
133  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::VECTOR, meshIO->GetCellPixelType());
134 
135 
136  using CovariantVectorPixelType = itk::CovariantVector<FloatType, length>;
137 
138  CovariantVectorPixelType covariantVectorValue;
139  covariantVectorValue.Fill(1.0);
140  usePointPixel = true;
141  meshIO->SetPixelType(covariantVectorValue, usePointPixel);
142  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfPointPixelComponents());
143  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
144  meshIO->GetPointPixelComponentType());
145  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::COVARIANTVECTOR, meshIO->GetPointPixelType());
146 
147  usePointPixel = false;
148  meshIO->SetPixelType(covariantVectorValue, usePointPixel);
149  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfCellPixelComponents());
150  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
151  meshIO->GetCellPixelComponentType());
152  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::COVARIANTVECTOR, meshIO->GetCellPixelType());
153 
154 
155  using FixedArrayPixelType = itk::FixedArray<FloatType, length>;
156 
157  FixedArrayPixelType fixedArrayValue;
158  fixedArrayValue.Fill(1.0);
159  usePointPixel = true;
160  meshIO->SetPixelType(fixedArrayValue, usePointPixel);
161  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfPointPixelComponents());
162  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
163  meshIO->GetPointPixelComponentType());
164  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::FIXEDARRAY, meshIO->GetPointPixelType());
165 
166  usePointPixel = false;
167  meshIO->SetPixelType(fixedArrayValue, usePointPixel);
168  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfCellPixelComponents());
169  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
170  meshIO->GetCellPixelComponentType());
171  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::FIXEDARRAY, meshIO->GetCellPixelType());
172 
173 
174  using SymmetricSecondRankTensorPixelType = itk::SymmetricSecondRankTensor<FloatType, length>;
175 
176  SymmetricSecondRankTensorPixelType symmetricSecondRankTensorValue;
177  symmetricSecondRankTensorValue.Fill(1.0);
178  usePointPixel = true;
179  meshIO->SetPixelType(symmetricSecondRankTensorValue, usePointPixel);
180  LOCAL_ITK_TEST_SET_GET_VALUE(length * (length + 1) / 2, meshIO->GetNumberOfPointPixelComponents());
181  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
182  meshIO->GetPointPixelComponentType());
183  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::SYMMETRICSECONDRANKTENSOR, meshIO->GetPointPixelType());
184 
185  usePointPixel = false;
186  meshIO->SetPixelType(symmetricSecondRankTensorValue, usePointPixel);
187  LOCAL_ITK_TEST_SET_GET_VALUE(length * (length + 1) / 2, meshIO->GetNumberOfCellPixelComponents());
188  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
189  meshIO->GetCellPixelComponentType());
190  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::SYMMETRICSECONDRANKTENSOR, meshIO->GetCellPixelType());
191 
192 
193  using DiffusionTensor3DPixelType = itk::DiffusionTensor3D<FloatType>;
194 
195  DiffusionTensor3DPixelType diffusionTensor3DPixelValue;
196  diffusionTensor3DPixelValue.Fill(1.0);
197  usePointPixel = true;
198  meshIO->SetPixelType(diffusionTensor3DPixelValue, usePointPixel);
199  LOCAL_ITK_TEST_SET_GET_VALUE(6, meshIO->GetNumberOfPointPixelComponents());
200  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
201  meshIO->GetPointPixelComponentType());
202  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::DIFFUSIONTENSOR3D, meshIO->GetPointPixelType());
203 
204  usePointPixel = false;
205  meshIO->SetPixelType(diffusionTensor3DPixelValue, usePointPixel);
206  LOCAL_ITK_TEST_SET_GET_VALUE(6, meshIO->GetNumberOfCellPixelComponents());
207  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
208  meshIO->GetCellPixelComponentType());
209  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::DIFFUSIONTENSOR3D, meshIO->GetCellPixelType());
210 
211 
212  const itk::SizeValueType rows = 2;
213  const itk::SizeValueType cols = 2;
214  using MatrixPixelType = itk::Matrix<FloatType, rows, cols>;
215 
216  MatrixPixelType matrixPixelValue;
217  matrixPixelValue.Fill(1.0);
218  usePointPixel = true;
219  meshIO->SetPixelType(matrixPixelValue, usePointPixel);
220  LOCAL_ITK_TEST_SET_GET_VALUE(rows * cols, meshIO->GetNumberOfPointPixelComponents());
221  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
222  meshIO->GetPointPixelComponentType());
223  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::MATRIX, meshIO->GetPointPixelType());
224 
225  usePointPixel = false;
226  meshIO->SetPixelType(matrixPixelValue, usePointPixel);
227  LOCAL_ITK_TEST_SET_GET_VALUE(rows * cols, meshIO->GetNumberOfCellPixelComponents());
228  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
229  meshIO->GetCellPixelComponentType());
230  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::MATRIX, meshIO->GetCellPixelType());
231 
232 
233  using ComplexPixelType = std::complex<FloatType>;
234 
235  ComplexPixelType complexPixelValue(1.0, 1.0);
236  usePointPixel = true;
237  meshIO->SetPixelType(complexPixelValue, usePointPixel);
238  LOCAL_ITK_TEST_SET_GET_VALUE(2, meshIO->GetNumberOfPointPixelComponents());
239  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
240  meshIO->GetPointPixelComponentType());
241  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::COMPLEX, meshIO->GetPointPixelType());
242 
243  usePointPixel = false;
244  meshIO->SetPixelType(complexPixelValue, usePointPixel);
245  LOCAL_ITK_TEST_SET_GET_VALUE(2, meshIO->GetNumberOfCellPixelComponents());
246  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
247  meshIO->GetCellPixelComponentType());
248  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::COMPLEX, meshIO->GetCellPixelType());
249 
250 
251  using ArrayPixelType = itk::Array<FloatType>;
252 
253  ArrayPixelType arrayPixelValue;
254  arrayPixelValue.Fill(1.0);
255  usePointPixel = true;
256  meshIO->SetPixelType(arrayPixelValue, usePointPixel);
257  LOCAL_ITK_TEST_SET_GET_VALUE(arrayPixelValue.Size(), meshIO->GetNumberOfPointPixelComponents());
258  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
259  meshIO->GetPointPixelComponentType());
260  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::ARRAY, meshIO->GetPointPixelType());
261 
262  usePointPixel = false;
263  meshIO->SetPixelType(arrayPixelValue, usePointPixel);
264  LOCAL_ITK_TEST_SET_GET_VALUE(arrayPixelValue.Size(), meshIO->GetNumberOfCellPixelComponents());
265  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
266  meshIO->GetCellPixelComponentType());
267  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::ARRAY, meshIO->GetCellPixelType());
268 
269 
270  using VariableLengthVectorPixelType = itk::VariableLengthVector<FloatType>;
271 
272  VariableLengthVectorPixelType variableLengthVectorValue;
273  variableLengthVectorValue.Fill(1.0);
274  usePointPixel = true;
275  meshIO->SetPixelType(variableLengthVectorValue, usePointPixel);
276  LOCAL_ITK_TEST_SET_GET_VALUE(variableLengthVectorValue.Size(), meshIO->GetNumberOfPointPixelComponents());
277  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
278  meshIO->GetPointPixelComponentType());
279  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::VARIABLELENGTHVECTOR, meshIO->GetPointPixelType());
280 
281  usePointPixel = false;
282  meshIO->SetPixelType(variableLengthVectorValue, usePointPixel);
283  LOCAL_ITK_TEST_SET_GET_VALUE(variableLengthVectorValue.Size(), meshIO->GetNumberOfCellPixelComponents());
284  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
285  meshIO->GetCellPixelComponentType());
286  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::VARIABLELENGTHVECTOR, meshIO->GetCellPixelType());
287 
288 
289  using VariableSizeMatrixType = itk::VariableSizeMatrix<FloatType>;
290 
291  VariableSizeMatrixType matrix;
292  matrix.Fill(1.0);
293  usePointPixel = true;
294  meshIO->SetPixelType(matrix, usePointPixel);
295  LOCAL_ITK_TEST_SET_GET_VALUE(matrix.Rows() * matrix.Cols(), meshIO->GetNumberOfPointPixelComponents());
296  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
297  meshIO->GetPointPixelComponentType());
298  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::VARIABLESIZEMATRIX, meshIO->GetPointPixelType());
299 
300  usePointPixel = false;
301  meshIO->SetPixelType(matrix, usePointPixel);
302  LOCAL_ITK_TEST_SET_GET_VALUE(matrix.Rows() * matrix.Cols(), meshIO->GetNumberOfCellPixelComponents());
303  LOCAL_ITK_TEST_SET_GET_VALUE(itk::MeshIOBase::MapComponentType<FloatType>::CType,
304  meshIO->GetCellPixelComponentType());
305  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::VARIABLESIZEMATRIX, meshIO->GetCellPixelType());
306 
307 
308  // ToDo see how the above change the below
309  // Do this only for the last pixel type
310  itk::IOComponentEnum floatComponent = itk::IOComponentEnum::FLOAT;
311  std::cout << "ComponentSize: " << meshIO->GetComponentSize(floatComponent) << std::endl;
312 
313  std::cout << "ComponentTypeAsString: " << meshIO->GetComponentTypeAsString(floatComponent) << std::endl;
314 
315  itk::CommonEnums::IOPixel pixelType = itk::CommonEnums::IOPixel::SCALAR;
316  std::cout << "PixelTypeAsString: " << meshIO->GetPixelTypeAsString(pixelType) << std::endl;
317 
318  itk::CommonEnums::IOComponent pointComponentType = itk::CommonEnums::IOComponent::FLOAT;
319  meshIO->SetPointComponentType(pointComponentType);
320  LOCAL_ITK_TEST_SET_GET_VALUE(pointComponentType, meshIO->GetPointComponentType());
321 
322  itk::CommonEnums::IOComponent cellComponentType = itk::CommonEnums::IOComponent::FLOAT;
323  meshIO->SetCellComponentType(cellComponentType);
324  LOCAL_ITK_TEST_SET_GET_VALUE(cellComponentType, meshIO->GetCellComponentType());
325 
326  unsigned int pointDimension = 2;
327  meshIO->SetPointDimension(pointDimension);
328  LOCAL_ITK_TEST_SET_GET_VALUE(pointDimension, meshIO->GetPointDimension());
329 
330  itk::MeshIOBase::SizeValueType numberOfPoints = 400;
331  meshIO->SetNumberOfPoints(numberOfPoints);
332  LOCAL_ITK_TEST_SET_GET_VALUE(numberOfPoints, meshIO->GetNumberOfPoints());
333 
334  itk::MeshIOBase::SizeValueType numberOfCells = 100;
335  meshIO->SetNumberOfCells(numberOfCells);
336  LOCAL_ITK_TEST_SET_GET_VALUE(numberOfCells, meshIO->GetNumberOfCells());
337 
338  itk::MeshIOBase::SizeValueType numberOfPointPixels = 200;
339  meshIO->SetNumberOfPointPixels(numberOfPointPixels);
340  LOCAL_ITK_TEST_SET_GET_VALUE(numberOfPointPixels, meshIO->GetNumberOfPointPixels());
341 
342  itk::MeshIOBase::SizeValueType numberOfCellPixels = 600;
343  meshIO->SetNumberOfCellPixels(numberOfCellPixels);
344  LOCAL_ITK_TEST_SET_GET_VALUE(numberOfCellPixels, meshIO->GetNumberOfCellPixels());
345 
346  itk::MeshIOBase::SizeValueType cellBufferSize = 1000;
347  meshIO->SetCellBufferSize(cellBufferSize);
348  LOCAL_ITK_TEST_SET_GET_VALUE(cellBufferSize, meshIO->GetCellBufferSize());
349 
350  itk::IOFileEnum fileType = itk::IOFileEnum::ASCII;
351  meshIO->SetFileType(fileType);
352  LOCAL_ITK_TEST_SET_GET_VALUE(fileType, meshIO->GetFileType());
353 
354  std::cout << "FileTypeAsString: " << meshIO->GetFileTypeAsString(fileType) << std::endl;
355 
356  itk::IOByteOrderEnum ioByteOrder = itk::IOByteOrderEnum::BigEndian;
357  meshIO->SetByteOrder(ioByteOrder);
358  LOCAL_ITK_TEST_SET_GET_VALUE(ioByteOrder, meshIO->GetByteOrder());
359 
360  std::cout << "ByteOrderAsString: " << meshIO->GetByteOrderAsString(ioByteOrder) << std::endl;
361 
362  itk::MeshIOBase::ArrayOfExtensionsType supportedReadExtensions = meshIO->GetSupportedReadExtensions();
363  std::cout << "SupportedReadExtensions: " << std::endl;
364  for (auto ext : supportedReadExtensions)
365  {
366  std::cout << ext << std::endl;
367  }
368 
369  itk::MeshIOBase::ArrayOfExtensionsType supportedWriteExtensions = meshIO->GetSupportedWriteExtensions();
370  std::cout << "SupportedWriteExtensions: " << std::endl;
371  for (auto ext : supportedWriteExtensions)
372  {
373  std::cout << ext << std::endl;
374  }
375 
376 
377  return EXIT_SUCCESS;
378 }
379 
380 namespace itk
381 {
382 namespace MeshIOTestHelper
383 {
384 
385 template <typename T>
386 std::shared_ptr<void>
387 MakeSharedArray(const std::size_t bufferSize)
388 {
389  return std::shared_ptr<void>(new T[bufferSize], std::default_delete<T[]>());
390 }
391 
392 inline std::shared_ptr<void>
393 AllocateBuffer(itk::IOComponentEnum componentType, itk::SizeValueType bufferSize)
394 {
395  switch (componentType)
396  {
397  case itk::IOComponentEnum::CHAR:
398  return MakeSharedArray<char>(bufferSize);
399  case itk::IOComponentEnum::UCHAR:
400  return MakeSharedArray<unsigned char>(bufferSize);
401  case itk::IOComponentEnum::USHORT:
402  return MakeSharedArray<unsigned short>(bufferSize);
403  case itk::IOComponentEnum::SHORT:
404  return MakeSharedArray<short>(bufferSize);
405  case itk::IOComponentEnum::UINT:
406  return MakeSharedArray<unsigned int>(bufferSize);
407  case itk::IOComponentEnum::INT:
408  return MakeSharedArray<int>(bufferSize);
409  case itk::IOComponentEnum::ULONG:
410  return MakeSharedArray<unsigned long>(bufferSize);
411  case itk::IOComponentEnum::LONG:
412  return MakeSharedArray<long>(bufferSize);
413  case itk::IOComponentEnum::LONGLONG:
414  return MakeSharedArray<long long>(bufferSize);
415  case itk::IOComponentEnum::ULONGLONG:
416  return MakeSharedArray<unsigned long long>(bufferSize);
417  case itk::IOComponentEnum::FLOAT:
418  return MakeSharedArray<float>(bufferSize);
419  case itk::IOComponentEnum::DOUBLE:
420  return MakeSharedArray<double>(bufferSize);
421  case itk::IOComponentEnum::LDOUBLE:
422  return MakeSharedArray<long double>(bufferSize);
423  case itk::IOComponentEnum::UNKNOWNCOMPONENTTYPE:
424  break;
425  default:
426  break;
427  }
428 
429  return nullptr;
430 }
431 
432 } // namespace MeshIOTestHelper
433 } // namespace itk
434 
435 #endif
itk::MeshIOBase::ArrayOfExtensionsType
std::vector< std::string > ArrayOfExtensionsType
Definition: itkMeshIOBase.h:84
itk::VariableLengthVector::Fill
void Fill(TValue const &v)
Pointer
SmartPointer< Self > Pointer
Definition: itkAddImageFilter.h:93
itk::CommonEnums::IOComponent::CHAR
itk::CommonEnums::IOPixel::RGBA
itk::RGBPixel
Represent Red, Green and Blue components for color images.
Definition: itkRGBPixel.h:58
itk::CommonEnums::IOFile
IOFile
Definition: itkCommonEnums.h:100
itk::CommonEnums::IOByteOrder::BigEndian
itkCovariantVector.h
itkRGBPixel.h
itk::CommonEnums::IOComponent::USHORT
itk::MeshIOBase::SizeValueType
IdentifierType SizeValueType
Definition: itkMeshIOBase.h:89
itk::CommonEnums::IOPixel::ARRAY
itkVariableSizeMatrix.h
itkMatrix.h
itk::CommonEnums::IOByteOrder
IOByteOrder
Definition: itkCommonEnums.h:127
itk::CommonEnums::IOComponent::SHORT
itk::CommonEnums::IOPixel::VECTOR
itk::CommonEnums::IOPixel::SCALAR
itkVariableLengthVector.h
itk::CommonEnums::IOComponent::ULONG
itk::CommonEnums::IOComponent::UINT
itkDiffusionTensor3D.h
itk::Vector
A templated class holding a n-Dimensional vector.
Definition: itkVector.h:62
itk::DiffusionTensor3D
Represent a diffusion tensor as used in DTI images.
Definition: itkDiffusionTensor3D.h:79
itkRGBAPixel.h
itk::CommonEnums::IOPixel::COVARIANTVECTOR
itk::CommonEnums::IOPixel::SYMMETRICSECONDRANKTENSOR
itk::CommonEnums::IOComponent
IOComponent
Definition: itkCommonEnums.h:76
itk::CommonEnums::IOComponent::UCHAR
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
IOPixel
Definition: itkCommonEnums.h:49
itk::CommonEnums::IOComponent::DOUBLE
itk::CommonEnums::IOComponent::LONGLONG
itk::SymmetricSecondRankTensor
Represent a symmetric tensor of second rank.
Definition: itkSymmetricSecondRankTensor.h:75
itk::CommonEnums::IOPixel::DIFFUSIONTENSOR3D
itk::CommonEnums::IOPixel::FIXEDARRAY
itk::CommonEnums::IOPixel::MATRIX
itk::CommonEnums::IOComponent::LONG
itkMacro.h
itk::CommonEnums::IOPixel::RGB
itkSymmetricSecondRankTensor.h
itkFixedArray.h
itk::CommonEnums::IOComponent::ULONGLONG
itk::MeshIOBase::MapComponentType
Definition: itkMeshIOBase.h:204
itk::CommonEnums::IOComponent::INT
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::Matrix
A templated class holding a M x N size Matrix.
Definition: itkMatrix.h:52
itk::Matrix::Fill
void Fill(const T &value)
Definition: itkMatrix.h:210
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:387
itk::CommonEnums::IOPixel::VARIABLESIZEMATRIX
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: itkAnnulusOperator.h:24
itkCommonEnums.h
itk::CommonEnums::IOPixel::COMPLEX
itk::MeshIOTestHelper::AllocateBuffer
std::shared_ptr< void > AllocateBuffer(itk::IOComponentEnum componentType, itk::SizeValueType bufferSize)
Definition: itkMeshIOTestHelper.h:393
itkVector.h
itk::CommonEnums::IOFile::ASCII
itk::Array
Array class with size defined at construction time.
Definition: itkArray.h:47
itk::VariableSizeMatrix::Fill
void Fill(const T &value)
Definition: itkVariableSizeMatrix.h:172
itk::CommonEnums::IOComponent::UNKNOWNCOMPONENTTYPE
itk::CommonEnums::IOComponent::FLOAT
itk::CommonEnums::IOPixel::VARIABLELENGTHVECTOR
itk::SizeValueType
unsigned long SizeValueType
Definition: itkIntTypes.h:83
itk::CommonEnums::IOComponent::LDOUBLE
itk::FixedArray::Fill
void Fill(const ValueType &)
itk::Array::Fill
void Fill(TValue const &v)
Definition: itkArray.h:114
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