itkImageIOBase.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         https://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkImageIOBase_h
#define itkImageIOBase_h
#include "ITKIOImageBaseExport.h"
 
#include "itkIOConfigure.h"
 
#include "itkLightProcessObject.h"
#include "itkIndent.h"
#include "itkImageIORegion.h"
#include "itkRGBPixel.h"
#include "itkRGBAPixel.h"
#include "itkCovariantVector.h"
#include "itkSymmetricSecondRankTensor.h"
#include "itkDiffusionTensor3D.h"
#include "itkArray.h"
#include "itkVariableSizeMatrix.h"
#include "itkImageRegionSplitterBase.h"
#include "itkCommonEnums.h"
 
#include "vnl/vnl_vector.h"
#include "vcl_compiler.h"
 
#include <fstream>
#include <string>
#include <type_traits> // For is_same_v and is_signed_v.
 
namespace itk
{
// Forward reference for VariableLengthVector
template <typename TValue>
class VariableLengthVector;

class ITKIOImageBase_EXPORT ImageIOBase : public LightProcessObject
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ImageIOBase);

  using Self = ImageIOBase;
  using Superclass = LightProcessObject;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkOverrideGetNameOfClassMacro(ImageIOBase);

  itkSetStringMacro(FileName);
  itkGetStringMacro(FileName);

  using IndexValueType = itk::IndexValueType;
  using SizeValueType = itk::SizeValueType;
 
#ifndef ITK_LEGACY_REMOVE
  class [[deprecated("This class is intended to be removed from ITK 6.")]] UnknownType
  {};
#endif
 
#if !defined(ITK_LEGACY_REMOVE)
  using IOPixelType = IOPixelEnum;
  static constexpr IOPixelEnum UNKNOWNPIXELTYPE = IOPixelEnum::UNKNOWNPIXELTYPE;
  static constexpr IOPixelEnum SCALAR = IOPixelEnum::SCALAR;
  static constexpr IOPixelEnum RGB = IOPixelEnum::RGB;
  static constexpr IOPixelEnum RGBA = IOPixelEnum::RGBA;
  static constexpr IOPixelEnum OFFSET = IOPixelEnum::OFFSET;
  static constexpr IOPixelEnum VECTOR = IOPixelEnum::VECTOR;
  static constexpr IOPixelEnum POINT = IOPixelEnum::POINT;
  static constexpr IOPixelEnum COVARIANTVECTOR = IOPixelEnum::COVARIANTVECTOR;
  static constexpr IOPixelEnum SYMMETRICSECONDRANKTENSOR = IOPixelEnum::SYMMETRICSECONDRANKTENSOR;
  static constexpr IOPixelEnum DIFFUSIONTENSOR3D = IOPixelEnum::DIFFUSIONTENSOR3D;
  static constexpr IOPixelEnum COMPLEX = IOPixelEnum::COMPLEX;
  static constexpr IOPixelEnum FIXEDARRAY = IOPixelEnum::FIXEDARRAY;
  static constexpr IOPixelEnum MATRIX = IOPixelEnum::MATRIX;
#endif
 
  using IOComponentEnum = itk::IOComponentEnum;
#if !defined(ITK_LEGACY_REMOVE)
  using IOComponentType = IOComponentEnum;
  static constexpr IOComponentEnum UNKNOWNCOMPONENTTYPE = IOComponentEnum::UNKNOWNCOMPONENTTYPE;
  static constexpr IOComponentEnum UCHAR = IOComponentEnum::UCHAR;
  static constexpr IOComponentEnum CHAR = IOComponentEnum::CHAR;
  static constexpr IOComponentEnum USHORT = IOComponentEnum::USHORT;
  static constexpr IOComponentEnum SHORT = IOComponentEnum::SHORT;
  static constexpr IOComponentEnum UINT = IOComponentEnum::UINT;
  static constexpr IOComponentEnum INT = IOComponentEnum::INT;
  static constexpr IOComponentEnum ULONG = IOComponentEnum::ULONG;
  static constexpr IOComponentEnum LONG = IOComponentEnum::LONG;
  static constexpr IOComponentEnum ULONGLONG = IOComponentEnum::ULONGLONG;
  static constexpr IOComponentEnum LONGLONG = IOComponentEnum::LONGLONG;
  static constexpr IOComponentEnum FLOAT = IOComponentEnum::FLOAT;
  static constexpr IOComponentEnum DOUBLE = IOComponentEnum::DOUBLE;
