otbImageIOBase.h

Go to the documentation of this file.

/*
 * Copyright (C) 1999-2011 Insight Software Consortium
 * Copyright (C) 2005-2023 Centre National d'Etudes Spatiales (CNES)
 *
 * This file is part of Orfeo Toolbox
 *
 *     https://www.orfeo-toolbox.org/
 *
 * 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
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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 otbImageIOBase_h
#define otbImageIOBase_h
 
#include "otbImageMetadata.h"
#include "itkLightProcessObject.h"
#include "itkIndent.h"
#include "itkImageIORegion.h"
#include "vnl/vnl_vector.h"
 
#include <string>
#include <typeinfo>
#include <vector>
 
#include "OTBImageBaseExport.h"
 
namespace otb
{
 
class OTBImageBase_EXPORT ImageIOBase : public itk::LightProcessObject
{
public:
  typedef ImageIOBase             Self;
  typedef itk::LightProcessObject Superclass;
  typedef itk::SmartPointer<Self> Pointer;
 
  itkTypeMacro(ImageIOBase, Superclass);
 
  itkSetStringMacro(FileName);
  itkGetStringMacro(FileName);
 
  typedef long          IndexValueType;
  typedef unsigned long SizeValueType;
 
  class UnknownType
  {
  };
 
  typedef enum {
    UNKNOWNPIXELTYPE,
    SCALAR,
    RGB,
    RGBA,
    OFFSET,
    VECTOR,
    POINT,
    COVARIANTVECTOR,
    SYMMETRICSECONDRANKTENSOR,
    DIFFUSIONTENSOR3D,
    COMPLEX,
    FIXEDARRAY,
    MATRIX
  } IOPixelType;
 
  typedef enum { UNKNOWNCOMPONENTTYPE, UCHAR, CHAR, USHORT, SHORT, UINT, INT, ULONG, LONG, FLOAT, DOUBLE, CSHORT, CINT, CFLOAT, CDOUBLE } IOComponentType;
 
  void SetNumberOfDimensions(unsigned int);
  itkGetConstMacro(NumberOfDimensions, unsigned int);
 
  virtual void SetDimensions(unsigned int i, unsigned int dim);
  virtual unsigned int 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, std::vector<double>& direction);
  virtual void SetDirection(unsigned int i, vnl_vector<double>& direction);
  virtual std::vector<double> GetDirection(unsigned int i) const
  {
    return m_Direction[i];
  }
 
  virtual std::vector<double> GetDefaultDirection(unsigned int i) const;
 
  itkSetMacro(IORegion, itk::ImageIORegion);
  itkGetConstReferenceMacro(IORegion, itk::ImageIORegion);
 
  itkSetEnumMacro(PixelType, IOPixelType);
  itkGetEnumMacro(PixelType, IOPixelType);
 
  virtual bool SetPixelTypeInfo(const std::type_info& ptype);
 
  itkSetEnumMacro(ComponentType, IOComponentType);
  itkGetEnumMacro(ComponentType, IOComponentType);
  virtual const std::type_info& GetComponentTypeInfo() const;
 
  itkSetMacro(NumberOfComponents, unsigned int);
  itkGetConstReferenceMacro(NumberOfComponents, unsigned int);
 
  itkSetMacro(UseCompression, bool);
  itkGetConstMacro(UseCompression, bool);
  itkBooleanMacro(UseCompression);
 
  itkSetMacro(UseStreamedReading, bool);
  itkGetConstMacro(UseStreamedReading, bool);
  itkBooleanMacro(UseStreamedReading);
 
  itkSetMacro(UseStreamedWriting, bool);
  itkGetConstMacro(UseStreamedWriting, bool);
  itkBooleanMacro(UseStreamedWriting);
 
 
  static std::string GetComponentTypeAsString(IOComponentType);
 
  static std::string GetPixelTypeAsString(IOPixelType);
 
  typedef enum { ASCII, Binary, TypeNotApplicable } FileType;
 
  typedef enum { BigEndian, LittleEndian, OrderNotApplicable } ByteOrder;
 
  itkSetEnumMacro(FileType, FileType);
  itkGetEnumMacro(FileType, FileType);
  void SetFileTypeToASCII()
  {
    this->SetFileType(ASCII);
  }
  void SetFileTypeToBinary()
  {
    this->SetFileType(Binary);
  }
 
  itkSetEnumMacro(ByteOrder, ByteOrder);
  itkGetEnumMacro(ByteOrder, ByteOrder);
  void SetByteOrderToBigEndian()
  {
    this->SetByteOrder(BigEndian);
  }
  void SetByteOrderToLittleEndian()
  {
    this->SetByteOrder(LittleEndian);
  }
 
  static std::string GetFileTypeAsString(FileType);
 
  static std::string GetByteOrderAsString(ByteOrder);
 
  typedef std::streamoff SizeType;
 
  typedef size_t BufferSizeType;
 
  virtual SizeType GetPixelStride() const;
 
  SizeType GetImageSizeInPixels() const;
 
  SizeType GetImageSizeInBytes() const;
 
  SizeType GetImageSizeInComponents() const;
 
 
  virtual unsigned int GetComponentSize() const;
 
  virtual unsigned int GetOverviewsCount() = 0;
 
  virtual std::vector<std::string> GetOverviewsInfo() = 0;
 
  virtual void SetOutputImagePixelType(bool isComplexInternalPixelType, bool isVectorImage) = 0;
 
  /*-------- 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 itk::ImageIORegion GenerateStreamableReadRegionFromRequestedRegion(const itk::ImageIORegion& requested) const;
 
 
  virtual unsigned int GetActualNumberOfSplitsForWriting(unsigned int numberOfRequestedSplits, const itk::ImageIORegion& pasteRegion,
                                                         const itk::ImageIORegion& largestPossibleRegion);
 
  virtual itk::ImageIORegion GetSplitRegionForWriting(unsigned int ithPiece, unsigned int numberOfActualSplits, const itk::ImageIORegion& pasteRegion,
                                                      const itk::ImageIORegion& largestPossibleRegion);
 
  typedef std::vector<std::string> ArrayOfExtensionsType;
 
  const ArrayOfExtensionsType& GetSupportedReadExtensions() const;
 
  const ArrayOfExtensionsType& GetSupportedWriteExtensions() const;
 
  void DoMapBuffer(void* buffer, size_t numberOfPixels, std::vector<unsigned int>& bandList);
 
  itkGetConstReferenceMacro(AttachedFileNames, std::vector<std::string>);
 
  const ImageMetadata & GetImageMetadata() const;
 
  void SetImageMetadata(ImageMetadata);
 
protected:
  ImageIOBase();
  ~ImageIOBase() override;
  void PrintSelf(std::ostream& os, itk::Indent indent) const override;
 
  IOPixelType m_PixelType;
 
  IOComponentType m_ComponentType;
 
  ByteOrder m_ByteOrder;
  FileType  m_FileType;
 
  bool m_Initialized;
 
  std::string m_FileName;
 
  unsigned int m_NumberOfComponents;
 
  unsigned int m_NumberOfDimensions;
 
  bool m_UseCompression;
 
  bool m_UseStreamedReading;
 
  bool m_UseStreamedWriting;
 
  itk::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;
 
  void WriteBufferAsASCII(std::ostream& os, const void* buffer, IOComponentType ctype, SizeType numberOfBytesToWrite);
 
  void ReadBufferAsASCII(std::istream& os, void* buffer, IOComponentType ctype, SizeType numberOfBytesToBeRead);
 
  bool ReadBufferAsBinary(std::istream& os, void* buffer, SizeType numberOfBytesToBeRead);
 
 
  void AddSupportedReadExtension(const char* extension);
 
  void AddSupportedWriteExtension(const char* extension);
 
  virtual unsigned int GetActualNumberOfSplitsForWritingCanStreamWrite(unsigned int numberOfRequestedSplits, const itk::ImageIORegion& pasteRegion) const;
 
  virtual itk::ImageIORegion GetSplitRegionForWritingCanStreamWrite(unsigned int ithPiece, unsigned int numberOfActualSplits,
                                                                    const itk::ImageIORegion& pasteRegion) const;
 
  std::vector<std::string> m_AttachedFileNames;
 
  ImageMetadata m_Imd;
 
  std::vector<unsigned int> m_BandList;
 
private:
  ImageIOBase(const Self&) = delete;
  void operator=(const Self&) = delete;
 
  ArrayOfExtensionsType m_SupportedReadExtensions;
  ArrayOfExtensionsType m_SupportedWriteExtensions;
};
 
} // end namespace itk
 
#endif // otbImageIOBase_h