ITK 6.0.0
Insight Toolkit
 
Loading...
Searching...
No Matches
itkMeshIOBase.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 itkMeshIOBase_h
19#define itkMeshIOBase_h
20#include "ITKIOMeshBaseExport.h"
21
22#include "itkByteSwapper.h"
23#include "itkCellInterface.h"
24#include "itkCovariantVector.h"
25#include "itkDiffusionTensor3D.h"
26#include "itkIntTypes.h"
27#include "itkLightProcessObject.h"
28#include "itkMatrix.h"
29#include "itkRGBPixel.h"
30#include "itkRGBAPixel.h"
31#include "itkSymmetricSecondRankTensor.h"
32#include "itkVariableLengthVector.h"
33#include "itkVariableSizeMatrix.h"
34#include "itkVector.h"
35#include "itkNumberToString.h"
36#include "itkCommonEnums.h"
37#include "itkMakeUniqueForOverwrite.h"
38
39#include <string>
40#include <type_traits> // For is_same_v.
41#include <complex>
42#include <fstream>
43
44namespace itk
45{
72
73class ITKIOMeshBase_EXPORT MeshIOBase : public LightProcessObject
74{
75public:
76 ITK_DISALLOW_COPY_AND_MOVE(MeshIOBase);
77
79 using Self = MeshIOBase;
80 using Superclass = LightProcessObject;
81 using ConstPointer = SmartPointer<const Self>;
82 using Pointer = SmartPointer<Self>;
83
85 using ArrayOfExtensionsType = std::vector<std::string>;
86
88 using StreamOffsetType = std::streamoff;
89
90 using SizeValueType = IdentifierType;
91
92#ifndef ITK_LEGACY_REMOVE
98 class [[deprecated("This class is intended to be removed from ITK 6.")]] UnknownType
99 {};
100#endif
101
103 itkOverrideGetNameOfClassMacro(MeshIOBase);
104
107 itkSetStringMacro(FileName);
108 itkGetStringMacro(FileName);
110#if !defined(ITK_LEGACY_REMOVE)
112 static constexpr IOPixelEnum UNKNOWNPIXELTYPE = IOPixelEnum::UNKNOWNPIXELTYPE;
113 static constexpr IOPixelEnum SCALAR = IOPixelEnum::SCALAR;
114 static constexpr IOPixelEnum RGB = IOPixelEnum::RGB;
115 static constexpr IOPixelEnum RGBA = IOPixelEnum::RGBA;
116 static constexpr IOPixelEnum OFFSET = IOPixelEnum::OFFSET;
117 static constexpr IOPixelEnum VECTOR = IOPixelEnum::VECTOR;
118 static constexpr IOPixelEnum POINT = IOPixelEnum::POINT;
119 static constexpr IOPixelEnum COVARIANTVECTOR = IOPixelEnum::COVARIANTVECTOR;
120 static constexpr IOPixelEnum SYMMETRICSECONDRANKTENSOR = IOPixelEnum::SYMMETRICSECONDRANKTENSOR;
121 static constexpr IOPixelEnum DIFFUSIONTENSOR3D = IOPixelEnum::DIFFUSIONTENSOR3D;
122 static constexpr IOPixelEnum COMPLEX = IOPixelEnum::COMPLEX;
123 static constexpr IOPixelEnum FIXEDARRAY = IOPixelEnum::FIXEDARRAY;
124 static constexpr IOPixelEnum ARRAY = IOPixelEnum::ARRAY;
125 static constexpr IOPixelEnum MATRIX = IOPixelEnum::MATRIX;
126 static constexpr IOPixelEnum VARIABLELENGTHVECTOR = IOPixelEnum::VARIABLELENGTHVECTOR;
127 static constexpr IOPixelEnum VARIABLESIZEMATRIX = IOPixelEnum::VARIABLESIZEMATRIX;
128#endif
129
130#if !defined(ITK_LEGACY_REMOVE)
132 static constexpr IOComponentEnum UNKNOWNCOMPONENTTYPE = IOComponentEnum::UNKNOWNCOMPONENTTYPE;
133 static constexpr IOComponentEnum UCHAR = IOComponentEnum::UCHAR;
134 static constexpr IOComponentEnum CHAR = IOComponentEnum::CHAR;
135 static constexpr IOComponentEnum USHORT = IOComponentEnum::USHORT;
136 static constexpr IOComponentEnum SHORT = IOComponentEnum::SHORT;
137 static constexpr IOComponentEnum UINT = IOComponentEnum::UINT;
138 static constexpr IOComponentEnum INT = IOComponentEnum::INT;
139 static constexpr IOComponentEnum ULONG = IOComponentEnum::ULONG;
140 static constexpr IOComponentEnum LONG = IOComponentEnum::LONG;
141 static constexpr IOComponentEnum ULONGLONG = IOComponentEnum::ULONGLONG;
142 static constexpr IOComponentEnum LONGLONG = IOComponentEnum::LONGLONG;
143 static constexpr IOComponentEnum FLOAT = IOComponentEnum::FLOAT;
144 static constexpr IOComponentEnum DOUBLE = IOComponentEnum::DOUBLE;
145 static constexpr IOComponentEnum LDOUBLE = IOComponentEnum::LDOUBLE;
146#endif
147
148#if !defined(ITK_LEGACY_REMOVE)
150 static constexpr IOFileEnum ASCII = IOFileEnum::ASCII;
151 static constexpr IOFileEnum BINARY = IOFileEnum::BINARY;
152 static constexpr IOFileEnum TYPENOTAPPLICABLE = IOFileEnum::TYPENOTAPPLICABLE;
153#endif
154
155#if !defined(ITK_LEGACY_REMOVE)
157 static constexpr IOByteOrderEnum BigEndian = IOByteOrderEnum::BigEndian;
158 static constexpr IOByteOrderEnum LittleEndian = IOByteOrderEnum::LittleEndian;
159 static constexpr IOByteOrderEnum OrderNotApplicable = IOByteOrderEnum::OrderNotApplicable;
160#endif
161
162#if !defined(ITK_LEGACY_REMOVE)
164 static constexpr IOFileModeEnum ReadMode = IOFileModeEnum::ReadMode;
165 static constexpr IOFileModeEnum WriteMode = IOFileModeEnum::WriteMode;
166#endif
167
168#if !defined(ITK_LEGACY_REMOVE)
170 static constexpr CellGeometryEnum VERTEX_CELL = CellGeometryEnum::VERTEX_CELL;
171 static constexpr CellGeometryEnum LINE_CELL = CellGeometryEnum::LINE_CELL;
172 static constexpr CellGeometryEnum TRIANGLE_CELL = CellGeometryEnum::TRIANGLE_CELL;
173 static constexpr CellGeometryEnum QUADRILATERAL_CELL = CellGeometryEnum::QUADRILATERAL_CELL;
174 static constexpr CellGeometryEnum POLYGON_CELL = CellGeometryEnum::POLYGON_CELL;
175 static constexpr CellGeometryEnum TETRAHEDRON_CELL = CellGeometryEnum::TETRAHEDRON_CELL;
176 static constexpr CellGeometryEnum HEXAHEDRON_CELL = CellGeometryEnum::HEXAHEDRON_CELL;
177 static constexpr CellGeometryEnum QUADRATIC_EDGE_CELL = CellGeometryEnum::QUADRATIC_EDGE_CELL;
178 static constexpr CellGeometryEnum QUADRATIC_TRIANGLE_CELL = CellGeometryEnum::QUADRATIC_TRIANGLE_CELL;
179 static constexpr CellGeometryEnum LAST_ITK_CELL = CellGeometryEnum::LAST_ITK_CELL;
180 static constexpr CellGeometryEnum MAX_ITK_CELLS = CellGeometryEnum::MAX_ITK_CELLS;
181#endif
182
189 itkSetEnumMacro(PointPixelType, itk::CommonEnums::IOPixel);
190 itkGetEnumMacro(PointPixelType, itk::CommonEnums::IOPixel);
191 itkSetEnumMacro(CellPixelType, itk::CommonEnums::IOPixel);
192 itkGetEnumMacro(CellPixelType, itk::CommonEnums::IOPixel);
197 itkSetEnumMacro(PointComponentType, itk::CommonEnums::IOComponent);
198 itkGetEnumMacro(PointComponentType, itk::CommonEnums::IOComponent);
199 itkSetEnumMacro(CellComponentType, itk::CommonEnums::IOComponent);
200 itkGetEnumMacro(CellComponentType, itk::CommonEnums::IOComponent);
201 itkSetEnumMacro(PointPixelComponentType, itk::CommonEnums::IOComponent);
202 itkGetEnumMacro(PointPixelComponentType, itk::CommonEnums::IOComponent);
203 itkSetEnumMacro(CellPixelComponentType, itk::CommonEnums::IOComponent);
204 itkGetEnumMacro(CellPixelComponentType, itk::CommonEnums::IOComponent);
206
207 template <typename TComponent>
208 struct MapComponentType
209 {
210 static constexpr IOComponentEnum CType =
211 std::is_same_v<TComponent, unsigned char> ? IOComponentEnum::UCHAR
212 : std::is_same_v<TComponent, char> ? IOComponentEnum::CHAR
213 : std::is_same_v<TComponent, short> ? IOComponentEnum::SHORT
214 : std::is_same_v<TComponent, unsigned short> ? IOComponentEnum::USHORT
215 : std::is_same_v<TComponent, int> ? IOComponentEnum::INT
216 : std::is_same_v<TComponent, unsigned int> ? IOComponentEnum::UINT
217 : std::is_same_v<TComponent, long> ? IOComponentEnum::LONG
218 : std::is_same_v<TComponent, unsigned long> ? IOComponentEnum::ULONG
219 : std::is_same_v<TComponent, long long> ? IOComponentEnum::LONGLONG
220 : std::is_same_v<TComponent, unsigned long long> ? IOComponentEnum::ULONGLONG
221 : std::is_same_v<TComponent, float> ? IOComponentEnum::FLOAT
222 : std::is_same_v<TComponent, double> ? IOComponentEnum::DOUBLE
223 : std::is_same_v<TComponent, long double> ? IOComponentEnum::LDOUBLE
224 : IOComponentEnum::UNKNOWNCOMPONENTTYPE;
225 };
226
227 template <typename T>
228 void
229 SetPixelType(const T & itkNotUsed(dummy), bool usePointPixel = true)
230 {
231 if (usePointPixel)
232 {
233 SetNumberOfPointPixelComponents(1);
234 SetPointPixelComponentType(MapComponentType<T>::CType);
235 SetPointPixelType(IOPixelEnum::SCALAR);
236 }
237 else
238 {
239 SetNumberOfCellPixelComponents(1);
240 SetCellPixelComponentType(MapComponentType<T>::CType);
241 SetCellPixelType(IOPixelEnum::SCALAR);
242 }
243 }
244
245 template <typename T>
246 void
247 SetPixelType(const RGBPixel<T> & itkNotUsed(dummy), bool usePointPixel = true)
248 {
249 if (usePointPixel)
250 {
251 SetNumberOfPointPixelComponents(3);
252 SetPointPixelComponentType(MapComponentType<T>::CType);
253 SetPointPixelType(IOPixelEnum::RGB);
254 }
255 else
256 {
257 SetNumberOfCellPixelComponents(3);
258 SetCellPixelComponentType(MapComponentType<T>::CType);
259 SetCellPixelType(IOPixelEnum::RGB);
260 }
261 }
262
263 template <typename T>
264 void
265 SetPixelType(const RGBAPixel<T> & itkNotUsed(dummy), bool usePointPixel = true)
266 {
267 if (usePointPixel)
268 {
269 SetNumberOfPointPixelComponents(4);
270 SetPointPixelComponentType(MapComponentType<T>::CType);
271 SetPointPixelType(IOPixelEnum::RGBA);
272 }
273 else
274 {
275 SetNumberOfCellPixelComponents(4);
276 SetCellPixelComponentType(MapComponentType<T>::CType);
277 SetCellPixelType(IOPixelEnum::RGBA);
278 }
279 }
280
281 template <typename T, unsigned int VLength>
282 void
283 SetPixelType(const Vector<T, VLength> & itkNotUsed(dummy), bool usePointPixel = true)
284 {
285 if (usePointPixel)
286 {
287 SetNumberOfPointPixelComponents(VLength);
288 SetPointPixelComponentType(MapComponentType<T>::CType);
289 SetPointPixelType(IOPixelEnum::VECTOR);
290 }
291 else
292 {
293 SetNumberOfCellPixelComponents(VLength);
294 SetCellPixelComponentType(MapComponentType<T>::CType);
295 SetCellPixelType(IOPixelEnum::VECTOR);
296 }
297 }
298
299 template <typename T, unsigned int VLength>
300 void
301 SetPixelType(const CovariantVector<T, VLength> & itkNotUsed(dummy), bool usePointPixel = true)
302 {
303 if (usePointPixel)
304 {
305 SetNumberOfPointPixelComponents(VLength);
306 SetPointPixelComponentType(MapComponentType<T>::CType);
307 SetPointPixelType(IOPixelEnum::COVARIANTVECTOR);
308 }
309 else
310 {
311 SetNumberOfCellPixelComponents(VLength);
312 SetCellPixelComponentType(MapComponentType<T>::CType);
313 SetCellPixelType(IOPixelEnum::COVARIANTVECTOR);
314 }
315 }
316
317 template <typename T, unsigned int VLength>
318 void
319 SetPixelType(const FixedArray<T, VLength> & itkNotUsed(dummy), bool usePointPixel = true)
320 {
321 if (usePointPixel)
322 {
323 SetNumberOfPointPixelComponents(VLength);
324 SetPointPixelComponentType(MapComponentType<T>::CType);
325 SetPointPixelType(IOPixelEnum::FIXEDARRAY);
326 }
327 else
328 {
329 SetNumberOfCellPixelComponents(VLength);
330 SetCellPixelComponentType(MapComponentType<T>::CType);
331 SetCellPixelType(IOPixelEnum::FIXEDARRAY);
332 }
333 }
334
335 template <typename T, unsigned int VLength>
336 void
337 SetPixelType(const SymmetricSecondRankTensor<T, VLength> itkNotUsed(dummy), bool usePointPixel = true)
338 {
339 if (usePointPixel)
340 {
341 SetNumberOfPointPixelComponents(VLength * (VLength + 1) / 2);
342 SetPointPixelComponentType(MapComponentType<T>::CType);
343 SetPointPixelType(IOPixelEnum::SYMMETRICSECONDRANKTENSOR);
344 }
345 else
346 {
347 SetNumberOfCellPixelComponents(VLength * (VLength + 1) / 2);
348 SetCellPixelComponentType(MapComponentType<T>::CType);
349 SetCellPixelType(IOPixelEnum::SYMMETRICSECONDRANKTENSOR);
350 }
351 }
352
353 template <typename T>
354 void
355 SetPixelType(const DiffusionTensor3D<T> & itkNotUsed(dummy), bool usePointPixel = true)
356 {
357 if (usePointPixel)
358 {
359 SetNumberOfPointPixelComponents(6);
360 SetPointPixelComponentType(MapComponentType<T>::CType);
361 SetPointPixelType(IOPixelEnum::DIFFUSIONTENSOR3D);
362 }
363 else
364 {
365 SetNumberOfCellPixelComponents(6);
366 SetCellPixelComponentType(MapComponentType<T>::CType);
367 SetCellPixelType(IOPixelEnum::DIFFUSIONTENSOR3D);
368 }
369 }
370
371 template <typename T, unsigned int VRows, unsigned int VColumns>
372 void
373 SetPixelType(const Matrix<T, VRows, VColumns> & itkNotUsed(dummy), bool usePointPixel = true)
374 {
375 if (usePointPixel)
376 {
377 SetNumberOfPointPixelComponents(VRows * VColumns);
378 SetPointPixelComponentType(MapComponentType<T>::CType);
379 SetPointPixelType(IOPixelEnum::MATRIX);
380 }
381 else
382 {
383 SetNumberOfCellPixelComponents(VRows * VColumns);
384 SetCellPixelComponentType(MapComponentType<T>::CType);
385 SetCellPixelType(IOPixelEnum::MATRIX);
386 }
387 }
388
389 template <typename T>
390 void
391 SetPixelType(const std::complex<T> & itkNotUsed(dummy), bool usePointPixel = true)
392 {
393 if (usePointPixel)
394 {
395 SetNumberOfPointPixelComponents(2);
396 SetPointPixelComponentType(MapComponentType<T>::CType);
397 SetPointPixelType(IOPixelEnum::COMPLEX);
398 }
399 else
400 {
401 SetNumberOfCellPixelComponents(2);
402 SetCellPixelComponentType(MapComponentType<T>::CType);
403 SetCellPixelType(IOPixelEnum::COMPLEX);
404 }
405 }
406
407 template <typename T>
408 void
409 SetPixelType(const Array<T> & array, bool usePointPixel = true)
410 {
411 if (usePointPixel)
412 {
413 SetNumberOfPointPixelComponents(array.Size());
414 SetPointPixelComponentType(MapComponentType<T>::CType);
415 SetPointPixelType(IOPixelEnum::ARRAY);
416 }
417 else
418 {
419 SetNumberOfCellPixelComponents(array.Size());
420 SetCellPixelComponentType(MapComponentType<T>::CType);
421 SetCellPixelType(IOPixelEnum::ARRAY);
422 }
423 }
424
425 template <typename T>
426 void
427 SetPixelType(const VariableLengthVector<T> & vector, bool usePointPixel = true)
428 {
429 if (usePointPixel)
430 {
431 SetNumberOfPointPixelComponents(vector.Size());
432 SetPointPixelComponentType(MapComponentType<T>::CType);
433 SetPointPixelType(IOPixelEnum::VARIABLELENGTHVECTOR);
434 }
435 else
436 {
437 SetNumberOfCellPixelComponents(vector.Size());
438 SetCellPixelComponentType(MapComponentType<T>::CType);
439 SetCellPixelType(IOPixelEnum::VARIABLELENGTHVECTOR);
440 }
441 }
442
443 template <typename T>
444 void
445 SetPixelType(const VariableSizeMatrix<T> & matrix, bool usePointPixel = true)
446 {
447 if (usePointPixel)
448 {
449 SetNumberOfPointPixelComponents(matrix.Rows() * matrix.Cols());
450 SetPointPixelComponentType(MapComponentType<T>::CType);
451 SetPointPixelType(IOPixelEnum::VARIABLESIZEMATRIX);
452 }
453 else
454 {
455 SetNumberOfCellPixelComponents(matrix.Rows() * matrix.Cols());
456 SetCellPixelComponentType(MapComponentType<T>::CType);
457 SetCellPixelType(IOPixelEnum::VARIABLESIZEMATRIX);
458 }
459 }
460
466 itkSetMacro(NumberOfPointPixelComponents, unsigned int);
467 itkGetConstMacro(NumberOfPointPixelComponents, unsigned int);
468 itkSetMacro(NumberOfCellPixelComponents, unsigned int);
469 itkGetConstMacro(NumberOfCellPixelComponents, unsigned int);
470 itkSetMacro(PointDimension, unsigned int);
471 itkGetConstMacro(PointDimension, unsigned int);
472 itkSetMacro(NumberOfPoints, SizeValueType);
473 itkGetConstMacro(NumberOfPoints, SizeValueType);
474 itkSetMacro(NumberOfCells, SizeValueType);
475 itkGetConstMacro(NumberOfCells, SizeValueType);
476 itkSetMacro(NumberOfPointPixels, SizeValueType);
477 itkGetConstMacro(NumberOfPointPixels, SizeValueType);
478 itkSetMacro(NumberOfCellPixels, SizeValueType);
479 itkGetConstMacro(NumberOfCellPixels, SizeValueType);
480 itkSetMacro(CellBufferSize, SizeValueType);
481 itkGetConstMacro(CellBufferSize, SizeValueType);
482 itkSetMacro(UpdatePoints, bool);
483 itkGetConstMacro(UpdatePoints, bool);
484 itkBooleanMacro(UpdatePoints);
485 itkSetMacro(UpdateCells, bool);
486 itkGetConstMacro(UpdateCells, bool);
487 itkBooleanMacro(UpdateCells);
488 itkSetMacro(UpdatePointData, bool);
489 itkGetConstMacro(UpdatePointData, bool);
490 itkBooleanMacro(UpdatePointData);
491 itkSetMacro(UpdateCellData, bool);
492 itkGetConstMacro(UpdateCellData, bool);
493 itkBooleanMacro(UpdateCellData);
495 unsigned int
496 GetComponentSize(IOComponentEnum componentType) const;
497
500 static std::string GetComponentTypeAsString(IOComponentEnum);
501
504 static std::string GetPixelTypeAsString(IOPixelEnum);
505
509 itkSetEnumMacro(FileType, IOFileEnum);
510 itkGetEnumMacro(FileType, IOFileEnum);
512 void
513 SetFileTypeToASCII()
514 {
515 this->SetFileType(IOFileEnum::ASCII);
516 }
517
518 void
519 SetFileTypeToBinary()
520 {
521 this->SetFileType(IOFileEnum::BINARY);
522 }
523
536 itkSetEnumMacro(ByteOrder, IOByteOrderEnum);
537 itkGetEnumMacro(ByteOrder, IOByteOrderEnum);
539 void
540 SetByteOrderToBigEndian()
541 {
542 this->SetByteOrder(IOByteOrderEnum::BigEndian);
543 }
544
545 void
546 SetByteOrderToLittleEndian()
547 {
548 this->SetByteOrder(IOByteOrderEnum::LittleEndian);
549 }
550
553 itkSetMacro(UseCompression, bool);
554 itkGetConstMacro(UseCompression, bool);
555 itkBooleanMacro(UseCompression);
559 std::string GetFileTypeAsString(IOFileEnum) const;
560
563 std::string GetByteOrderAsString(IOByteOrderEnum) const;
564
565 /*-------- This part of the interfaces deals with reading data ----- */
568 virtual bool
569 CanReadFile(const char *) = 0;
570
573 virtual void
574 ReadMeshInformation() = 0;
575
577 virtual void
578 ReadPoints(void * buffer) = 0;
579
580 virtual void
581 ReadCells(void * buffer) = 0;
582
583 virtual void
584 ReadPointData(void * buffer) = 0;
585
586 virtual void
587 ReadCellData(void * buffer) = 0;
588
589 /*-------- This part of the interfaces deals with writing data ----- */
590
593 virtual bool
594 CanWriteFile(const char *) = 0;
595
596 virtual void
597 WriteMeshInformation() = 0;
598
599 virtual void
600 WritePoints(void * buffer) = 0;
601
602 virtual void
603 WriteCells(void * buffer) = 0;
604
605 virtual void
606 WritePointData(void * buffer) = 0;
607
608 virtual void
609 WriteCellData(void * buffer) = 0;
610
611 virtual void
612 Write() = 0;
613
618 const ArrayOfExtensionsType &
619 GetSupportedReadExtensions() const;
620
625 const ArrayOfExtensionsType &
626 GetSupportedWriteExtensions() const;
627
628protected:
629 MeshIOBase();
630 ~MeshIOBase() override = default;
631
632 void
633 PrintSelf(std::ostream & os, Indent indent) const override;
634
636 void
637 AddSupportedReadExtension(const char * extension);
638
640 void
641 AddSupportedWriteExtension(const char * extension);
642
644 template <typename T>
645 void
646 ReadBufferAsAscii(T * buffer, std::ifstream & inputFile, SizeValueType numberOfComponents)
647 {
648 for (SizeValueType i = 0; i < numberOfComponents; ++i)
649 {
650 inputFile >> buffer[i];
651 }
652 }
653
655 template <typename T>
656 void
657 ReadBufferAsBinary(T * buffer, std::ifstream & inputFile, SizeValueType numberOfComponents)
658 {
659 inputFile.read(reinterpret_cast<char *>(buffer), numberOfComponents * sizeof(T));
660
661 if (m_ByteOrder == IOByteOrderEnum::BigEndian)
662 {
663 if constexpr (itk::ByteSwapper<T>::SystemIsLittleEndian())
664 {
665 itk::ByteSwapper<T>::SwapRangeFromSystemToBigEndian(buffer, numberOfComponents);
666 }
667 }
668 else if (m_ByteOrder == IOByteOrderEnum::LittleEndian)
669 {
670 if constexpr (itk::ByteSwapper<T>::SystemIsBigEndian())
671 {
672 itk::ByteSwapper<T>::SwapRangeFromSystemToLittleEndian(buffer, numberOfComponents);
673 }
674 }
675 }
676
678 template <typename T>
679 void
680 WriteBufferAsAscii(T * buffer,
681 std::ofstream & outputFile,
682 SizeValueType numberOfLines,
683 SizeValueType numberOfComponents)
684 {
685 for (SizeValueType ii = 0; ii < numberOfLines; ++ii)
686 {
687 for (SizeValueType jj = 0; jj < numberOfComponents; ++jj)
688 {
689 outputFile << ConvertNumberToString(buffer[ii * numberOfComponents + jj]) << " ";
690 }
691 outputFile << '\n';
692 }
693 }
694
696 template <typename TOutput, typename TInput>
697 void
698 WriteBufferAsBinary(TInput * buffer, std::ofstream & outputFile, SizeValueType numberOfComponents)
699 {
700 if (typeid(TInput) == typeid(TOutput))
701 {
702 if (m_ByteOrder == IOByteOrderEnum::BigEndian && itk::ByteSwapper<TInput>::SystemIsLittleEndian())
703 {
704 itk::ByteSwapper<TInput>::SwapRangeFromSystemToBigEndian(buffer, numberOfComponents);
705 }
706 else if (m_ByteOrder == IOByteOrderEnum::LittleEndian && itk::ByteSwapper<TInput>::SystemIsBigEndian())
707 {
708 itk::ByteSwapper<TInput>::SwapRangeFromSystemToLittleEndian(buffer, numberOfComponents);
709 }
710
711 outputFile.write(reinterpret_cast<char *>(buffer), numberOfComponents);
712 }
713 else
714 {
715 const auto data = make_unique_for_overwrite<TOutput[]>(numberOfComponents);
716 for (SizeValueType ii = 0; ii < numberOfComponents; ++ii)
717 {
718 data[ii] = static_cast<TOutput>(buffer[ii]);
719 }
720
721 if (m_ByteOrder == IOByteOrderEnum::BigEndian && itk::ByteSwapper<TOutput>::SystemIsLittleEndian())
722 {
723 itk::ByteSwapper<TOutput>::SwapRangeFromSystemToBigEndian(data.get(), numberOfComponents);
724 }
725 else if (m_ByteOrder == IOByteOrderEnum::LittleEndian && itk::ByteSwapper<TOutput>::SystemIsBigEndian())
726 {
727 itk::ByteSwapper<TOutput>::SwapRangeFromSystemToLittleEndian(data.get(), numberOfComponents);
728 }
729
730 outputFile.write(reinterpret_cast<char *>(data.get()), numberOfComponents);
731 }
732 }
733
737 template <typename TInput, typename TOutput>
738 void
739 ReadCellsBuffer(TInput * input, TOutput * output)
740 {
741 if (input && output)
742 {
743 SizeValueType inputIndex{};
744 SizeValueType outputIndex{};
745 for (SizeValueType ii = 0; ii < m_NumberOfCells; ++ii)
746 {
747 ++inputIndex; // ignore the cell type
748 auto numberOfPoints = static_cast<unsigned int>(input[inputIndex++]);
749 for (unsigned int jj = 0; jj < numberOfPoints; ++jj)
750 {
751 output[outputIndex++] = static_cast<TOutput>(input[inputIndex++]);
752 }
753 }
754 }
755 }
756
760 template <typename TInput, typename TOutput>
761 void
762 ReadCellsBuffer(TInput * input, TOutput * output, CellGeometryEnum type)
763 {
764 if (input && output)
765 {
766 SizeValueType inputIndex{};
767 SizeValueType outputIndex{};
768
769 for (SizeValueType ii = 0; ii < m_NumberOfCells; ++ii)
770 {
771 auto cellType = static_cast<CellGeometryEnum>(input[inputIndex++]);
772 auto nn = static_cast<unsigned int>(input[inputIndex++]);
773 if (cellType == type)
774 {
775 output[outputIndex++] = nn;
776 for (unsigned int jj = 0; jj < nn; ++jj)
777 {
778 output[outputIndex++] = static_cast<TOutput>(input[inputIndex++]);
779 }
780 }
781 else
782 {
783 inputIndex += nn;
784 }
785 }
786 }
787 }
788
791 template <typename TInput, typename TOutput>
792 void
793 WriteCellsBuffer(TInput * input,
794 TOutput * output,
795 CellGeometryEnum cellType,
796 unsigned int numberOfPoints,
797 SizeValueType numberOfCells)
798 {
799 if (input && output)
800 {
801 SizeValueType inputIndex{};
802 SizeValueType outputIndex{};
803 for (SizeValueType ii = 0; ii < numberOfCells; ++ii)
804 {
805 output[outputIndex++] = static_cast<TOutput>(cellType);
806 output[outputIndex++] = static_cast<TOutput>(numberOfPoints);
807 for (unsigned int jj = 0; jj < numberOfPoints; ++jj)
808 {
809 output[outputIndex++] = static_cast<TOutput>(input[inputIndex++]);
810 }
811 }
812 }
813 }
814
817 template <typename TInput, typename TOutput>
818 void
819 WriteCellsBuffer(TInput * input, TOutput * output, CellGeometryEnum cellType, SizeValueType numberOfCells)
820 {
821 if (input && output)
822 {
823 SizeValueType inputIndex{};
824 SizeValueType outputIndex{};
825 for (SizeValueType ii = 0; ii < numberOfCells; ++ii)
826 {
827 auto numberOfPoints = static_cast<unsigned int>(input[inputIndex++]);
828 if (numberOfPoints > 2 && cellType == CellGeometryEnum::LINE_CELL)
829 {
830 output[outputIndex++] = static_cast<TOutput>(CellGeometryEnum::POLYLINE_CELL);
831 }
832 else
833 {
834 output[outputIndex++] = static_cast<TOutput>(cellType);
835 }
836 output[outputIndex++] = static_cast<TOutput>(numberOfPoints);
837
838 for (unsigned int jj = 0; jj < numberOfPoints; ++jj)
839 {
840 output[outputIndex++] = static_cast<TOutput>(input[inputIndex++]);
841 }
842 }
843 }
844 }
845
846protected:
848 IOByteOrderEnum m_ByteOrder{ IOByteOrderEnum::OrderNotApplicable };
849 IOFileEnum m_FileType{ IOFileEnum::ASCII };
850
852 std::string m_FileName{};
853
855 bool m_UseCompression{ false };
856
858 IOComponentEnum m_PointComponentType{ IOComponentEnum::UNKNOWNCOMPONENTTYPE };
859 IOComponentEnum m_CellComponentType{ IOComponentEnum::UNKNOWNCOMPONENTTYPE };
860 IOComponentEnum m_PointPixelComponentType{ IOComponentEnum::UNKNOWNCOMPONENTTYPE };
861 IOComponentEnum m_CellPixelComponentType{ IOComponentEnum::UNKNOWNCOMPONENTTYPE };
862
864 IOPixelEnum m_PointPixelType{ IOPixelEnum::SCALAR };
865 IOPixelEnum m_CellPixelType{ IOPixelEnum::SCALAR };
866
869 unsigned int m_NumberOfPointPixelComponents{ 0 };
870 unsigned int m_NumberOfCellPixelComponents{ 0 };
871
873 unsigned int m_PointDimension{ 3 };
874
876 SizeValueType m_NumberOfPoints{};
877 SizeValueType m_NumberOfCells{};
878 SizeValueType m_NumberOfPointPixels{};
879 SizeValueType m_NumberOfCellPixels{};
880
882 SizeValueType m_CellBufferSize{};
883
886 bool m_UpdatePoints{ false };
887 bool m_UpdateCells{ false };
888 bool m_UpdatePointData{ false };
889 bool m_UpdateCellData{ false };
890
891private:
892 ArrayOfExtensionsType m_SupportedReadExtensions{};
893 ArrayOfExtensionsType m_SupportedWriteExtensions{};
894};
895} // end namespace itk
896
897#endif
itk::Array
Array class with size defined at construction time.
Definition itkArray.h:48
itk::Array::Size
SizeValueType Size() const
Definition itkArray.h:130
itk::ByteSwapper::SystemIsBigEndian
static constexpr bool SystemIsBigEndian()
Definition itkByteSwapper.h:74
itk::ByteSwapper::SwapRangeFromSystemToLittleEndian
static void SwapRangeFromSystemToLittleEndian(T *p, BufferSizeType num)
itk::ByteSwapper::SystemIsLittleEndian
static constexpr bool SystemIsLittleEndian()
Definition itkByteSwapper.h:85
itk::ByteSwapper::SwapRangeFromSystemToBigEndian
static void SwapRangeFromSystemToBigEndian(T *p, BufferSizeType num)
itk::CovariantVector
A templated class holding a n-Dimensional covariant vector.
Definition itkCovariantVector.h:69
itk::DiffusionTensor3D
Represent a diffusion tensor as used in DTI images.
Definition itkDiffusionTensor3D.h:77
itk::FixedArray
Simulate a standard C array with copy semantics.
Definition itkFixedArray.h:54
itk::Indent
Control indentation during Print() invocation.
Definition itkIndent.h:50
itk::Matrix
A templated class holding a M x N size Matrix.
Definition itkMatrix.h:53
itk::MeshIOBase::m_CellPixelType
IOPixelEnum m_CellPixelType
Definition itkMeshIOBase.h:865
itk::MeshIOBase::SetFileType
virtual void SetFileType(const IOFileEnum _arg)
itk::MeshIOBase::ReadCellsBuffer
void ReadCellsBuffer(TInput *input, TOutput *output, CellGeometryEnum type)
Definition itkMeshIOBase.h:762
itk::MeshIOBase::WriteBufferAsBinary
void WriteBufferAsBinary(TInput *buffer, std::ofstream &outputFile, SizeValueType numberOfComponents)
Definition itkMeshIOBase.h:698
itk::MeshIOBase::SetPixelType
void SetPixelType(const FixedArray< T, VLength > &dummy, bool usePointPixel=true)
Definition itkMeshIOBase.h:319
itk::MeshIOBase::m_NumberOfPointPixelComponents
unsigned int m_NumberOfPointPixelComponents
Definition itkMeshIOBase.h:869
itk::MeshIOBase::m_ByteOrder
IOByteOrderEnum m_ByteOrder
Definition itkMeshIOBase.h:848
itk::MeshIOBase::Pointer
SmartPointer< Self > Pointer
Definition itkMeshIOBase.h:82
itk::MeshIOBase::SetPointPixelComponentType
virtual void SetPointPixelComponentType(const itk::CommonEnums::IOComponent _arg)
itk::MeshIOBase::m_NumberOfPoints
SizeValueType m_NumberOfPoints
Definition itkMeshIOBase.h:876
itk::MeshIOBase::SetPixelType
void SetPixelType(const T &dummy, bool usePointPixel=true)
Definition itkMeshIOBase.h:229
itk::MeshIOBase::WriteBufferAsAscii
void WriteBufferAsAscii(T *buffer, std::ofstream &outputFile, SizeValueType numberOfLines, SizeValueType numberOfComponents)
Definition itkMeshIOBase.h:680
itk::MeshIOBase::Write
virtual void Write()=0
itk::MeshIOBase::m_FileType
IOFileEnum m_FileType
Definition itkMeshIOBase.h:849
itk::MeshIOBase::m_CellBufferSize
SizeValueType m_CellBufferSize
Definition itkMeshIOBase.h:882
itk::MeshIOBase::SetFileTypeToBinary
void SetFileTypeToBinary()
Definition itkMeshIOBase.h:519
itk::MeshIOBase::GetFileTypeAsString
std::string GetFileTypeAsString(IOFileEnum) const
itk::MeshIOBase::SizeValueType
IdentifierType SizeValueType
Definition itkMeshIOBase.h:90
itk::MeshIOBase::SetPixelType
void SetPixelType(const VariableSizeMatrix< T > &matrix, bool usePointPixel=true)
Definition itkMeshIOBase.h:445
itk::MeshIOBase::ReadPointData
virtual void ReadPointData(void *buffer)=0
itk::MeshIOBase::SetByteOrder
virtual void SetByteOrder(const IOByteOrderEnum _arg)
itk::MeshIOBase::WritePoints
virtual void WritePoints(void *buffer)=0
itk::MeshIOBase::GetComponentTypeAsString
static std::string GetComponentTypeAsString(IOComponentEnum)
itk::MeshIOBase::m_SupportedReadExtensions
ArrayOfExtensionsType m_SupportedReadExtensions
Definition itkMeshIOBase.h:892
itk::MeshIOBase::SetPixelType
void SetPixelType(const RGBPixel< T > &dummy, bool usePointPixel=true)
Definition itkMeshIOBase.h:247
itk::MeshIOBase::WriteCellsBuffer
void WriteCellsBuffer(TInput *input, TOutput *output, CellGeometryEnum cellType, unsigned int numberOfPoints, SizeValueType numberOfCells)
Definition itkMeshIOBase.h:793
itk::MeshIOBase::WriteMeshInformation
virtual void WriteMeshInformation()=0
itk::MeshIOBase::WriteCells
virtual void WriteCells(void *buffer)=0
itk::MeshIOBase::m_PointDimension
unsigned int m_PointDimension
Definition itkMeshIOBase.h:873
itk::MeshIOBase::GetComponentSize
unsigned int GetComponentSize(IOComponentEnum componentType) const
itk::MeshIOBase::AddSupportedReadExtension
void AddSupportedReadExtension(const char *extension)
itk::MeshIOBase::ReadMeshInformation
virtual void ReadMeshInformation()=0
itk::MeshIOBase::ReadCells
virtual void ReadCells(void *buffer)=0
itk::MeshIOBase::GetPixelTypeAsString
static std::string GetPixelTypeAsString(IOPixelEnum)
itk::MeshIOBase::m_FileName
std::string m_FileName
Definition itkMeshIOBase.h:852
itk::MeshIOBase::SetNumberOfCellPixelComponents
virtual void SetNumberOfCellPixelComponents(unsigned int _arg)
itk::MeshIOBase::m_PointPixelType
IOPixelEnum m_PointPixelType
Definition itkMeshIOBase.h:864
itk::MeshIOBase::SetPixelType
void SetPixelType(const Vector< T, VLength > &dummy, bool usePointPixel=true)
Definition itkMeshIOBase.h:283
itk::MeshIOBase::SetPixelType
void SetPixelType(const RGBAPixel< T > &dummy, bool usePointPixel=true)
Definition itkMeshIOBase.h:265
itk::MeshIOBase::CanReadFile
virtual bool CanReadFile(const char *)=0
itk::MeshIOBase::ReadBufferAsBinary
void ReadBufferAsBinary(T *buffer, std::ifstream &inputFile, SizeValueType numberOfComponents)
Definition itkMeshIOBase.h:657
itk::MeshIOBase::SetPixelType
void SetPixelType(const std::complex< T > &dummy, bool usePointPixel=true)
Definition itkMeshIOBase.h:391
itk::MeshIOBase::ConstPointer
SmartPointer< const Self > ConstPointer
Definition itkMeshIOBase.h:81
itk::MeshIOBase::GetSupportedReadExtensions
const ArrayOfExtensionsType & GetSupportedReadExtensions() const
itk::MeshIOBase::SetNumberOfPointPixelComponents
virtual void SetNumberOfPointPixelComponents(unsigned int _arg)
itk::MeshIOBase::WriteCellData
virtual void WriteCellData(void *buffer)=0
itk::MeshIOBase::SetPixelType
void SetPixelType(const VariableLengthVector< T > &vector, bool usePointPixel=true)
Definition itkMeshIOBase.h:427
itk::MeshIOBase::m_PointComponentType
IOComponentEnum m_PointComponentType
Definition itkMeshIOBase.h:858
itk::MeshIOBase::GetByteOrderAsString
std::string GetByteOrderAsString(IOByteOrderEnum) const
itk::MeshIOBase::m_CellPixelComponentType
IOComponentEnum m_CellPixelComponentType
Definition itkMeshIOBase.h:861
itk::MeshIOBase::ReadCellsBuffer
void ReadCellsBuffer(TInput *input, TOutput *output)
Definition itkMeshIOBase.h:739
itk::MeshIOBase::PrintSelf
void PrintSelf(std::ostream &os, Indent indent) const override
itk::MeshIOBase::SetPixelType
void SetPixelType(const DiffusionTensor3D< T > &dummy, bool usePointPixel=true)
Definition itkMeshIOBase.h:355
itk::MeshIOBase::GetSupportedWriteExtensions
const ArrayOfExtensionsType & GetSupportedWriteExtensions() const
itk::MeshIOBase::SetPixelType
void SetPixelType(const SymmetricSecondRankTensor< T, VLength > dummy, bool usePointPixel=true)
Definition itkMeshIOBase.h:337
itk::MeshIOBase::m_NumberOfPointPixels
SizeValueType m_NumberOfPointPixels
Definition itkMeshIOBase.h:878
itk::MeshIOBase::m_NumberOfCellPixels
SizeValueType m_NumberOfCellPixels
Definition itkMeshIOBase.h:879
itk::MeshIOBase::CanWriteFile
virtual bool CanWriteFile(const char *)=0
itk::MeshIOBase::SetByteOrderToBigEndian
void SetByteOrderToBigEndian()
Definition itkMeshIOBase.h:540
itk::MeshIOBase::m_PointPixelComponentType
IOComponentEnum m_PointPixelComponentType
Definition itkMeshIOBase.h:860
itk::MeshIOBase::StreamOffsetType
std::streamoff StreamOffsetType
Definition itkMeshIOBase.h:88
itk::MeshIOBase::SetCellPixelComponentType
virtual void SetCellPixelComponentType(const itk::CommonEnums::IOComponent _arg)
itk::MeshIOBase::SetPixelType
void SetPixelType(const Matrix< T, VRows, VColumns > &dummy, bool usePointPixel=true)
Definition itkMeshIOBase.h:373
itk::MeshIOBase::~MeshIOBase
~MeshIOBase() override=default
itk::MeshIOBase::SetByteOrderToLittleEndian
void SetByteOrderToLittleEndian()
Definition itkMeshIOBase.h:546
itk::MeshIOBase::SetFileTypeToASCII
void SetFileTypeToASCII()
Definition itkMeshIOBase.h:513
itk::MeshIOBase::WritePointData
virtual void WritePointData(void *buffer)=0
itk::MeshIOBase::SetCellPixelType
virtual void SetCellPixelType(const itk::CommonEnums::IOPixel _arg)
itk::MeshIOBase::ArrayOfExtensionsType
std::vector< std::string > ArrayOfExtensionsType
Definition itkMeshIOBase.h:85
itk::MeshIOBase::m_CellComponentType
IOComponentEnum m_CellComponentType
Definition itkMeshIOBase.h:859
itk::MeshIOBase::Superclass
LightProcessObject Superclass
Definition itkMeshIOBase.h:80
itk::MeshIOBase::Self
MeshIOBase Self
Definition itkMeshIOBase.h:79
itk::MeshIOBase::ReadCellData
virtual void ReadCellData(void *buffer)=0
itk::MeshIOBase::SetPixelType
void SetPixelType(const Array< T > &array, bool usePointPixel=true)
Definition itkMeshIOBase.h:409
itk::MeshIOBase::AddSupportedWriteExtension
void AddSupportedWriteExtension(const char *extension)
itk::MeshIOBase::m_SupportedWriteExtensions
ArrayOfExtensionsType m_SupportedWriteExtensions
Definition itkMeshIOBase.h:893
itk::MeshIOBase::ReadPoints
virtual void ReadPoints(void *buffer)=0
itk::MeshIOBase::ReadBufferAsAscii
void ReadBufferAsAscii(T *buffer, std::ifstream &inputFile, SizeValueType numberOfComponents)
Definition itkMeshIOBase.h:646
itk::MeshIOBase::SetPointPixelType
virtual void SetPointPixelType(const itk::CommonEnums::IOPixel _arg)
itk::MeshIOBase::m_NumberOfCellPixelComponents
unsigned int m_NumberOfCellPixelComponents
Definition itkMeshIOBase.h:870
itk::MeshIOBase::SetPixelType
void SetPixelType(const CovariantVector< T, VLength > &dummy, bool usePointPixel=true)
Definition itkMeshIOBase.h:301
itk::MeshIOBase::m_NumberOfCells
SizeValueType m_NumberOfCells
Definition itkMeshIOBase.h:877
itk::MeshIOBase::WriteCellsBuffer
void WriteCellsBuffer(TInput *input, TOutput *output, CellGeometryEnum cellType, SizeValueType numberOfCells)
Definition itkMeshIOBase.h:819
itk::RGBAPixel
Represent Red, Green, Blue and Alpha components for color images.
Definition itkRGBAPixel.h:60
itk::RGBPixel
Represent Red, Green and Blue components for color images.
Definition itkRGBPixel.h:59
itk::SmartPointer
Implements transparent reference counting.
Definition itkSmartPointer.h:52
itk::SymmetricSecondRankTensor
Represent a symmetric tensor of second rank.
Definition itkSymmetricSecondRankTensor.h:76
itk::VariableSizeMatrix
A templated class holding a M x N size Matrix.
Definition itkVariableSizeMatrix.h:46
itk::Vector
A templated class holding a n-Dimensional vector.
Definition itkVector.h:63
itk::CommonEnums::IOPixel
IOPixel
Definition itkCommonEnums.h:50
itk::CommonEnums::IOComponent
IOComponent
Definition itkCommonEnums.h:80
itk
The "itk" namespace contains all Insight Segmentation and Registration Toolkit (ITK) classes....
Definition itkAnatomicalOrientation.h:30
itk::IdentifierType
SizeValueType IdentifierType
Definition itkIntTypes.h:90
itk::IOComponentEnum
CommonEnums::IOComponent IOComponentEnum
Definition itkCommonEnums.h:169
itk::ConvertNumberToString
std::string ConvertNumberToString(const TValue val)
Definition itkNumberToString.h:83
itk::IOFileEnum
CommonEnums::IOFile IOFileEnum
Definition itkCommonEnums.h:170
itk::IOByteOrderEnum
CommonEnums::IOByteOrder IOByteOrderEnum
Definition itkCommonEnums.h:172
itk::CellGeometryEnum
CommonEnums::CellGeometry CellGeometryEnum
Definition itkCommonEnums.h:173
itk::IOPixelEnum
CommonEnums::IOPixel IOPixelEnum
Definition itkCommonEnums.h:168
itk::IOFileModeEnum
CommonEnums::IOFileMode IOFileModeEnum
Definition itkCommonEnums.h:171
itk::make_unique_for_overwrite
auto make_unique_for_overwrite(const vcl_size_t numberOfElements)
Definition itkMakeUniqueForOverwrite.h:60
itk::MeshIOBase::MapComponentType::CType
static constexpr IOComponentEnum CType
Definition itkMeshIOBase.h:210