#endif
 
  using IOFileEnum = itk::IOFileEnum;
#if !defined(ITK_LEGACY_REMOVE)
  static constexpr IOFileEnum ASCII = IOFileEnum::ASCII;
  static constexpr IOFileEnum Binary = IOFileEnum::Binary;
  static constexpr IOFileEnum TypeNotApplicable = IOFileEnum::TypeNotApplicable;
#endif
 
  using IOByteOrderEnum = itk::IOByteOrderEnum;
#if !defined(ITK_LEGACY_REMOVE)
  using ByteOrder = itk::IOByteOrderEnum;
  static constexpr IOByteOrderEnum BigEndian = IOByteOrderEnum::BigEndian;
  static constexpr IOByteOrderEnum LittleEndian = IOByteOrderEnum::LittleEndian;
  static constexpr IOByteOrderEnum OrderNotApplicable = IOByteOrderEnum::OrderNotApplicable;
#endif

  void
  SetNumberOfDimensions(unsigned int);
 
  itkGetConstMacro(NumberOfDimensions, unsigned int);

  virtual void
  SetDimensions(unsigned int i, SizeValueType dim);
  virtual SizeValueType
 
  GetDimensions(unsigned int i) const
  {
    return m_Dimensions[i];
  }


  virtual void
  SetOrigin(unsigned int i, double origin);
 
  virtual double
  GetOrigin(unsigned int i) const
  {
    return m_Origin[i];
  }

  virtual void
  SetSpacing(unsigned int i, double spacing);
 
  virtual double
  GetSpacing(unsigned int i) const
  {
    return m_Spacing[i];
  }

  virtual void
  SetDirection(unsigned int i, const std::vector<double> & direction);
 
  virtual void
  SetDirection(unsigned int i, const vnl_vector<double> & direction);
 
  virtual std::vector<double>
  GetDirection(unsigned int i) const
  {
    return m_Direction[i];
  }

  virtual std::vector<double>
  GetDefaultDirection(unsigned int k) const;

  itkSetMacro(IORegion, ImageIORegion);
  itkGetConstReferenceMacro(IORegion, ImageIORegion);

  itkSetEnumMacro(PixelType, itk::CommonEnums::IOPixel);
  itkGetEnumMacro(PixelType, itk::CommonEnums::IOPixel);

  itkSetEnumMacro(ComponentType, IOComponentEnum);
  itkGetEnumMacro(ComponentType, IOComponentEnum);
 
#ifndef ITK_LEGACY_REMOVE
  itkLegacyMacro(virtual const std::type_info & GetComponentTypeInfo() const);
