ITK  5.1.0
Insight Toolkit
itkImageIOBase.h
Go to the documentation of this file.
1 /*=========================================================================
2  *
3  * Copyright Insight Software Consortium
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  * http://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 itkImageIOBase_h
19 #define itkImageIOBase_h
20 #include "ITKIOImageBaseExport.h"
21 
22 #include "itkIOConfigure.h"
23 
24 #include "itkLightProcessObject.h"
25 #include "itkIndent.h"
26 #include "itkImageIORegion.h"
27 #include "itkRGBPixel.h"
28 #include "itkRGBAPixel.h"
29 #include "itkCovariantVector.h"
31 #include "itkDiffusionTensor3D.h"
33 
34 #include "vnl/vnl_vector.h"
35 #include "vcl_compiler.h"
36 
37 #include <fstream>
38 #include <string>
39 
40 namespace itk
41 {
42 // Forward reference for VariableLengthVector
43 template <typename TValue>
44 class VariableLengthVector;
45 
74 class ITKIOImageBase_EXPORT ImageIOBase : public LightProcessObject
75 {
76 public:
77  ITK_DISALLOW_COPY_AND_ASSIGN(ImageIOBase);
78 
80  using Self = ImageIOBase;
84 
86  itkTypeMacro(ImageIOBase, Superclass);
87 
89  itkSetStringMacro(FileName);
90  itkGetStringMacro(FileName);
92 
96 
103  {};
104 
108  typedef enum
109  {
122  MATRIX
123  } IOPixelType;
124 
129  // NOTE unsigned char, char, and signed char are 3 distinct types in C++
130  // the enum value UCHAR represents 'unsigned char'
131  // the enum value CHAR represents 'signed char'
132  // and the 'char' type maps to one of UCHAR or CHAR based on the platforms 'signededness'
133  typedef enum
134  {
147  DOUBLE
148  } IOComponentType;
149 
153  void
154  SetNumberOfDimensions(unsigned int);
155 
156  itkGetConstMacro(NumberOfDimensions, unsigned int);
157 
161  virtual void
162  SetDimensions(unsigned int i, SizeValueType dim);
164 
165  virtual SizeValueType
166  GetDimensions(unsigned int i) const
167  {
168  return m_Dimensions[i];
169  }
170 
173  virtual void
174  SetOrigin(unsigned int i, double origin);
175 
176  virtual double
177  GetOrigin(unsigned int i) const
178  {
179  return m_Origin[i];
180  }
181 
184  virtual void
185  SetSpacing(unsigned int i, double spacing);
186 
187  virtual double
188  GetSpacing(unsigned int i) const
189  {
190  return m_Spacing[i];
191  }
192 
195  virtual void
196  SetDirection(unsigned int i, const std::vector<double> & direction);
197 
198  virtual void
199  SetDirection(unsigned int i, const vnl_vector<double> & direction);
200 
201  virtual std::vector<double>
202  GetDirection(unsigned int i) const
203  {
204  return m_Direction[i];
205  }
206 
209  virtual std::vector<double>
210  GetDefaultDirection(unsigned int i) const;
211 
218  itkSetMacro(IORegion, ImageIORegion);
219  itkGetConstReferenceMacro(IORegion, ImageIORegion);
221 
227  itkSetEnumMacro(PixelType, IOPixelType);
228  itkGetEnumMacro(PixelType, IOPixelType);
230 
233  itkSetEnumMacro(ComponentType, IOComponentType);
234  itkGetEnumMacro(ComponentType, IOComponentType);
235 
241  virtual const std::type_info &
242  GetComponentTypeInfo() const;
243 
248  itkSetMacro(NumberOfComponents, unsigned int);
249  itkGetConstReferenceMacro(NumberOfComponents, unsigned int);
251 
253  itkSetMacro(UseCompression, bool);
254  itkGetConstMacro(UseCompression, bool);
255  itkBooleanMacro(UseCompression);
257 
264  itkSetClampMacro(CompressionLevel, int, 1, this->GetMaximumCompressionLevel());
265  itkGetConstMacro(CompressionLevel, int);
266 
277  virtual void
278  SetCompressor(std::string _c);
279  itkGetConstReferenceMacro(Compressor, std::string);
280 
282  itkSetMacro(UseStreamedReading, bool);
283  itkGetConstMacro(UseStreamedReading, bool);
284  itkBooleanMacro(UseStreamedReading);
286 
288  itkSetMacro(UseStreamedWriting, bool);
289  itkGetConstMacro(UseStreamedWriting, bool);
290  itkBooleanMacro(UseStreamedWriting);
292 
297  itkSetMacro(ExpandRGBPalette, bool);
298  itkGetConstMacro(ExpandRGBPalette, bool);
299  itkBooleanMacro(ExpandRGBPalette);
301 
304  itkSetMacro(WritePalette, bool);
305  itkGetConstMacro(WritePalette, bool);
306  itkBooleanMacro(WritePalette);
308 
313  itkGetConstMacro(IsReadAsScalarPlusPalette, bool);
314 
317  static std::string GetComponentTypeAsString(IOComponentType);
318 
320  static IOComponentType
321  GetComponentTypeFromString(const std::string & typeString);
322 
325  static std::string GetPixelTypeAsString(IOPixelType);
326 
328  static IOPixelType
329  GetPixelTypeFromString(const std::string & pixelString);
330 
334  {
337  TypeNotApplicable
338  };
339 
343  {
346  OrderNotApplicable
347  };
348 
351  itkSetEnumMacro(FileType, FileType);
352  itkGetEnumMacro(FileType, FileType);
353  void
355  {
356  this->SetFileType(ASCII);
357  }
359 
360  void
362  {
363  this->SetFileType(Binary);
364  }
365 
377  itkSetEnumMacro(ByteOrder, ByteOrder);
378  itkGetEnumMacro(ByteOrder, ByteOrder);
379  void
381  {
382  this->SetByteOrder(BigEndian);
383  }
385 
386  void
388  {
389  this->SetByteOrder(LittleEndian);
390  }
391 
394  std::string GetFileTypeAsString(FileType) const;
395 
398  std::string GetByteOrderAsString(ByteOrder) const;
399 
402 
406 
413  virtual SizeType
414  GetPixelStride() const;
415 
417  SizeType
418  GetImageSizeInPixels() const;
419 
421  SizeType
422  GetImageSizeInBytes() const;
423 
426  SizeType
427  GetImageSizeInComponents() const;
428 
433  virtual unsigned int
434  GetComponentSize() const;
435 
436  /*-------- This part of the interfaces deals with reading data ----- */
437 
440  virtual bool
441  CanReadFile(const char *) = 0;
442 
447  virtual bool
449  {
450  return false;
451  }
452 
455  virtual void
456  ReadImageInformation() = 0;
457 
459  virtual void
460  Read(void * buffer) = 0;
461 
462  /*-------- This part of the interfaces deals with writing data ----- */
463 
466  virtual bool
467  CanWriteFile(const char *) = 0;
468 
475  virtual bool
477  {
478  return false;
479  }
480 
483  virtual void
484  WriteImageInformation() = 0;
485 
489  virtual void
490  Write(const void * buffer) = 0;
491 
492  /* --- Support reading and writing data as a series of files. --- */
493 
499  virtual bool
500  SupportsDimension(unsigned long dim)
501  {
502  return (dim == 2);
503  }
504 
516  virtual ImageIORegion
517  GenerateStreamableReadRegionFromRequestedRegion(const ImageIORegion & requested) const;
518 
533  virtual unsigned int
534  GetActualNumberOfSplitsForWriting(unsigned int numberOfRequestedSplits,
535  const ImageIORegion & pasteRegion,
536  const ImageIORegion & largestPossibleRegion);
537 
544  virtual ImageIORegion
545  GetSplitRegionForWriting(unsigned int ithPiece,
546  unsigned int numberOfActualSplits,
547  const ImageIORegion & pasteRegion,
548  const ImageIORegion & largestPossibleRegion);
549 
551  using ArrayOfExtensionsType = std::vector<std::string>;
552 
557  const ArrayOfExtensionsType &
558  GetSupportedReadExtensions() const;
559 
564  const ArrayOfExtensionsType &
565  GetSupportedWriteExtensions() const;
566 
567  template <typename TPixel>
568  void
569  SetTypeInfo(const TPixel *);
570 
572  template <typename TPixel>
574  {
575  static constexpr IOComponentType CType = UNKNOWNCOMPONENTTYPE;
576  };
577  template <typename TPixel>
578  void
579  SetPixelTypeInfo(const TPixel *)
580  {
581  this->SetNumberOfComponents(1);
582  this->SetPixelType(SCALAR);
583  this->SetComponentType(MapPixelType<TPixel>::CType);
584  }
585  template <typename TPixel>
586  void
588  {
589  this->SetNumberOfComponents(3);
590  this->SetPixelType(RGB);
591  this->SetComponentType(MapPixelType<TPixel>::CType);
592  }
593  template <typename TPixel>
594  void
596  {
597  this->SetNumberOfComponents(4);
598  this->SetPixelType(RGBA);
599  this->SetComponentType(MapPixelType<TPixel>::CType);
600  }
601  template <typename TPixel, unsigned VLength>
602  void
604  {
605  this->SetNumberOfComponents(VLength);
606  this->SetPixelType(VECTOR);
607  this->SetComponentType(MapPixelType<TPixel>::CType);
608  }
609  template <typename TPixel>
610  void
612  {
613  this->SetNumberOfComponents(1);
614  this->SetPixelType(VECTOR);
615  this->SetComponentType(MapPixelType<TPixel>::CType);
616  }
617  template <typename TPixel, unsigned VLength>
618  void
620  {
621  this->SetNumberOfComponents(VLength);
622  this->SetPixelType(COVARIANTVECTOR);
623  this->SetComponentType(MapPixelType<TPixel>::CType);
624  }
625  template <typename TPixel, unsigned VLength>
626  void
628  {
629  this->SetNumberOfComponents(VLength);
630  this->SetPixelType(COVARIANTVECTOR);
631  this->SetComponentType(MapPixelType<TPixel>::CType);
632  }
634 
635  template <typename TPixel, unsigned VLength>
636  void
638  {
639  this->SetNumberOfComponents(VLength * (VLength + 1) / 2);
640  this->SetPixelType(SYMMETRICSECONDRANKTENSOR);
641  this->SetComponentType(MapPixelType<TPixel>::CType);
642  }
643 
644  template <typename TPixel>
645  inline void
647  {
648  this->SetNumberOfComponents(6);
649  this->SetPixelType(DIFFUSIONTENSOR3D);
650  this->SetComponentType(MapPixelType<TPixel>::CType);
651  }
652 
653  template <typename TPixel, unsigned VLength>
654  void
656  {
657  this->SetNumberOfComponents(VLength * VLength);
658  this->SetPixelType(MATRIX);
659  this->SetComponentType(MapPixelType<TPixel>::CType);
660  }
661 
662  template <typename TPixel>
663  void
664  SetPixelTypeInfo(const std::complex<TPixel> *)
665  {
666  this->SetNumberOfComponents(2);
667  this->SetPixelType(COMPLEX);
668  this->SetComponentType(MapPixelType<TPixel>::CType);
669  }
670 
671  template <unsigned VLength>
672  void
674  {
675  this->SetNumberOfComponents(VLength);
676  this->SetPixelType(ImageIOBase::OFFSET);
677  this->SetComponentType(ImageIOBase::LONG);
678  }
679 
680 protected:
681  ImageIOBase();
682  ~ImageIOBase() override;
683  void
684  PrintSelf(std::ostream & os, Indent indent) const override;
685 
686  virtual const ImageRegionSplitterBase *
687  GetImageRegionSplitter() const;
688 
693  virtual bool
694  HasSupportedReadExtension(const char * fileName, bool ignoreCase = true);
695  virtual bool
696  HasSupportedWriteExtension(const char * fileName, bool ignoreCase = true);
698 
700  IOPixelType m_PixelType{ SCALAR };
701 
704  IOComponentType m_ComponentType{ UNKNOWNCOMPONENTTYPE };
705 
707  ByteOrder m_ByteOrder{ OrderNotApplicable };
708 
709  FileType m_FileType{ TypeNotApplicable };
710 
713 
715  std::string m_FileName;
716 
719  unsigned int m_NumberOfComponents;
720 
722  unsigned int m_NumberOfDimensions{ 0 };
723 
725  bool m_UseCompression{ false };
726 
727 
728  int m_CompressionLevel{ 30 };
729  int m_MaximumCompressionLevel{ 100 };
730  std::string m_Compressor{ "uninitialized" };
731 
733  virtual void
734  SetMaximumCompressionLevel(int);
735  itkGetConstMacro(MaximumCompressionLevel, int);
737 
741  virtual void
742  InternalSetCompressor(const std::string & COMPRESSOR);
743 
746 
749 
752 
756 
759 
763 
765  std::vector<SizeValueType> m_Dimensions;
766 
769  std::vector<double> m_Spacing;
770 
772  std::vector<double> m_Origin;
773 
775  std::vector<std::vector<double>> m_Direction;
776 
779  std::vector<SizeType> m_Strides;
780 
782  virtual void
783  Reset(const bool freeDynamic = true);
784 
786  void
787  Resize(const unsigned int numDimensions, const unsigned int * dimensions);
788 
791  virtual unsigned int
792  GetPixelSize() const;
793 
800  void
801  ComputeStrides();
802 
805  SizeType
806  GetComponentStride() const;
807 
810  SizeType
811  GetRowStride() const;
812 
815  SizeType
816  GetSliceStride() const;
817 
829  virtual void
830  OpenFileForReading(std::ifstream & inputStream, const std::string & filename, bool ascii = false);
831 
847  virtual void
848  OpenFileForWriting(std::ofstream & outputStream,
849  const std::string & filename,
850  bool truncate = true,
851  bool ascii = false);
852 
854  virtual void
855  WriteBufferAsASCII(std::ostream & os, const void * buffer, IOComponentType ctype, SizeType numberOfBytesToWrite);
856 
858  virtual void
859  ReadBufferAsASCII(std::istream & os, void * buffer, IOComponentType ctype, SizeType numberOfBytesToBeRead);
860 
862  bool
863  ReadBufferAsBinary(std::istream & os, void * buffer, SizeType numberOfBytesToBeRead);
864 
866  void
867  AddSupportedReadExtension(const char * extension);
868 
870  void
871  AddSupportedWriteExtension(const char * extension);
872 
873 
874  void
875  SetSupportedReadExtensions(const ArrayOfExtensionsType &);
876  void
877  SetSupportedWriteExtensions(const ArrayOfExtensionsType &);
878 
881  virtual unsigned int
882  GetActualNumberOfSplitsForWritingCanStreamWrite(unsigned int numberOfRequestedSplits,
883  const ImageIORegion & pasteRegion) const;
884 
887  virtual ImageIORegion
888  GetSplitRegionForWritingCanStreamWrite(unsigned int ithPiece,
889  unsigned int numberOfActualSplits,
890  const ImageIORegion & pasteRegion) const;
891 
892 private:
893  bool
894  HasSupportedExtension(const char *, const ArrayOfExtensionsType &, bool tolower = true);
895 
898 };
899 
901 extern ITKIOImageBase_EXPORT void
903  const void * buffer,
904  std::ofstream & file,
905  ImageIOBase::ByteOrder byteOrder,
906  SizeValueType numberOfBytes,
907  SizeValueType numberOfComponents);
908 
910 extern ITKIOImageBase_EXPORT void
912  void * buffer,
913  ImageIOBase::ByteOrder byteOrder,
914  SizeValueType numberOfComponents);
915 
916 #define IMAGEIOBASE_TYPEMAP(type, ctype) \
917  template <> \
918  struct ImageIOBase::MapPixelType<type> \
919  { \
920  static constexpr IOComponentType CType = ctype; \
921  }
922 
923 // the following typemaps are not platform independent
924 IMAGEIOBASE_TYPEMAP(signed char, IOComponentType::CHAR);
925 IMAGEIOBASE_TYPEMAP(char, std::numeric_limits<char>::is_signed ? IOComponentType::CHAR : IOComponentType::UCHAR);
926 IMAGEIOBASE_TYPEMAP(unsigned char, IOComponentType::UCHAR);
927 IMAGEIOBASE_TYPEMAP(short, IOComponentType::SHORT);
928 IMAGEIOBASE_TYPEMAP(unsigned short, IOComponentType::USHORT);
929 IMAGEIOBASE_TYPEMAP(int, IOComponentType::INT);
930 IMAGEIOBASE_TYPEMAP(unsigned int, IOComponentType::UINT);
931 IMAGEIOBASE_TYPEMAP(long, IOComponentType::LONG);
932 IMAGEIOBASE_TYPEMAP(unsigned long, IOComponentType::ULONG);
933 IMAGEIOBASE_TYPEMAP(long long, IOComponentType::LONGLONG);
934 IMAGEIOBASE_TYPEMAP(unsigned long long, IOComponentType::ULONGLONG);
935 IMAGEIOBASE_TYPEMAP(float, IOComponentType::FLOAT);
936 IMAGEIOBASE_TYPEMAP(double, IOComponentType::DOUBLE);
937 #undef IMAGIOBASE_TYPEMAP
938 
939 } // end namespace itk
940 
941 #endif // itkImageIOBase_h
itk::ImageIOBase::m_WritePalette
bool m_WritePalette
Definition: itkImageIOBase.h:758
itk::ImageIOBase::POINT
Definition: itkImageIOBase.h:116
itk::ImageIOBase
Abstract superclass defines image IO interface.
Definition: itkImageIOBase.h:74
itk::uint8_t
::uint8_t uint8_t
Definition: itkIntTypes.h:29
itk::ImageIOBase::m_SupportedReadExtensions
ArrayOfExtensionsType m_SupportedReadExtensions
Definition: itkImageIOBase.h:896
itk::ImageIOBase::m_NumberOfComponents
unsigned int m_NumberOfComponents
Definition: itkImageIOBase.h:719
itk::LightProcessObject
LightProcessObject is the base class for all process objects (source, filters, mappers) in the Insigh...
Definition: itkLightProcessObject.h:72
itk::ImageIOBase::COMPLEX
Definition: itkImageIOBase.h:120
itk::RGBPixel< TPixel >
itk::ImageIOBase::GetSpacing
virtual double GetSpacing(unsigned int i) const
Definition: itkImageIOBase.h:188
itk::ImageIOBase::VECTOR
Definition: itkImageIOBase.h:115
itkCovariantVector.h
itk::ImageIOBase::Binary
Definition: itkImageIOBase.h:336
itk::ImageIOBase::SetPixelTypeInfo
void SetPixelTypeInfo(const RGBAPixel< TPixel > *)
Definition: itkImageIOBase.h:595
itkRGBPixel.h
itk::ImageIOBase::ByteOrder
ByteOrder
Definition: itkImageIOBase.h:342
itk::ImageIOBase::IOComponentType
IOComponentType
Definition: itkImageIOBase.h:133
itk::ImageIOBase::m_Dimensions
std::vector< SizeValueType > m_Dimensions
Definition: itkImageIOBase.h:765
itk::ImageIOBase::ASCII
Definition: itkImageIOBase.h:335
itk::ImageIOBase::SetPixelTypeInfo
void SetPixelTypeInfo(const CovariantVector< TPixel, VLength > *)
Definition: itkImageIOBase.h:619
itkLightProcessObject.h
itk::ImageIOBase::m_Direction
std::vector< std::vector< double > > m_Direction
Definition: itkImageIOBase.h:775
itk::ImageIOBase::GetOrigin
virtual double GetOrigin(unsigned int i) const
Definition: itkImageIOBase.h:177
itk::ImageIOBase::SetPixelTypeInfo
void SetPixelTypeInfo(const std::complex< TPixel > *)
Definition: itkImageIOBase.h:664
itk::ImageIOBase::IndexValueType
::itk::IndexValueType IndexValueType
Definition: itkImageIOBase.h:94
itk::ImageIOBase::IOPixelType
IOPixelType
Definition: itkImageIOBase.h:108
itk::ImageIOBase::SetPixelTypeInfo
void SetPixelTypeInfo(const Offset< VLength > *)
Definition: itkImageIOBase.h:673
itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR
Definition: itkImageIOBase.h:118
itkDiffusionTensor3D.h
itk::Vector
A templated class holding a n-Dimensional vector.
Definition: itkVector.h:62
itk::IMAGEIOBASE_TYPEMAP
IMAGEIOBASE_TYPEMAP(signed char, IOComponentType::CHAR)
itk::ReadRawBytesAfterSwapping
ITKIOImageBase_EXPORT void ReadRawBytesAfterSwapping(ImageIOBase::IOComponentType componentType, void *buffer, ImageIOBase::ByteOrder byteOrder, SizeValueType numberOfComponents)
itk::ImageIOBase::FIXEDARRAY
Definition: itkImageIOBase.h:121
itk::ImageIOBase::RGB
Definition: itkImageIOBase.h:112
itk::DiffusionTensor3D
Represent a diffusion tensor as used in DTI images.
Definition: itkDiffusionTensor3D.h:79
itk::ImageIOBase::SHORT
Definition: itkImageIOBase.h:139
itkRGBAPixel.h
itk::ImageIOBase::m_Strides
std::vector< SizeType > m_Strides
Definition: itkImageIOBase.h:779
itk::ImageIOBase::m_UseStreamedWriting
bool m_UseStreamedWriting
Definition: itkImageIOBase.h:748
itk::SmartPointer< Self >
itk::Indent
Control indentation during Print() invocation.
Definition: itkIndent.h:49
itk::ImageIORegion
An ImageIORegion represents a structured region of data.
Definition: itkImageIORegion.h:52
itk::intmax_t
::intmax_t intmax_t
Definition: itkIntTypes.h:55
itk::ImageIOBase::m_IORegion
ImageIORegion m_IORegion
Definition: itkImageIOBase.h:762
itk::ImageIOBase::FLOAT
Definition: itkImageIOBase.h:146
itk::ImageIOBase::RGBA
Definition: itkImageIOBase.h:113
itk::SymmetricSecondRankTensor
Represent a symmetric tensor of second rank.
Definition: itkSymmetricSecondRankTensor.h:75
itk::ImageIOBase::CanStreamRead
virtual bool CanStreamRead()
Definition: itkImageIOBase.h:448
itk::ImageIOBase::SetPixelTypeInfo
void SetPixelTypeInfo(const FixedArray< TPixel, VLength > *)
Definition: itkImageIOBase.h:627
itk::ImageIOBase::m_UseStreamedReading
bool m_UseStreamedReading
Definition: itkImageIOBase.h:745
itk::ImageIOBase::m_Initialized
bool m_Initialized
Definition: itkImageIOBase.h:712
itk::ImageIOBase::SetPixelTypeInfo
void SetPixelTypeInfo(const RGBPixel< TPixel > *)
Definition: itkImageIOBase.h:587
itk::ImageIOBase::GetDimensions
virtual SizeValueType GetDimensions(unsigned int i) const
Definition: itkImageIOBase.h:166
itk::ImageIOBase::SetFileTypeToBinary
void SetFileTypeToBinary()
Definition: itkImageIOBase.h:361
itk::LightObject
Light weight base class for most itk classes.
Definition: itkLightObject.h:59
itk::ImageIOBase::BufferSizeType
::itk::OffsetValueType BufferSizeType
Definition: itkImageIOBase.h:405
itkIndent.h
itk::ImageRegionSplitterBase
Divide an image region into several pieces.
Definition: itkImageRegionSplitterBase.h:58
itkSymmetricSecondRankTensor.h
itk::ImageIOBase::LONGLONG
Definition: itkImageIOBase.h:145
itk::ImageIOBase::UNKNOWNPIXELTYPE
Definition: itkImageIOBase.h:110
itk::ImageIOBase::SizeValueType
::itk::SizeValueType SizeValueType
Definition: itkImageIOBase.h:95
itk::ImageIOBase::USHORT
Definition: itkImageIOBase.h:138
itk::ImageIOBase::m_IsReadAsScalarPlusPalette
bool m_IsReadAsScalarPlusPalette
Definition: itkImageIOBase.h:755
itk::ImageIOBase::UNKNOWNCOMPONENTTYPE
Definition: itkImageIOBase.h:135
itk::ImageIOBase::SetPixelTypeInfo
void SetPixelTypeInfo(const Matrix< TPixel, VLength, VLength > *)
Definition: itkImageIOBase.h:655
itkImageRegionSplitterBase.h
itk::ImageIOBase::m_ExpandRGBPalette
bool m_ExpandRGBPalette
Definition: itkImageIOBase.h:751
itk::ImageIOBase::MapPixelType
Definition: itkImageIOBase.h:573
itk::ImageIOBase::COVARIANTVECTOR
Definition: itkImageIOBase.h:117
itk::ImageIOBase::m_FileName
std::string m_FileName
Definition: itkImageIOBase.h:715
itk::ImageIOBase::SetPixelTypeInfo
void SetPixelTypeInfo(const DiffusionTensor3D< TPixel > *)
Definition: itkImageIOBase.h:646
itk::ImageIOBase::OFFSET
Definition: itkImageIOBase.h:114
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:52
itk::ImageIOBase::LittleEndian
Definition: itkImageIOBase.h:345
itk::Matrix
A templated class holding a M x N size Matrix.
Definition: itkMatrix.h:50
itk::ImageIOBase::INT
Definition: itkImageIOBase.h:141
itk::ImageIOBase::GetDirection
virtual std::vector< double > GetDirection(unsigned int i) const
Definition: itkImageIOBase.h:202
itk::ImageIOBase::SetFileTypeToASCII
void SetFileTypeToASCII()
Definition: itkImageIOBase.h:354
itk::CovariantVector
A templated class holding a n-Dimensional covariant vector.
Definition: itkCovariantVector.h:68
itk::Offset
Represent a n-dimensional offset between two n-dimensional indexes of n-dimensional image.
Definition: itkOffset.h:67
itk::ImageIOBase::SetPixelTypeInfo
void SetPixelTypeInfo(const TPixel *)
Definition: itkImageIOBase.h:579
itk::ImageIOBase::FileType
FileType
Definition: itkImageIOBase.h:333
itk::ImageIOBase::BigEndian
Definition: itkImageIOBase.h:344
itk::RGBAPixel
Represent Red, Green, Blue and Alpha components for color images.
Definition: itkRGBAPixel.h:59
itk::ImageIOBase::SizeType
::itk::intmax_t SizeType
Definition: itkImageIOBase.h:401
itk
The "itk" namespace contains all Insight Segmentation and Registration Toolkit (ITK) classes....
Definition: itkArray.h:26
itk::ImageIOBase::SCALAR
Definition: itkImageIOBase.h:111
itk::OffsetValueType
signed long OffsetValueType
Definition: itkIntTypes.h:94
itk::ImageIOBase::LONG
Definition: itkImageIOBase.h:143
itk::ImageIOBase::DIFFUSIONTENSOR3D
Definition: itkImageIOBase.h:119
itk::ImageIOBase::m_Origin
std::vector< double > m_Origin
Definition: itkImageIOBase.h:772
itk::IndexValueType
signed long IndexValueType
Definition: itkIntTypes.h:90
itk::WriteRawBytesAfterSwapping
ITKIOImageBase_EXPORT void WriteRawBytesAfterSwapping(ImageIOBase::IOComponentType componentType, const void *buffer, std::ofstream &file, ImageIOBase::ByteOrder byteOrder, SizeValueType numberOfBytes, SizeValueType numberOfComponents)
itkImageIORegion.h
itk::Object
Base class for most ITK classes.
Definition: itkObject.h:60
itk::ImageIOBase::SetByteOrderToLittleEndian
void SetByteOrderToLittleEndian()
Definition: itkImageIOBase.h:387
itk::ImageIOBase::SetByteOrderToBigEndian
void SetByteOrderToBigEndian()
Definition: itkImageIOBase.h:380
itk::ImageIOBase::ULONG
Definition: itkImageIOBase.h:142
itk::ImageIOBase::UINT
Definition: itkImageIOBase.h:140
itk::ImageIOBase::UCHAR
Definition: itkImageIOBase.h:136
itk::ImageIOBase::CHAR
Definition: itkImageIOBase.h:137
itk::ImageIOBase::UnknownType
Definition: itkImageIOBase.h:102
itk::ImageIOBase::m_SupportedWriteExtensions
ArrayOfExtensionsType m_SupportedWriteExtensions
Definition: itkImageIOBase.h:897
itk::ImageIOBase::ULONGLONG
Definition: itkImageIOBase.h:144
itk::ImageIOBase::SetPixelTypeInfo
void SetPixelTypeInfo(const VariableLengthVector< TPixel > *)
Definition: itkImageIOBase.h:611
itk::ImageIOBase::SetPixelTypeInfo
void SetPixelTypeInfo(const Vector< TPixel, VLength > *)
Definition: itkImageIOBase.h:603
itk::ImageIOBase::CanStreamWrite
virtual bool CanStreamWrite()
Definition: itkImageIOBase.h:476
itk::ImageIOBase::SupportsDimension
virtual bool SupportsDimension(unsigned long dim)
Definition: itkImageIOBase.h:500
itk::ImageIOBase::m_Spacing
std::vector< double > m_Spacing
Definition: itkImageIOBase.h:769
itk::ImageIOBase::SetPixelTypeInfo
void SetPixelTypeInfo(const SymmetricSecondRankTensor< TPixel, VLength > *)
Definition: itkImageIOBase.h:637
itk::SizeValueType
unsigned long SizeValueType
Definition: itkIntTypes.h:83
itk::ImageIOBase::ArrayOfExtensionsType
std::vector< std::string > ArrayOfExtensionsType
Definition: itkImageIOBase.h:551
fileName
std::string fileName
Definition: itkTestDriverInclude.h:118