otbGDALImageIO.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2019 Centre National d'Etudes Spatiales (CNES)
 * Copyright (C) 2018 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 "OTBIOGDALExport.h"

namespace otb
{
class GDALDatasetWrapper;
class GDALDataTypeWrapper;

class OTBIOGDAL_EXPORT GDALImageIO : public otb::ImageIOBase
{
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;

  itkGetMacro(NbBands, int);

protected:
  GDALImageIO();

  ~GDALImageIO() override;

  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;

  typedef itk::SmartPointer<GDALDatasetWrapper> GDALDatasetWrapperPointer;
  GDALDatasetWrapperPointer m_Dataset;

  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