#endif

  itkSetMacro(NumberOfComponents, unsigned int);
  itkGetConstReferenceMacro(NumberOfComponents, unsigned int);

  itkSetMacro(UseCompression, bool);
  itkGetConstMacro(UseCompression, bool);
  itkBooleanMacro(UseCompression);

  itkSetClampMacro(CompressionLevel, int, 1, this->GetMaximumCompressionLevel());
  itkGetConstMacro(CompressionLevel, int);

  virtual void
  SetCompressor(std::string _c);
  itkGetConstReferenceMacro(Compressor, std::string);

  itkSetMacro(UseStreamedReading, bool);
  itkGetConstMacro(UseStreamedReading, bool);
  itkBooleanMacro(UseStreamedReading);

  itkSetMacro(UseStreamedWriting, bool);
  itkGetConstMacro(UseStreamedWriting, bool);
  itkBooleanMacro(UseStreamedWriting);

  itkSetMacro(ExpandRGBPalette, bool);
  itkGetConstMacro(ExpandRGBPalette, bool);
  itkBooleanMacro(ExpandRGBPalette);

  itkSetMacro(WritePalette, bool);
  itkGetConstMacro(WritePalette, bool);
  itkBooleanMacro(WritePalette);

  itkGetConstMacro(IsReadAsScalarPlusPalette, bool);

  static std::string GetComponentTypeAsString(IOComponentEnum);

  static constexpr bool
  IsComponentTypeFloatingPoint(const IOComponentEnum componentEnum)
  {
    return GetComponentTypeTraits(componentEnum).isFloatingPoint;
  }

  static constexpr bool
  IsComponentTypeUnsigned(const IOComponentEnum componentEnum)
  {
    return GetComponentTypeTraits(componentEnum).isUnsigned;
  }

  static constexpr size_t
  GetNumberOfBitsOfComponentType(const IOComponentEnum componentEnum)
  {
    return GetComponentTypeTraits(componentEnum).sizeOfComponent * size_t{ CHAR_BIT };
  }

  static constexpr IOComponentEnum
  GetComponentTypeFromTypeTraits(const bool isFloatingPoint, const bool isUnsigned, const size_t numberOfBits)
  {
    for (const auto componentEnum : { IOComponentEnum::UINT8,
                                      IOComponentEnum::INT8,
                                      IOComponentEnum::UINT16,
                                      IOComponentEnum::INT16,
                                      IOComponentEnum::UINT32,
                                      IOComponentEnum::INT32,
                                      IOComponentEnum::UINT64,
                                      IOComponentEnum::INT64,
                                      IOComponentEnum::FLOAT32,
                                      IOComponentEnum::FLOAT64 })
    {
      if (const ComponentTypeTraits typeTraits = GetComponentTypeTraits(componentEnum);
          typeTraits.isFloatingPoint == isFloatingPoint && typeTraits.isUnsigned == isUnsigned &&
          typeTraits.sizeOfComponent * size_t{ CHAR_BIT } == numberOfBits)
      {
        return componentEnum;
      }
    }
    return IOComponentEnum::UNKNOWNCOMPONENTTYPE;
  }

  static IOComponentEnum
  GetComponentTypeFromString(const std::string & typeString);

  static std::string GetPixelTypeAsString(IOPixelEnum);

  static IOPixelEnum
  GetPixelTypeFromString(const std::string & pixelString);

  itkSetEnumMacro(FileType, IOFileEnum);
  itkGetEnumMacro(FileType, IOFileEnum);
  void
  SetFileTypeToASCII()
  {
    this->SetFileType(IOFileEnum::ASCII);
  }

 
  void
  SetFileTypeToBinary()
  {
    this->SetFileType(IOFileEnum::Binary);
  }

  itkSetEnumMacro(ByteOrder, IOByteOrderEnum);
  itkGetEnumMacro(ByteOrder, IOByteOrderEnum);
  void
  SetByteOrderToBigEndian()
  {
    this->SetByteOrder(IOByteOrderEnum::BigEndian);
  }

 
  void
  SetByteOrderToLittleEndian()
  {
    this->SetByteOrder(IOByteOrderEnum::LittleEndian);
  }

  std::string GetFileTypeAsString(IOFileEnum) const;

  std::string GetByteOrderAsString(IOByteOrderEnum) const;

  using SizeType = itk::intmax_t;

  using BufferSizeType = itk::OffsetValueType;

  virtual SizeType
  GetPixelStride() const;

  SizeType
  GetImageSizeInPixels() const;

  SizeType
  GetImageSizeInBytes() const;

  SizeType
  GetImageSizeInComponents() const;

  virtual unsigned int
  GetComponentSize() const;
 
  /*-------- This part of the interfaces deals with reading data ----- */

  virtual bool
  CanReadFile(const char *) = 0;

  virtual bool
  CanStreamRead()
  {
    return false;
  }

  virtual void
  ReadImageInformation() = 0;

  virtual void
  Read(void * buffer) = 0;
 
  /*-------- This part of the interfaces deals with writing data ----- */

  virtual bool
  CanWriteFile(const char *) = 0;

  virtual bool
  CanStreamWrite()
  {
    return false;
  }

  virtual void
  WriteImageInformation() = 0;

  virtual void
  Write(const void * buffer) = 0;
 
  /* --- Support reading and writing data as a series of files. --- */

  virtual bool
  SupportsDimension(unsigned long dim)
  {
    return (dim == 2);
  }

  virtual ImageIORegion
  GenerateStreamableReadRegionFromRequestedRegion(const ImageIORegion & requested) const;

  virtual unsigned int
  GetActualNumberOfSplitsForWriting(unsigned int          numberOfRequestedSplits,
                                    const ImageIORegion & pasteRegion,
                                    const ImageIORegion & largestPossibleRegion);

  virtual ImageIORegion
  GetSplitRegionForWriting(unsigned int          ithPiece,
                           unsigned int          numberOfActualSplits,
                           const ImageIORegion & pasteRegion,
                           const ImageIORegion & largestPossibleRegion);

  using ArrayOfExtensionsType = std::vector<std::string>;

  const ArrayOfExtensionsType &
  GetSupportedReadExtensions() const;

  const ArrayOfExtensionsType &
  GetSupportedWriteExtensions() const;
 
