ITK  5.3.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"
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  CLANG_PRAGMA_PUSH \
44  CLANG_SUPPRESS_Wfloat_equal if (variable != command) CLANG_PRAGMA_POP \
45  { \
46  std::cerr << "Error in " << #command << std::endl; \
47  std::cerr << " In " __FILE__ ", line " << __LINE__ << std::endl; \
48  std::cerr << "Expected " << variable << std::endl; \
49  std::cerr << "but got " << command << std::endl; \
50  return EXIT_FAILURE; \
51  } \
52  ITK_MACROEND_NOOP_STATEMENT
53 
54 
55 template <typename TMeshIO>
56 int
58 {
59  using FloatType = float;
60 
61  FloatType floatValue = 1.0;
62  bool usePointPixel = true;
63  meshIO->SetPixelType(floatValue, usePointPixel);
64  LOCAL_ITK_TEST_SET_GET_VALUE(1, meshIO->GetNumberOfPointPixelComponents());
66  meshIO->GetPointPixelComponentType());
67  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::SCALAR, meshIO->GetPointPixelType());
68 
69  usePointPixel = false;
70  meshIO->SetPixelType(floatValue, usePointPixel);
71  LOCAL_ITK_TEST_SET_GET_VALUE(1, meshIO->GetNumberOfCellPixelComponents());
73  meshIO->GetCellPixelComponentType());
74  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::SCALAR, meshIO->GetCellPixelType());
75 
76 
77  using RGBPixelType = itk::RGBPixel<FloatType>;
78 
79  RGBPixelType rgbValue{ 1.0 };
80  usePointPixel = true;
81  meshIO->SetPixelType(rgbValue, usePointPixel);
82  LOCAL_ITK_TEST_SET_GET_VALUE(3, meshIO->GetNumberOfPointPixelComponents());
84  meshIO->GetPointPixelComponentType());
85  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::RGB, meshIO->GetPointPixelType());
86 
87  usePointPixel = false;
88  meshIO->SetPixelType(rgbValue, usePointPixel);
89  LOCAL_ITK_TEST_SET_GET_VALUE(3, meshIO->GetNumberOfCellPixelComponents());
91  meshIO->GetCellPixelComponentType());
92  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::RGB, meshIO->GetCellPixelType());
93 
94 
95  using RGBAPixelType = itk::RGBAPixel<FloatType>;
96 
97  RGBAPixelType rgbaValue;
98  rgbaValue.Fill(1.0);
99  usePointPixel = true;
100  meshIO->SetPixelType(rgbaValue, usePointPixel);
101  LOCAL_ITK_TEST_SET_GET_VALUE(4, meshIO->GetNumberOfPointPixelComponents());
103  meshIO->GetPointPixelComponentType());
104  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::RGBA, meshIO->GetPointPixelType());
105 
106  usePointPixel = false;
107  meshIO->SetPixelType(rgbaValue, usePointPixel);
108  LOCAL_ITK_TEST_SET_GET_VALUE(4, meshIO->GetNumberOfCellPixelComponents());
110  meshIO->GetCellPixelComponentType());
111  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::RGBA, meshIO->GetCellPixelType());
112 
113 
114  const itk::SizeValueType length = 5;
115  using VectorPixelType = itk::Vector<FloatType, length>;
116 
117  VectorPixelType vectorValue;
118  vectorValue.Fill(1.0);
119  usePointPixel = true;
120  meshIO->SetPixelType(vectorValue, usePointPixel);
121  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfPointPixelComponents());
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());
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  CovariantVectorPixelType covariantVectorValue;
137  covariantVectorValue.Fill(1.0);
138  usePointPixel = true;
139  meshIO->SetPixelType(covariantVectorValue, usePointPixel);
140  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfPointPixelComponents());
142  meshIO->GetPointPixelComponentType());
144 
145  usePointPixel = false;
146  meshIO->SetPixelType(covariantVectorValue, usePointPixel);
147  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfCellPixelComponents());
149  meshIO->GetCellPixelComponentType());
151 
152 
153  using FixedArrayPixelType = itk::FixedArray<FloatType, length>;
154 
155  FixedArrayPixelType fixedArrayValue;
156  fixedArrayValue.Fill(1.0);
157  usePointPixel = true;
158  meshIO->SetPixelType(fixedArrayValue, usePointPixel);
159  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfPointPixelComponents());
161  meshIO->GetPointPixelComponentType());
162  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::FIXEDARRAY, meshIO->GetPointPixelType());
163 
164  usePointPixel = false;
165  meshIO->SetPixelType(fixedArrayValue, usePointPixel);
166  LOCAL_ITK_TEST_SET_GET_VALUE(length, meshIO->GetNumberOfCellPixelComponents());
168  meshIO->GetCellPixelComponentType());
169  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::FIXEDARRAY, meshIO->GetCellPixelType());
170 
171 
172  using SymmetricSecondRankTensorPixelType = itk::SymmetricSecondRankTensor<FloatType, length>;
173 
174  SymmetricSecondRankTensorPixelType symmetricSecondRankTensorValue;
175  symmetricSecondRankTensorValue.Fill(1.0);
176  usePointPixel = true;
177  meshIO->SetPixelType(symmetricSecondRankTensorValue, usePointPixel);
178  LOCAL_ITK_TEST_SET_GET_VALUE(length * (length + 1) / 2, meshIO->GetNumberOfPointPixelComponents());
180  meshIO->GetPointPixelComponentType());
182 
183  usePointPixel = false;
184  meshIO->SetPixelType(symmetricSecondRankTensorValue, usePointPixel);
185  LOCAL_ITK_TEST_SET_GET_VALUE(length * (length + 1) / 2, meshIO->GetNumberOfCellPixelComponents());
187  meshIO->GetCellPixelComponentType());
189 
190 
191  using DiffusionTensor3DPixelType = itk::DiffusionTensor3D<FloatType>;
192 
193  DiffusionTensor3DPixelType diffusionTensor3DPixelValue;
194  diffusionTensor3DPixelValue.Fill(1.0);
195  usePointPixel = true;
196  meshIO->SetPixelType(diffusionTensor3DPixelValue, usePointPixel);
197  LOCAL_ITK_TEST_SET_GET_VALUE(6, meshIO->GetNumberOfPointPixelComponents());
199  meshIO->GetPointPixelComponentType());
201 
202  usePointPixel = false;
203  meshIO->SetPixelType(diffusionTensor3DPixelValue, usePointPixel);
204  LOCAL_ITK_TEST_SET_GET_VALUE(6, meshIO->GetNumberOfCellPixelComponents());
206  meshIO->GetCellPixelComponentType());
208 
209 
210  const itk::SizeValueType rows = 2;
211  const itk::SizeValueType cols = 2;
212  using MatrixPixelType = itk::Matrix<FloatType, rows, cols>;
213 
214  MatrixPixelType matrixPixelValue;
215  matrixPixelValue.Fill(1.0);
216  usePointPixel = true;
217  meshIO->SetPixelType(matrixPixelValue, usePointPixel);
218  LOCAL_ITK_TEST_SET_GET_VALUE(rows * cols, meshIO->GetNumberOfPointPixelComponents());
220  meshIO->GetPointPixelComponentType());
221  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::MATRIX, meshIO->GetPointPixelType());
222 
223  usePointPixel = false;
224  meshIO->SetPixelType(matrixPixelValue, usePointPixel);
225  LOCAL_ITK_TEST_SET_GET_VALUE(rows * cols, meshIO->GetNumberOfCellPixelComponents());
227  meshIO->GetCellPixelComponentType());
228  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::MATRIX, meshIO->GetCellPixelType());
229 
230 
231  using ComplexPixelType = std::complex<FloatType>;
232 
233  ComplexPixelType complexPixelValue(1.0, 1.0);
234  usePointPixel = true;
235  meshIO->SetPixelType(complexPixelValue, usePointPixel);
236  LOCAL_ITK_TEST_SET_GET_VALUE(2, meshIO->GetNumberOfPointPixelComponents());
238  meshIO->GetPointPixelComponentType());
239  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::COMPLEX, meshIO->GetPointPixelType());
240 
241  usePointPixel = false;
242  meshIO->SetPixelType(complexPixelValue, usePointPixel);
243  LOCAL_ITK_TEST_SET_GET_VALUE(2, meshIO->GetNumberOfCellPixelComponents());
245  meshIO->GetCellPixelComponentType());
246  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::COMPLEX, meshIO->GetCellPixelType());
247 
248 
249  using ArrayPixelType = itk::Array<FloatType>;
250 
251  ArrayPixelType arrayPixelValue;
252  arrayPixelValue.Fill(1.0);
253  usePointPixel = true;
254  meshIO->SetPixelType(arrayPixelValue, usePointPixel);
255  LOCAL_ITK_TEST_SET_GET_VALUE(arrayPixelValue.Size(), meshIO->GetNumberOfPointPixelComponents());
257  meshIO->GetPointPixelComponentType());
258  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::ARRAY, meshIO->GetPointPixelType());
259 
260  usePointPixel = false;
261  meshIO->SetPixelType(arrayPixelValue, usePointPixel);
262  LOCAL_ITK_TEST_SET_GET_VALUE(arrayPixelValue.Size(), meshIO->GetNumberOfCellPixelComponents());
264  meshIO->GetCellPixelComponentType());
265  LOCAL_ITK_TEST_SET_GET_VALUE(itk::IOPixelEnum::ARRAY, meshIO->GetCellPixelType());
266 
267 
268  using VariableLengthVectorPixelType = itk::VariableLengthVector<FloatType>;
269 
270  VariableLengthVectorPixelType variableLengthVectorValue;
271  variableLengthVectorValue.Fill(1.0);
272  usePointPixel = true;
273  meshIO->SetPixelType(variableLengthVectorValue, usePointPixel);
274  LOCAL_ITK_TEST_SET_GET_VALUE(variableLengthVectorValue.Size(), meshIO->GetNumberOfPointPixelComponents());
276  meshIO->GetPointPixelComponentType());
278 
279  usePointPixel = false;
280  meshIO->SetPixelType(variableLengthVectorValue, usePointPixel);
281  LOCAL_ITK_TEST_SET_GET_VALUE(variableLengthVectorValue.Size(), meshIO->GetNumberOfCellPixelComponents());
283  meshIO->GetCellPixelComponentType());
285 
286 
287  using VariableSizeMatrixType = itk::VariableSizeMatrix<FloatType>;
288 
289  VariableSizeMatrixType matrix;
290  matrix.Fill(1.0);
291  usePointPixel = true;
292  meshIO->SetPixelType(matrix, usePointPixel);
293  LOCAL_ITK_TEST_SET_GET_VALUE(matrix.Rows() * matrix.Cols(), meshIO->GetNumberOfPointPixelComponents());
295  meshIO->GetPointPixelComponentType());
297 
298  usePointPixel = false;
299  meshIO->SetPixelType(matrix, usePointPixel);
300  LOCAL_ITK_TEST_SET_GET_VALUE(matrix.Rows() * matrix.Cols(), meshIO->GetNumberOfCellPixelComponents());
302  meshIO->GetCellPixelComponentType());
304 
305 
306  // ToDo see how the above change the below
307  // Do this only for the last pixel type
309  std::cout << "ComponentSize: " << meshIO->GetComponentSize(floatComponent) << std::endl;
310 
311  std::cout << "ComponentTypeAsString: " << meshIO->GetComponentTypeAsString(floatComponent) << std::endl;
312 
314  std::cout << "PixelTypeAsString: " << meshIO->GetPixelTypeAsString(pixelType) << std::endl;
315 
317  meshIO->SetPointComponentType(pointComponentType);
318  LOCAL_ITK_TEST_SET_GET_VALUE(pointComponentType, meshIO->GetPointComponentType());
319 
321  meshIO->SetCellComponentType(cellComponentType);
322  LOCAL_ITK_TEST_SET_GET_VALUE(cellComponentType, meshIO->GetCellComponentType());
323 
324  unsigned int pointDimension = 2;
325  meshIO->SetPointDimension(pointDimension);
326  LOCAL_ITK_TEST_SET_GET_VALUE(pointDimension, meshIO->GetPointDimension());
327 
328  itk::MeshIOBase::SizeValueType numberOfPoints = 400;
329  meshIO->SetNumberOfPoints(numberOfPoints);
330  LOCAL_ITK_TEST_SET_GET_VALUE(numberOfPoints, meshIO->GetNumberOfPoints());
331 
332  itk::MeshIOBase::SizeValueType numberOfCells = 100;
333  meshIO->SetNumberOfCells(numberOfCells);
334  LOCAL_ITK_TEST_SET_GET_VALUE(numberOfCells, meshIO->GetNumberOfCells());
335 
336  itk::MeshIOBase::SizeValueType numberOfPointPixels = 200;
337  meshIO->SetNumberOfPointPixels(numberOfPointPixels);
338  LOCAL_ITK_TEST_SET_GET_VALUE(numberOfPointPixels, meshIO->GetNumberOfPointPixels());
339 
340  itk::MeshIOBase::SizeValueType numberOfCellPixels = 600;
341  meshIO->SetNumberOfCellPixels(numberOfCellPixels);
342  LOCAL_ITK_TEST_SET_GET_VALUE(numberOfCellPixels, meshIO->GetNumberOfCellPixels());
343 
344  itk::MeshIOBase::SizeValueType cellBufferSize = 1000;
345  meshIO->SetCellBufferSize(cellBufferSize);
346  LOCAL_ITK_TEST_SET_GET_VALUE(cellBufferSize, meshIO->GetCellBufferSize());
347 
349  meshIO->SetFileType(fileType);
350  LOCAL_ITK_TEST_SET_GET_VALUE(fileType, meshIO->GetFileType());
351 
352  std::cout << "FileTypeAsString: " << meshIO->GetFileTypeAsString(fileType) << std::endl;
353 
355  meshIO->SetByteOrder(ioByteOrder);
356  LOCAL_ITK_TEST_SET_GET_VALUE(ioByteOrder, meshIO->GetByteOrder());
357 
358  std::cout << "ByteOrderAsString: " << meshIO->GetByteOrderAsString(ioByteOrder) << std::endl;
359 
360  itk::MeshIOBase::ArrayOfExtensionsType supportedReadExtensions = meshIO->GetSupportedReadExtensions();
361  std::cout << "SupportedReadExtensions: " << std::endl;
362  for (auto ext : supportedReadExtensions)
363  {
364  std::cout << ext << std::endl;
365  }
366 
367  itk::MeshIOBase::ArrayOfExtensionsType supportedWriteExtensions = meshIO->GetSupportedWriteExtensions();
368  std::cout << "SupportedWriteExtensions: " << std::endl;
369  for (auto ext : supportedWriteExtensions)
370  {
371  std::cout << ext << std::endl;
372  }
373 
374 
375  return EXIT_SUCCESS;
376 }
377 
378 namespace itk
379 {
380 namespace MeshIOTestHelper
381 {
382 
383 template <typename T>
384 std::shared_ptr<void>
385 MakeSharedArray(const std::size_t bufferSize)
386 {
387  return std::shared_ptr<void>(new T[bufferSize], std::default_delete<T[]>());
388 }
389 
390 inline std::shared_ptr<void>
392 {
393  switch (componentType)
394  {
396  return MakeSharedArray<char>(bufferSize);
398  return MakeSharedArray<unsigned char>(bufferSize);
400  return MakeSharedArray<unsigned short>(bufferSize);
402  return MakeSharedArray<short>(bufferSize);
404  return MakeSharedArray<unsigned int>(bufferSize);
406  return MakeSharedArray<int>(bufferSize);
408  return MakeSharedArray<unsigned long>(bufferSize);
410  return MakeSharedArray<long>(bufferSize);
412  return MakeSharedArray<long long>(bufferSize);
414  return MakeSharedArray<unsigned long long>(bufferSize);
416  return MakeSharedArray<float>(bufferSize);
418  return MakeSharedArray<double>(bufferSize);
420  return MakeSharedArray<long double>(bufferSize);
422  break;
423  default:
424  break;
425  }
426 
427  return nullptr;
428 }
429 
430 } // namespace MeshIOTestHelper
431 } // namespace itk
432 
433 #endif
itk::MeshIOBase::ArrayOfExtensionsType
std::vector< std::string > ArrayOfExtensionsType
Definition: itkMeshIOBase.h:83
itk::VariableLengthVector::Fill
void Fill(TValue const &v)
Pointer
SmartPointer< Self > Pointer
Definition: itkAddImageFilter.h:92
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:88
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:57
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:203
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:385
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:391
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