otbGDALImageIO.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2022 Centre National d'Etudes Spatiales (CNES)
 * Copyright (C) 2018-2020 CS Systemes d'Information (CS SI)
 *
 * 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 otbGDALImageIO_h
#define otbGDALImageIO_h
 
 
/* C++ Libraries */
#include <string>
 
/* ITK Libraries */
#include "otbImageIOBase.h"
#include "otbMetadataSupplierInterface.h"
#include "otbMetadataStorageInterface.h"
 
#include "OTBIOGDALExport.h"
#include "otbSpatialReference.h"
 
class GDALDataset;
 
namespace otb
{
class GDALDatasetWrapper;
class GDALDataTypeWrapper;
 
class OTBIOGDAL_EXPORT GDALImageIO
  : public otb::ImageIOBase
  , public otb::MetadataSupplierInterface
  , public otb::MetadataStorageInterface
{
public:
  typedef unsigned char InputPixelType;
 
  typedef GDALImageIO             Self;
  typedef otb::ImageIOBase        Superclass;
  typedef itk::SmartPointer<Self> Pointer;
 
  typedef std::vector<std::string> GDALCreationOptionsType;
 
  typedef std::vector<std::pair<int, double>> NoDataListType;
 
  itkNewMacro(Self);
 
  itkTypeMacro(GDALImageIO, otb::ImageIOBase);
 
  itkSetMacro(CompressionLevel, int);
  itkGetMacro(CompressionLevel, int);
 
  itkSetMacro(IsComplex, bool);
  itkGetMacro(IsComplex, bool);
 
  itkSetMacro(IsVectorImage, bool);
  itkGetMacro(IsVectorImage, bool);
 
  itkSetMacro(WriteRPCTags, bool);
  itkGetMacro(WriteRPCTags, bool);
 
 
  void SetOptions(const GDALCreationOptionsType& opts)
  {
    m_CreationOptions = opts;
  }
 
  GDALCreationOptionsType GetOptions(void)
  {
    return m_CreationOptions;
  }
 
  void SetNoDataList(const NoDataListType& noDataList)
  {
    m_NoDataList = noDataList;
  }
 
  void SetOutputImagePixelType(bool isComplexInternalPixelType, bool isVectorImage) override
  {
    this->SetIsComplex(isComplexInternalPixelType);
    this->SetIsVectorImage(isVectorImage);
  }
 
  /*-------- This part of the interface deals with reading data. ------ */
 
  bool CanReadFile(const char*) override;
 
  bool CanStreamRead() override
  {
    return true;
  }
 
  void ReadImageInformation() override;
 
  void Read(void* buffer) override;
 
  virtual void ReadVolume(void* buffer);
 
  bool GetSubDatasetInfo(std::vector<std::string>& names, std::vector<std::string>& desc);
 
  bool GDALPixelTypeIsComplex();
 
  /*-------- This part of the interfaces deals with writing data. ----- */
 
  bool CanWriteFile(const char*) override;
 
  bool CanStreamWrite() override;
 
  void WriteImageInformation() override;
 
  void Write(const void* buffer) override;
 
  bool GetAvailableResolutions(std::vector<unsigned int>& res);
 
  bool GetResolutionInfo(std::vector<unsigned int>& res, std::vector<std::string>& desc);
 
  unsigned int GetOverviewsCount() override;
 
  std::vector<std::string> GetOverviewsInfo() override;
 
  std::string GetGdalPixelTypeAsString() const;
 
  int GetNbBands() const override;
 
  // MetadataSupplierInterface overrides
 
  std::string GetResourceFile(std::string const& s="") const override;
  std::vector<std::string> GetResourceFiles() const override;
 
  std::string GetMetadataValue(std::string const& path, bool& hasValue, int band = -1) const override;
 
  void SetMetadataValue(const char * path, const char * value, int band=-1) override;
 
  void SetEpsgCode(const unsigned int wellKnownCRS);
 
  unsigned int GetNumberOf(std::string const&) const override
  {
    itkExceptionMacro(
        "GetNumberOf() not yet implemented in otbGDALImageIO");
  }
 
  unsigned int GetAttributId(std::string const&, std::string const&) const override
  {
    itkExceptionMacro(
        "GetAttributId() not yet implemented in otbGDALImageIO");
  }
 
protected:
  GDALImageIO();
 
  ~GDALImageIO() override;
 
  void KeywordlistToMetadata(ImageMetadataBase::Keywordlist, int band=-1);
 
  void GDALMetadataToKeywordlist(const char* const* , ImageMetadataBase::Keywordlist &);
 
  void GDALMetadataReadRPC();
 
  void GDALMetadataWriteRPC(GDALDataset*);
 
  void PrintSelf(std::ostream& os, itk::Indent indent) const override;
  void InternalReadImageInformation();
 
  void InternalWriteImageInformation(const void* buffer);
 
  int m_NbBands;
 
  // float **pafimas;
 
  int m_CompressionLevel;
 
  bool m_IsIndexed;
 
  unsigned int m_DatasetNumber;
 
private:
  GDALImageIO(const Self&) = delete;
  void operator=(const Self&) = delete;
 
  std::string GetGdalWriteImageFileName(const std::string& gdalDriverShortName, const std::string& filename) const;
 
  std::string FilenameToGdalDriverShortName(const std::string& name) const;
 
  bool GetOriginFromGMLBox(std::vector<double>& origin);
 
  bool CreationOptionContains(std::string partialOption) const;
 
  void ExportMetadata();
 
  void ImportMetadata();
 
  typedef itk::SmartPointer<GDALDatasetWrapper> GDALDatasetWrapperPointer;
  GDALDatasetWrapperPointer                     m_Dataset;
  unsigned int                                  m_epsgCode;
 
  GDALDataTypeWrapper* m_PxType;
  int m_BytePerPixel;
 
  bool GDALInfoReportCorner(const char* corner_name, double x, double y, double& dfGeoX, double& dfGeoY) const;
 
  bool m_FlagWriteImageInformation;
  bool m_CanStreamWrite;
 
  bool m_IsComplex;
 
  bool m_IsVectorImage;
 
  GDALCreationOptionsType m_CreationOptions;
 
  unsigned int m_NumberOfOverviews;
 
  std::vector<std::pair<unsigned int, unsigned int>> m_OverviewsSize;
 
  unsigned int m_ResolutionFactor;
 
  std::vector<unsigned int> m_OriginalDimensions;
 
  bool m_WriteRPCTags;
 
 
  NoDataListType m_NoDataList;
};
 
} // end namespace otb
 
#endif // otbGDALImageIO_h