#ifndef ITK_LEGACY_REMOVE
  // This member function (template) is not implemented and not specialized.
  template <typename TPixel>
  itkLegacyMacro(void SetTypeInfo(const TPixel *));
#endif

  template <typename TComponent>
  struct MapPixelType
  {
    static constexpr IOComponentEnum CType =
      std::is_same_v<TComponent, char> ? (std::is_signed_v<char> ? IOComponentEnum::CHAR : IOComponentEnum::UCHAR)
      : std::is_same_v<TComponent, signed char>        ? IOComponentEnum::CHAR
      : std::is_same_v<TComponent, unsigned char>      ? IOComponentEnum::UCHAR
      : std::is_same_v<TComponent, short>              ? IOComponentEnum::SHORT
      : std::is_same_v<TComponent, unsigned short>     ? IOComponentEnum::USHORT
      : std::is_same_v<TComponent, int>                ? IOComponentEnum::INT
      : std::is_same_v<TComponent, unsigned int>       ? IOComponentEnum::UINT
      : std::is_same_v<TComponent, long>               ? IOComponentEnum::LONG
      : std::is_same_v<TComponent, unsigned long>      ? IOComponentEnum::ULONG
      : std::is_same_v<TComponent, long long>          ? IOComponentEnum::LONGLONG
      : std::is_same_v<TComponent, unsigned long long> ? IOComponentEnum::ULONGLONG
      : std::is_same_v<TComponent, float>              ? IOComponentEnum::FLOAT
      : std::is_same_v<TComponent, double>             ? IOComponentEnum::DOUBLE
                                                       : IOComponentEnum::UNKNOWNCOMPONENTTYPE;
  };
 
  template <typename TPixel>
  void
  SetPixelTypeInfo(const TPixel *)
  {
    this->SetNumberOfComponents(1);
    this->SetPixelType(IOPixelEnum::SCALAR);
    this->SetComponentType(MapPixelType<TPixel>::CType);
  }
  template <typename TComponent>
  void
  SetPixelTypeInfo(const RGBPixel<TComponent> *)
  {
    this->SetNumberOfComponents(3);
    this->SetPixelType(IOPixelEnum::RGB);
    this->SetComponentType(MapPixelType<TComponent>::CType);
  }
  template <typename TComponent>
  void
  SetPixelTypeInfo(const RGBAPixel<TComponent> *)
  {
    this->SetNumberOfComponents(4);
    this->SetPixelType(IOPixelEnum::RGBA);
    this->SetComponentType(MapPixelType<TComponent>::CType);
  }
  template <unsigned int VLength>
  void
  SetPixelTypeInfo(const Offset<VLength> *)
  {
    this->SetNumberOfComponents(VLength);
    this->SetPixelType(IOPixelEnum::OFFSET);
    this->SetComponentType(IOComponentEnum::LONG);
  }
  template <typename TComponent, unsigned int VLength>
  void
  SetPixelTypeInfo(const Vector<TComponent, VLength> *)
  {
    this->SetNumberOfComponents(VLength);
    this->SetPixelType(IOPixelEnum::VECTOR);
    this->SetComponentType(MapPixelType<TComponent>::CType);
  }
  template <typename TCoordinate, unsigned int VPointDimension>
  void
  SetPixelTypeInfo(const Point<TCoordinate, VPointDimension> *)
  {
    this->SetNumberOfComponents(VPointDimension);
    this->SetPixelType(IOPixelEnum::POINT);
    this->SetComponentType(MapPixelType<TCoordinate>::CType);
  }
  template <typename TComponent, unsigned int VLength>
  void
  SetPixelTypeInfo(const CovariantVector<TComponent, VLength> *)
  {
    this->SetNumberOfComponents(VLength);
    this->SetPixelType(IOPixelEnum::COVARIANTVECTOR);
    this->SetComponentType(MapPixelType<TComponent>::CType);
  }
  template <typename TComponent, unsigned int VLength>
  void
  SetPixelTypeInfo(const SymmetricSecondRankTensor<TComponent, VLength> *)
  {
    this->SetNumberOfComponents(VLength * (VLength + 1) / 2);
    this->SetPixelType(IOPixelEnum::SYMMETRICSECONDRANKTENSOR);
    this->SetComponentType(MapPixelType<TComponent>::CType);
  }
  template <typename TComponent>
  void
  SetPixelTypeInfo(const DiffusionTensor3D<TComponent> *)
  {
    this->SetNumberOfComponents(6);
    this->SetPixelType(IOPixelEnum::DIFFUSIONTENSOR3D);
    this->SetComponentType(MapPixelType<TComponent>::CType);
  }
  template <typename TComponent>
  void
  SetPixelTypeInfo(const std::complex<TComponent> *)
  {
    this->SetNumberOfComponents(2);
    this->SetPixelType(IOPixelEnum::COMPLEX);
    this->SetComponentType(MapPixelType<TComponent>::CType);
  }
  template <typename TComponent, unsigned int VLength>
  void
  SetPixelTypeInfo(const FixedArray<TComponent, VLength> *)
  {
    this->SetNumberOfComponents(VLength);
    this->SetPixelType(IOPixelEnum::FIXEDARRAY);
    this->SetComponentType(MapPixelType<TComponent>::CType);
  }
  template <typename TComponent>
  void
  SetPixelTypeInfo(const VariableLengthVector<TComponent> *)
  {
    this->SetNumberOfComponents(1);
    this->SetPixelType(IOPixelEnum::VARIABLELENGTHVECTOR);
    this->SetComponentType(MapPixelType<TComponent>::CType);
  }
  template <typename TValue>
  void
  SetPixelTypeInfo(const Array<TValue> *)
  {
    this->SetNumberOfComponents(1);
    this->SetPixelType(IOPixelEnum::ARRAY);
    this->SetComponentType(MapPixelType<TValue>::CType);
  }
  template <typename TComponent, unsigned int VLength>
  void
  SetPixelTypeInfo(const Matrix<TComponent, VLength, VLength> *)
  {
    this->SetNumberOfComponents(VLength * VLength);
    this->SetPixelType(IOPixelEnum::MATRIX);
    this->SetComponentType(MapPixelType<TComponent>::CType);
  }
  template <typename TValue>
  void
  SetPixelTypeInfo(const VariableSizeMatrix<TValue> *)
  {
    this->SetNumberOfComponents(1);
    this->SetPixelType(IOPixelEnum::VARIABLESIZEMATRIX);
    this->SetComponentType(MapPixelType<TValue>::CType);
  }

 
protected:
  ImageIOBase();
  ~ImageIOBase() override;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  virtual const ImageRegionSplitterBase *
  GetImageRegionSplitter() const;

  virtual bool
  HasSupportedReadExtension(const char * fileName, bool ignoreCase = true);
  virtual bool
  HasSupportedWriteExtension(const char * fileName, bool ignoreCase = true);

  IOPixelEnum m_PixelType{ IOPixelEnum::SCALAR };

  IOComponentEnum m_ComponentType{ IOComponentEnum::UNKNOWNCOMPONENTTYPE };

  IOByteOrderEnum m_ByteOrder{ IOByteOrderEnum::OrderNotApplicable };
 
  IOFileEnum m_FileType{ IOFileEnum::TypeNotApplicable };

  bool m_Initialized{};

  std::string m_FileName{};

  unsigned int m_NumberOfComponents{};

  unsigned int m_NumberOfDimensions{ 0 };

  bool m_UseCompression{ false };
 
 
  int         m_CompressionLevel{ 30 };
  int         m_MaximumCompressionLevel{ 100 };
  std::string m_Compressor{ "uninitialized" };

  virtual void
  SetMaximumCompressionLevel(int);
  itkGetConstMacro(MaximumCompressionLevel, int);

  virtual void
  InternalSetCompressor(const std::string & _compressor);

  bool m_UseStreamedReading{};

  bool m_UseStreamedWriting{};

  bool m_ExpandRGBPalette{};

  bool m_IsReadAsScalarPlusPalette{};

  bool m_WritePalette{};

  ImageIORegion m_IORegion{};

  std::vector<SizeValueType> m_Dimensions{};

  std::vector<double> m_Spacing{};

  std::vector<double> m_Origin{};

  std::vector<std::vector<double>> m_Direction{};

  std::vector<SizeType> m_Strides{};

  virtual void
  Reset(const bool freeDynamic = true);

  void
  Resize(const unsigned int numDimensions, const unsigned int * dimensions);

  virtual unsigned int
  GetPixelSize() const;

  void
  ComputeStrides();

  SizeType
  GetComponentStride() const;

  SizeType
  GetRowStride() const;

  SizeType
  GetSliceStride() const;

  virtual void
  OpenFileForReading(std::ifstream & inputStream, const std::string & filename, bool ascii = false);

  virtual void
  OpenFileForWriting(std::ofstream &     outputStream,
                     const std::string & filename,
                     bool                truncate = true,
                     bool                ascii = false);

  virtual void
  WriteBufferAsASCII(std::ostream & os, const void * buffer, IOComponentEnum ctype, SizeType numComp);

  virtual void
  ReadBufferAsASCII(std::istream & is, void * buffer, IOComponentEnum ctype, SizeType numComp);

  bool
  ReadBufferAsBinary(std::istream & is, void * buffer, SizeType num);

  void
  AddSupportedReadExtension(const char * extension);

  void
  AddSupportedWriteExtension(const char * extension);
 
 
  void
  SetSupportedReadExtensions(const ArrayOfExtensionsType &);
  void
  SetSupportedWriteExtensions(const ArrayOfExtensionsType &);

  virtual unsigned int
  GetActualNumberOfSplitsForWritingCanStreamWrite(unsigned int          numberOfRequestedSplits,
                                                  const ImageIORegion & pasteRegion) const;

  virtual ImageIORegion
  GetSplitRegionForWritingCanStreamWrite(unsigned int          ithPiece,
                                         unsigned int          numberOfActualSplits,
                                         const ImageIORegion & pasteRegion) const;
 
private:
  struct ComponentTypeTraits
  {
    bool         isFloatingPoint;
    bool         isUnsigned;
    unsigned int sizeOfComponent;
 
    template <typename... TComponent>
    static constexpr ComponentTypeTraits
    Get(const IOComponentEnum componentEnum)
    {
      ComponentTypeTraits result{};
      return ((MapPixelType<TComponent>::CType == componentEnum
                 ? result = { std::is_floating_point_v<TComponent>, std::is_unsigned_v<TComponent>, sizeof(TComponent) }
                 : result),
              ...);
    }
  };
 
 
  static constexpr ComponentTypeTraits
  GetComponentTypeTraits(const IOComponentEnum componentEnum)
  {
    return ComponentTypeTraits::Get<signed char,
                                    unsigned char,
                                    short,
                                    unsigned short,
                                    int,
                                    unsigned int,
                                    long,
                                    unsigned long,
                                    long long,
                                    unsigned long long,
                                    float,
                                    double>(componentEnum);
  }
 
  bool
  HasSupportedExtension(const char *, const ArrayOfExtensionsType &, bool ignoreCase = true);
 
  ArrayOfExtensionsType m_SupportedReadExtensions{};
  ArrayOfExtensionsType m_SupportedWriteExtensions{};
};

extern ITKIOImageBase_EXPORT void
WriteRawBytesAfterSwapping(IOComponentEnum componentType,
                           const void *    buffer,
                           std::ofstream & file,
                           IOByteOrderEnum byteOrder,
                           SizeValueType   numberOfBytes,
                           SizeValueType   numberOfComponents);

extern ITKIOImageBase_EXPORT void
ReadRawBytesAfterSwapping(IOComponentEnum componentType,
                          void *          buffer,
                          IOByteOrderEnum byteOrder,
                          SizeValueType   numberOfComponents);
 
} // end namespace itk
 
#endif // itkImageIOBase_h