api/master/qgsgdalutils_8cpp_source.html

/***************************************************************************

                             qgsgdalutils.cpp

                             ----------------

    begin                : September 2018

    copyright            : (C) 2018 Even Rouault

    email                : even.rouault at spatialys.com

 ***************************************************************************

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 *                                                                         *

 ***************************************************************************/


#include "qgsgdalutils.h"


#include "qgscoordinatereferencesystem.h"

#include "qgslogger.h"

#include "qgsmessagelog.h"

#include "qgsnetworkaccessmanager.h"

#include "qgsrasterblock.h"

#include "qgssettingsentryimpl.h"


#include <QString>


using namespace Qt::StringLiterals;


#define CPL_SUPRESS_CPLUSPLUS //#spellok

#include "gdal.h"

#include "gdalwarper.h"

#include "cpl_string.h"


#include <QNetworkProxy>

#include <QString>

#include <QImage>

#include <QFileInfo>

#include <mutex>


QgsGdalOption QgsGdalOption::fromXmlNode( const CPLXMLNode *node )

{

  if ( node->eType != CXT_Element || !EQUAL( node->pszValue, "Option" ) )

    return {};


  const QString optionName( CPLGetXMLValue( node, "name", nullptr ) );

  if ( optionName.isEmpty() )

    return {};


  QgsGdalOption option;

  option.name = optionName;


  option.description = QString( CPLGetXMLValue( node, "description", nullptr ) );

  option.scope = QString( CPLGetXMLValue( node, "scope", nullptr ) );


  option.type = QgsGdalOption::Type::Text;


  const char *pszType = CPLGetXMLValue( node, "type", nullptr );

  const char *pszDefault = CPLGetXMLValue( node, "default", nullptr );

  if ( pszType && EQUAL( pszType, "string-select" ) )

  {

    option.type = QgsGdalOption::Type::Select;

    for ( auto psOption = node->psChild; psOption != nullptr; psOption = psOption->psNext )

    {

      if ( psOption->eType != CXT_Element || !EQUAL( psOption->pszValue, "Value" ) || !psOption->psChild )

      {

        continue;

      }

      option.options << psOption->psChild->pszValue;

    }

    option.defaultValue = pszDefault ? QString( pszDefault ) : option.options.value( 0 );

    return option;

  }

  else if ( pszType && EQUAL( pszType, "boolean" ) )

  {

    option.type = QgsGdalOption::Type::Boolean;

    option.defaultValue = pszDefault ? QString( pszDefault ) : u"YES"_s;

    return option;

  }

  else if ( pszType && EQUAL( pszType, "string" ) )

  {

    option.type = QgsGdalOption::Type::Text;

    if ( pszDefault )

      option.defaultValue = QString( pszDefault );

    return option;

  }

  else if ( pszType && ( EQUAL( pszType, "int" ) || EQUAL( pszType, "integer" ) ) )

  {

    option.type = QgsGdalOption::Type::Int;

    if ( pszDefault )

    {

      bool ok = false;

      const int defaultInt = QString( pszDefault ).toInt( &ok );

      if ( ok )

        option.defaultValue = defaultInt;

    }


    if ( const char *pszMin = CPLGetXMLValue( node, "min", nullptr ) )

    {

      bool ok = false;

      const int minInt = QString( pszMin ).toInt( &ok );

      if ( ok )

        option.minimum = minInt;

    }

    if ( const char *pszMax = CPLGetXMLValue( node, "max", nullptr ) )

    {

      bool ok = false;

      const int maxInt = QString( pszMax ).toInt( &ok );

      if ( ok )

        option.maximum = maxInt;

    }

    return option;

  }

  else if ( pszType && ( EQUAL( pszType, "double" ) || EQUAL( pszType, "float" ) ) )

  {

    option.type = QgsGdalOption::Type::Double;

    if ( pszDefault )

    {

      bool ok = false;

      const double defaultDouble = QString( pszDefault ).toDouble( &ok );

      if ( ok )

        option.defaultValue = defaultDouble;

    }


    if ( const char *pszMin = CPLGetXMLValue( node, "min", nullptr ) )

    {

      bool ok = false;

      const double minDouble = QString( pszMin ).toDouble( &ok );

      if ( ok )

        option.minimum = minDouble;

    }

    if ( const char *pszMax = CPLGetXMLValue( node, "max", nullptr ) )

    {

      bool ok = false;

      const double maxDouble = QString( pszMax ).toDouble( &ok );

      if ( ok )

        option.maximum = maxDouble;

    }

    return option;

  }


  QgsDebugError( u"Unhandled GDAL option type: %1"_s.arg( pszType ) );

  return {};

}


QList<QgsGdalOption> QgsGdalOption::optionsFromXml( const CPLXMLNode *node )

{

  QList< QgsGdalOption > options;

  for ( auto psItem = node->psChild; psItem != nullptr; psItem = psItem->psNext )

  {

    const QgsGdalOption option = fromXmlNode( psItem );

    if ( option.type == QgsGdalOption::Type::Invalid )

      continue;


    options << option;

  }

  return options;

}


//

// QgsGdalUtils

//


bool QgsGdalUtils::supportsRasterCreate( GDALDriverH driver )

{

  const QString driverShortName = GDALGetDriverShortName( driver );

  if ( driverShortName == "SQLite"_L1 || driverShortName == "PDF"_L1 )

  {

    // it supports Create() but only for vector side

    return false;

  }

  return GDALGetMetadataItem( driver, GDAL_DCAP_CREATE, nullptr ) && GDALGetMetadataItem( driver, GDAL_DCAP_RASTER, nullptr );

}


gdal::dataset_unique_ptr QgsGdalUtils::createSingleBandMemoryDataset( GDALDataType dataType, const QgsRectangle &extent, int width, int height, const QgsCoordinateReferenceSystem &crs )

{

  return createMultiBandMemoryDataset( dataType, 1, extent, width, height, crs );

}


gdal::dataset_unique_ptr QgsGdalUtils::createMultiBandMemoryDataset( GDALDataType dataType, int bands, const QgsRectangle &extent, int width, int height, const QgsCoordinateReferenceSystem &crs )

{

  GDALDriverH hDriverMem = GDALGetDriverByName( "MEM" );

  if ( !hDriverMem )

  {

    return gdal::dataset_unique_ptr();

  }


  gdal::dataset_unique_ptr hSrcDS( GDALCreate( hDriverMem, "", width, height, bands, dataType, nullptr ) );


  const double cellSizeX = extent.width() / width;

  const double cellSizeY = extent.height() / height;

  double geoTransform[6];

  geoTransform[0] = extent.xMinimum();

  geoTransform[1] = cellSizeX;

  geoTransform[2] = 0;

  geoTransform[3] = extent.yMinimum() + ( cellSizeY * height );

  geoTransform[4] = 0;

  geoTransform[5] = -cellSizeY;


  GDALSetProjection( hSrcDS.get(), crs.toWkt( Qgis::CrsWktVariant::PreferredGdal ).toLatin1().constData() );

  GDALSetGeoTransform( hSrcDS.get(), geoTransform );

  return hSrcDS;

}


gdal::dataset_unique_ptr QgsGdalUtils::createSingleBandTiffDataset( const QString &filename, GDALDataType dataType, const QgsRectangle &extent, int width, int height, const QgsCoordinateReferenceSystem &crs )

{

  const double cellSizeX = extent.width() / width;

  const double cellSizeY = extent.height() / height;

  double geoTransform[6];

  geoTransform[0] = extent.xMinimum();

  geoTransform[1] = cellSizeX;

  geoTransform[2] = 0;

  geoTransform[3] = extent.yMinimum() + ( cellSizeY * height );

  geoTransform[4] = 0;

  geoTransform[5] = -cellSizeY;


  GDALDriverH hDriver = GDALGetDriverByName( "GTiff" );

  if ( !hDriver )

  {

    return gdal::dataset_unique_ptr();

  }


  // Create the output file.

  gdal::dataset_unique_ptr hDstDS( GDALCreate( hDriver, filename.toUtf8().constData(), width, height, 1, dataType, nullptr ) );

  if ( !hDstDS )

  {

    return gdal::dataset_unique_ptr();

  }


  // Write out the projection definition.

  GDALSetProjection( hDstDS.get(), crs.toWkt( Qgis::CrsWktVariant::PreferredGdal ).toLatin1().constData() );

  GDALSetGeoTransform( hDstDS.get(), geoTransform );

  return hDstDS;

}


gdal::dataset_unique_ptr QgsGdalUtils::imageToMemoryDataset( const QImage &image )

{

  if ( image.isNull() )

    return nullptr;


  const QRgb *rgb = reinterpret_cast<const QRgb *>( image.constBits() );

  GDALDriverH hDriverMem = GDALGetDriverByName( "MEM" );

  if ( !hDriverMem )

  {

    return nullptr;

  }

  gdal::dataset_unique_ptr hSrcDS( GDALCreate( hDriverMem, "", image.width(), image.height(), 0, GDT_Byte, nullptr ) );


  char **papszOptions = QgsGdalUtils::papszFromStringList(

    QStringList() << u"PIXELOFFSET=%1"_s.arg( sizeof( QRgb ) ) << u"LINEOFFSET=%1"_s.arg( image.bytesPerLine() ) << u"DATAPOINTER=%1"_s.arg( reinterpret_cast< qulonglong >( rgb ) + 2 )

  );

  GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );

  CSLDestroy( papszOptions );


  papszOptions = QgsGdalUtils::papszFromStringList(

    QStringList() << u"PIXELOFFSET=%1"_s.arg( sizeof( QRgb ) ) << u"LINEOFFSET=%1"_s.arg( image.bytesPerLine() ) << u"DATAPOINTER=%1"_s.arg( reinterpret_cast< qulonglong >( rgb ) + 1 )

  );

  GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );

  CSLDestroy( papszOptions );


  papszOptions = QgsGdalUtils::papszFromStringList(

    QStringList() << u"PIXELOFFSET=%1"_s.arg( sizeof( QRgb ) ) << u"LINEOFFSET=%1"_s.arg( image.bytesPerLine() ) << u"DATAPOINTER=%1"_s.arg( reinterpret_cast< qulonglong >( rgb ) )

  );

  GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );

  CSLDestroy( papszOptions );


  papszOptions = QgsGdalUtils::papszFromStringList(

    QStringList() << u"PIXELOFFSET=%1"_s.arg( sizeof( QRgb ) ) << u"LINEOFFSET=%1"_s.arg( image.bytesPerLine() ) << u"DATAPOINTER=%1"_s.arg( reinterpret_cast< qulonglong >( rgb ) + 3 )

  );

  GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );

  CSLDestroy( papszOptions );


  return hSrcDS;

}


gdal::dataset_unique_ptr QgsGdalUtils::blockToSingleBandMemoryDataset( int pixelWidth, int pixelHeight, const QgsRectangle &extent, void *block, GDALDataType dataType )

{

  if ( !block )

    return nullptr;


  GDALDriverH hDriverMem = GDALGetDriverByName( "MEM" );

  if ( !hDriverMem )

    return nullptr;


  const double cellSizeX = extent.width() / pixelWidth;

  const double cellSizeY = extent.height() / pixelHeight;

  double geoTransform[6];

  geoTransform[0] = extent.xMinimum();

  geoTransform[1] = cellSizeX;

  geoTransform[2] = 0;

  geoTransform[3] = extent.yMinimum() + ( cellSizeY * pixelHeight );

  geoTransform[4] = 0;

  geoTransform[5] = -cellSizeY;


  gdal::dataset_unique_ptr hDstDS( GDALCreate( hDriverMem, "", pixelWidth, pixelHeight, 0, dataType, nullptr ) );


  int dataTypeSize = GDALGetDataTypeSizeBytes( dataType );

  char **papszOptions = QgsGdalUtils::papszFromStringList(

    QStringList() << u"PIXELOFFSET=%1"_s.arg( dataTypeSize ) << u"LINEOFFSET=%1"_s.arg( pixelWidth * dataTypeSize ) << u"DATAPOINTER=%1"_s.arg( reinterpret_cast< qulonglong >( block ) )

  );

  GDALAddBand( hDstDS.get(), dataType, papszOptions );

  CSLDestroy( papszOptions );


  GDALSetGeoTransform( hDstDS.get(), geoTransform );


  return hDstDS;

}


gdal::dataset_unique_ptr QgsGdalUtils::blockToSingleBandMemoryDataset( const QgsRectangle &extent, QgsRasterBlock *block )

{

  if ( !block )

    return nullptr;


  gdal::dataset_unique_ptr ret = blockToSingleBandMemoryDataset( block->width(), block->height(), extent, block->bits(), gdalDataTypeFromQgisDataType( block->dataType() ) );

  if ( ret )

  {

    GDALRasterBandH band = GDALGetRasterBand( ret.get(), 1 );

    if ( band )

      GDALSetRasterNoDataValue( band, block->noDataValue() );

  }


  return ret;

}


gdal::dataset_unique_ptr QgsGdalUtils::blockToSingleBandMemoryDataset( double rotation, const QgsPointXY &origin, double gridXSize, double gridYSize, QgsRasterBlock *block )

{

  if ( !block )

    return nullptr;


  GDALDriverH hDriverMem = GDALGetDriverByName( "MEM" );

  if ( !hDriverMem )

    return nullptr;


  const double cellSizeX = gridXSize / block->width();

  const double cellSizeY = gridYSize / block->height();

  double geoTransform[6];

  geoTransform[0] = origin.x();

  geoTransform[1] = cellSizeX * std::cos( rotation );

  geoTransform[2] = cellSizeY * std::sin( rotation );

  geoTransform[3] = origin.y();

  geoTransform[4] = cellSizeX * std::sin( rotation );

  geoTransform[5] = -cellSizeY * std::cos( rotation );


  GDALDataType dataType = gdalDataTypeFromQgisDataType( block->dataType() );

  gdal::dataset_unique_ptr hDstDS( GDALCreate( hDriverMem, "", block->width(), block->height(), 0, dataType, nullptr ) );


  int dataTypeSize = GDALGetDataTypeSizeBytes( dataType );

  char **papszOptions = QgsGdalUtils::papszFromStringList(

    QStringList() << u"PIXELOFFSET=%1"_s.arg( dataTypeSize ) << u"LINEOFFSET=%1"_s.arg( block->width() * dataTypeSize ) << u"DATAPOINTER=%1"_s.arg( reinterpret_cast< qulonglong >( block->bits() ) )

  );

  GDALAddBand( hDstDS.get(), dataType, papszOptions );

  CSLDestroy( papszOptions );


  GDALSetGeoTransform( hDstDS.get(), geoTransform );


  GDALRasterBandH band = GDALGetRasterBand( hDstDS.get(), 1 );

  if ( band )

    GDALSetRasterNoDataValue( band, block->noDataValue() );


  return hDstDS;

}


static bool resampleSingleBandRasterStatic( GDALDatasetH hSrcDS, GDALDatasetH hDstDS, GDALResampleAlg resampleAlg, char **papszOptions )

{

  gdal::warp_options_unique_ptr psWarpOptions( GDALCreateWarpOptions() );

  psWarpOptions->hSrcDS = hSrcDS;

  psWarpOptions->hDstDS = hDstDS;


  psWarpOptions->nBandCount = 1;

  psWarpOptions->panSrcBands = reinterpret_cast< int * >( CPLMalloc( sizeof( int ) * 1 ) );

  psWarpOptions->panDstBands = reinterpret_cast< int * >( CPLMalloc( sizeof( int ) * 1 ) );

  psWarpOptions->panSrcBands[0] = 1;

  psWarpOptions->panDstBands[0] = 1;

  double noDataValue = GDALGetRasterNoDataValue( GDALGetRasterBand( hDstDS, 1 ), nullptr );

  psWarpOptions->padfDstNoDataReal = reinterpret_cast< double * >( CPLMalloc( sizeof( double ) * 1 ) );

  psWarpOptions->padfDstNoDataReal[0] = noDataValue;

  psWarpOptions->padfSrcNoDataReal = reinterpret_cast< double * >( CPLMalloc( sizeof( double ) * 1 ) );

  psWarpOptions->padfSrcNoDataReal[0] = noDataValue;

  psWarpOptions->eResampleAlg = resampleAlg;


  // Establish reprojection transformer.

  psWarpOptions->pTransformerArg = GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, papszOptions );


  if ( !psWarpOptions->pTransformerArg )

  {

    return false;

  }


  psWarpOptions->pfnTransformer = GDALGenImgProjTransform;

  psWarpOptions->papszWarpOptions = CSLSetNameValue( psWarpOptions->papszWarpOptions, "INIT_DEST", "NO_DATA" );


  // Initialize and execute the warp operation.

  bool retVal = false;

  GDALWarpOperation oOperation;

  CPLErr initResult = oOperation.Initialize( psWarpOptions.get() );

  if ( initResult != CE_Failure )

    retVal = oOperation.ChunkAndWarpImage( 0, 0, GDALGetRasterXSize( hDstDS ), GDALGetRasterYSize( hDstDS ) ) == CE_None;

  GDALDestroyGenImgProjTransformer( psWarpOptions->pTransformerArg );

  return retVal;

}


bool QgsGdalUtils::resampleSingleBandRaster( GDALDatasetH hSrcDS, GDALDatasetH hDstDS, GDALResampleAlg resampleAlg, const char *pszCoordinateOperation )

{

  char **papszOptions = nullptr;

  if ( pszCoordinateOperation )

    papszOptions = CSLSetNameValue( papszOptions, "COORDINATE_OPERATION", pszCoordinateOperation );


  bool result = resampleSingleBandRasterStatic( hSrcDS, hDstDS, resampleAlg, papszOptions );

  CSLDestroy( papszOptions );

  return result;

}


bool QgsGdalUtils::resampleSingleBandRaster(

  GDALDatasetH hSrcDS, GDALDatasetH hDstDS, GDALResampleAlg resampleAlg, const QgsCoordinateReferenceSystem &sourceCrs, const QgsCoordinateReferenceSystem &destinationCrs

)

{

  char **papszOptions = nullptr;


  papszOptions = CSLSetNameValue( papszOptions, "SRC_SRS", sourceCrs.toWkt( Qgis::CrsWktVariant::PreferredGdal ).toUtf8().constData() );

  papszOptions = CSLSetNameValue( papszOptions, "DST_SRS", destinationCrs.toWkt( Qgis::CrsWktVariant::PreferredGdal ).toUtf8().constData() );


  bool result = resampleSingleBandRasterStatic( hSrcDS, hDstDS, resampleAlg, papszOptions );

  CSLDestroy( papszOptions );

  return result;

}


QImage QgsGdalUtils::resampleImage( const QImage &image, QSize outputSize, GDALRIOResampleAlg resampleAlg )

{

  const gdal::dataset_unique_ptr srcDS = QgsGdalUtils::imageToMemoryDataset( image );

  if ( !srcDS )

    return QImage();


  GDALRasterIOExtraArg extra;

  INIT_RASTERIO_EXTRA_ARG( extra );

  extra.eResampleAlg = resampleAlg;


  QImage res( outputSize, image.format() );

  if ( res.isNull() )

    return QImage();


  GByte *rgb = reinterpret_cast<GByte *>( res.bits() );


  CPLErr err

    = GDALRasterIOEx( GDALGetRasterBand( srcDS.get(), 1 ), GF_Read, 0, 0, image.width(), image.height(), rgb + 2, outputSize.width(), outputSize.height(), GDT_Byte, sizeof( QRgb ), res.bytesPerLine(), &extra );

  if ( err != CE_None )

  {

    QgsDebugError( u"failed to read red band"_s );

    return QImage();

  }


  err = GDALRasterIOEx( GDALGetRasterBand( srcDS.get(), 2 ), GF_Read, 0, 0, image.width(), image.height(), rgb + 1, outputSize.width(), outputSize.height(), GDT_Byte, sizeof( QRgb ), res.bytesPerLine(), &extra );

  if ( err != CE_None )

  {

    QgsDebugError( u"failed to read green band"_s );

    return QImage();

  }


  err = GDALRasterIOEx( GDALGetRasterBand( srcDS.get(), 3 ), GF_Read, 0, 0, image.width(), image.height(), rgb, outputSize.width(), outputSize.height(), GDT_Byte, sizeof( QRgb ), res.bytesPerLine(), &extra );

  if ( err != CE_None )

  {

    QgsDebugError( u"failed to read blue band"_s );

    return QImage();

  }


  err = GDALRasterIOEx( GDALGetRasterBand( srcDS.get(), 4 ), GF_Read, 0, 0, image.width(), image.height(), rgb + 3, outputSize.width(), outputSize.height(), GDT_Byte, sizeof( QRgb ), res.bytesPerLine(), &extra );

  if ( err != CE_None )

  {

    QgsDebugError( u"failed to read alpha band"_s );

    return QImage();

  }


  return res;

}


QString QgsGdalUtils::helpCreationOptionsFormat( const QString &format )

{

  QString message;


  GDALDriverH myGdalDriver = GDALGetDriverByName( format.toLocal8Bit().constData() );

  if ( myGdalDriver )

  {

    // first report details and help page

    CSLConstList GDALmetadata = GDALGetMetadata( myGdalDriver, nullptr );

    message += "<h3>" + QCoreApplication::translate( "QgsGdalUtils", "Format Details" ) + "</h3>";

    message += "<b>" + QCoreApplication::translate( "QgsGdalUtils", "Extension:" ) + u"</b> %1<br>"_s.arg( CSLFetchNameValue( GDALmetadata, GDAL_DMD_EXTENSION ) );

    message += "<b>"

               + QCoreApplication::translate( "QgsGdalUtils", "Short Name:" )

               + u"</b> %1 / <b>"_s.arg( GDALGetDriverShortName( myGdalDriver ) )

               + QCoreApplication::translate( "QgsGdalUtils", "Long Name:" )

               + u"</b> %2<br>"_s.arg( GDALGetDriverLongName( myGdalDriver ) );

    const QString helpUrl = gdalDocumentationUrlForDriver( myGdalDriver );

    if ( !helpUrl.isEmpty() )

    {

      message += "<b>" + QCoreApplication::translate( "QgsGdalUtils", "Help page:" ) + u"</b> <a href=\"%1\">%1</a>"_s.arg( helpUrl );

    }


    // next get creation options

    // serialize xml and convert it to html

    CPLXMLNode *psCOL = CPLParseXMLString( GDALGetMetadataItem( myGdalDriver, GDAL_DMD_CREATIONOPTIONLIST, "" ) );

    char *pszFormattedXML = CPLSerializeXMLTree( psCOL );

    if ( pszFormattedXML )

    {

      QDomDocument doc;

      if ( doc.setContent( QString( pszFormattedXML ) ) )

      {

        message += "<h3>" + QCoreApplication::translate( "QgsGdalUtils", "Creation Options" ) + "</h3>";

        message += "<dl>";

        QDomNodeList options = doc.elementsByTagName( u"Option"_s );

        for ( int i = 0; i < options.count(); ++i )

        {

          QDomElement element = options.at( i ).toElement();


          const QString optionName = element.attribute( u"name"_s );

          const QString optionType = element.attribute( u"type"_s );

          const QString optionDefault = element.attribute( u"default"_s );

          const QString optionDescription = element.attribute( u"description"_s );

          message

            += u"<dt><b>%1</b> (%2%3)</dt>"_s

                 .arg( optionName.toHtmlEscaped(), optionType.toHtmlEscaped(), optionDefault.isEmpty() ? QString() : ", " + QCoreApplication::translate( "QgsGdalUtils", "default: " ) + optionDefault.toHtmlEscaped() );

          if ( !optionDescription.isEmpty() )

          {

            message += u"<dd>%1</dd>"_s.arg( optionDescription.toHtmlEscaped() );

          }


          // supported values for option

          QDomNodeList nodes = element.elementsByTagName( u"Value"_s );

          if ( !nodes.isEmpty() )

          {

            QStringList values;

            for ( int j = 0; j < nodes.count(); ++j )

            {

              values << nodes.at( j ).toElement().text().toHtmlEscaped();

            }

            message += "<dd><i>" + QCoreApplication::translate( "QgsGdalUtils", "Possible values:" ) + u"</i> %1</dd>"_s.arg( values.join( ", " ) );

          }

        }


        message += "</dl>";

      }

    }

    if ( psCOL )

      CPLDestroyXMLNode( psCOL );

    if ( pszFormattedXML )

      CPLFree( pszFormattedXML );

  }


  return message;

}


char **QgsGdalUtils::papszFromStringList( const QStringList &list )

{

  char **papszRetList = nullptr;

  const auto constList = list;

  for ( const QString &elem : constList )

  {

    papszRetList = CSLAddString( papszRetList, elem.toLocal8Bit().constData() );

  }

  return papszRetList;

}


QString QgsGdalUtils::validateCreationOptionsFormat( const QStringList &creationOptions, const QString &format )

{

  GDALDriverH myGdalDriver = GDALGetDriverByName( format.toLocal8Bit().constData() );

  if ( !myGdalDriver )

    return u"invalid GDAL driver"_s;


  char **papszOptions = papszFromStringList( creationOptions );

  // get error string?

  const int ok = GDALValidateCreationOptions( myGdalDriver, papszOptions );

  CSLDestroy( papszOptions );


  if ( !ok )

    return u"Failed GDALValidateCreationOptions() test"_s;

  return QString();

}


static void setRPCTransformerOptions( GDALDatasetH hSrcDS, char ***opts )

{

  if ( GDALGetMetadata( hSrcDS, "RPC" ) )

  {

    // Some RPC may contain a HEIGHT_DEFAULT entry, that must be used as the

    // best default for RPC_HEIGHT. See https://github.com/OSGeo/gdal/pull/11989

    const char *heightStr = GDALGetMetadataItem( hSrcDS, "HEIGHT_DEFAULT", "RPC" );

    if ( !heightStr )

    {

      // Otherwise well-behaved RPC should have height offset which is also

      // a resaonable default for RPC_HEIGHT.

      heightStr = GDALGetMetadataItem( hSrcDS, "HEIGHT_OFF", "RPC" );

    }

    if ( heightStr )

      *opts = CSLAddNameValue( *opts, "RPC_HEIGHT", heightStr );

  }

}


GDALDatasetH QgsGdalUtils::rpcAwareAutoCreateWarpedVrt( GDALDatasetH hSrcDS, const char *pszSrcWKT, const char *pszDstWKT, GDALResampleAlg eResampleAlg, double dfMaxError, const GDALWarpOptions *psOptionsIn )

{

  char **opts = nullptr;

  setRPCTransformerOptions( hSrcDS, &opts );

  GDALDatasetH hRetDS = GDALAutoCreateWarpedVRTEx( hSrcDS, pszSrcWKT, pszDstWKT, eResampleAlg, dfMaxError, psOptionsIn, opts );

  CSLDestroy( opts );

  return hRetDS;

}


void *QgsGdalUtils::rpcAwareCreateTransformer( GDALDatasetH hSrcDS, GDALDatasetH hDstDS, char **papszOptions )

{

  char **opts = CSLDuplicate( papszOptions );

  setRPCTransformerOptions( hSrcDS, &opts );

  void *transformer = GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, opts );

  CSLDestroy( opts );

  return transformer;

}


GDALDataType QgsGdalUtils::gdalDataTypeFromQgisDataType( Qgis::DataType dataType )

{

  switch ( dataType )

  {

    case Qgis::DataType::UnknownDataType:

      return GDALDataType::GDT_Unknown;

      break;

    case Qgis::DataType::Byte:

      return GDALDataType::GDT_Byte;

      break;

    case Qgis::DataType::Int8:

#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 7, 0 )

      return GDALDataType::GDT_Int8;

#else

      return GDALDataType::GDT_Unknown;

#endif

      break;

    case Qgis::DataType::UInt16:

      return GDALDataType::GDT_UInt16;

      break;

    case Qgis::DataType::Int16:

      return GDALDataType::GDT_Int16;

      break;

    case Qgis::DataType::UInt32:

      return GDALDataType::GDT_UInt32;

      break;

    case Qgis::DataType::Int32:

      return GDALDataType::GDT_Int32;

      break;

    case Qgis::DataType::Float32:

      return GDALDataType::GDT_Float32;

      break;

    case Qgis::DataType::Float64:

      return GDALDataType::GDT_Float64;

      break;

    case Qgis::DataType::CInt16:

      return GDALDataType::GDT_CInt16;

      break;

    case Qgis::DataType::CInt32:

      return GDALDataType::GDT_CInt32;

      break;

    case Qgis::DataType::CFloat32:

      return GDALDataType::GDT_CFloat32;

      break;

    case Qgis::DataType::CFloat64:

      return GDALDataType::GDT_CFloat64;

      break;

    case Qgis::DataType::ARGB32:

    case Qgis::DataType::ARGB32_Premultiplied:

      return GDALDataType::GDT_Unknown;

      break;

  };


  return GDALDataType::GDT_Unknown;

}


GDALResampleAlg QgsGdalUtils::gdalResamplingAlgorithm( Qgis::RasterResamplingMethod method )

{

  GDALResampleAlg eResampleAlg = GRA_NearestNeighbour;

  switch ( method )

  {

    case Qgis::RasterResamplingMethod::Nearest:

    case Qgis::RasterResamplingMethod::Gauss: // Gauss not available in GDALResampleAlg

      eResampleAlg = GRA_NearestNeighbour;

      break;


    case Qgis::RasterResamplingMethod::Bilinear:

      eResampleAlg = GRA_Bilinear;

      break;


    case Qgis::RasterResamplingMethod::Cubic:

      eResampleAlg = GRA_Cubic;

      break;


    case Qgis::RasterResamplingMethod::CubicSpline:

      eResampleAlg = GRA_CubicSpline;

      break;


    case Qgis::RasterResamplingMethod::Lanczos:

      eResampleAlg = GRA_Lanczos;

      break;


    case Qgis::RasterResamplingMethod::Average:

      eResampleAlg = GRA_Average;

      break;


    case Qgis::RasterResamplingMethod::Mode:

      eResampleAlg = GRA_Mode;

      break;

  }


  return eResampleAlg;

}


#ifndef QT_NO_NETWORKPROXY


void QgsGdalUtils::setupProxy()

{

  // Check proxy configuration, they are application level but

  // instead of adding an API and complex signal/slot connections

  // given the limited cost of checking them on every provider instantiation

  // we can do it here so that new settings are applied whenever a new layer

  // is created.

  // Check that proxy is enabled

  if ( QgsNetworkAccessManager::settingsProxyEnabled->value() )

  {

    // Get the first configured proxy

    QList<QNetworkProxy> proxies( QgsNetworkAccessManager::instance()->proxyFactory()->queryProxy() );

    if ( !proxies.isEmpty() )

    {

      const QNetworkProxy proxy( proxies.first() );

      // TODO/FIXME: check excludes (the GDAL config options are global, we need a per-connection config option)


      const QString proxyHost( proxy.hostName() );

      const quint16 proxyPort( proxy.port() );


      const QString proxyUser( proxy.user() );

      const QString proxyPassword( proxy.password() );


      if ( !proxyHost.isEmpty() )

      {

        QString connection( proxyHost );

        if ( proxyPort )

        {

          connection += ':' + QString::number( proxyPort );

        }

        CPLSetConfigOption( "GDAL_HTTP_PROXY", connection.toUtf8() );

        if ( !proxyUser.isEmpty() )

        {

          QString credentials( proxyUser );

          if ( !proxyPassword.isEmpty() )

          {

            credentials += ':' + proxyPassword;

          }

          CPLSetConfigOption( "GDAL_HTTP_PROXYUSERPWD", credentials.toUtf8() );

        }

      }

    }

  }

}


bool QgsGdalUtils::pathIsCheapToOpen( const QString &path, int smallFileSizeLimit )

{

  const QFileInfo info( path );

  const long long size = info.size();


  // if size could not be determined, safest to flag path as expensive

  if ( size == 0 )

    return false;


  const QString suffix = info.suffix().toLower();

  static const QStringList sFileSizeDependentExtensions { u"xlsx"_s, u"ods"_s, u"csv"_s };

  if ( sFileSizeDependentExtensions.contains( suffix ) )

  {

    // path corresponds to a file type which is only cheap to open for small files

    return size < smallFileSizeLimit;

  }


  // treat all other formats as expensive.

  // TODO -- flag formats which only require a quick header parse as cheap

  return false;

}


QStringList QgsGdalUtils::multiLayerFileExtensions()

{

#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 4, 0 )

  // get supported extensions

  static std::once_flag initialized;

  static QStringList SUPPORTED_DB_LAYERS_EXTENSIONS;

  std::call_once( initialized, [] {

    // iterate through all of the supported drivers, adding the corresponding file extensions for

    // types which advertise multilayer support

    GDALDriverH driver = nullptr;


    QSet< QString > extensions;


    for ( int i = 0; i < GDALGetDriverCount(); ++i )

    {

      driver = GDALGetDriver( i );

      if ( !driver )

      {

        QgsLogger::warning( "unable to get driver " + QString::number( i ) );

        continue;

      }


      bool isMultiLayer = false;

      if ( QString( GDALGetMetadataItem( driver, GDAL_DCAP_RASTER, nullptr ) ) == "YES"_L1 )

      {

        if ( GDALGetMetadataItem( driver, GDAL_DMD_SUBDATASETS, nullptr ) )

        {

          isMultiLayer = true;

        }

      }

      if ( !isMultiLayer && QString( GDALGetMetadataItem( driver, GDAL_DCAP_VECTOR, nullptr ) ) == "YES"_L1 )

      {

        if ( GDALGetMetadataItem( driver, GDAL_DCAP_MULTIPLE_VECTOR_LAYERS, nullptr ) )

        {

          isMultiLayer = true;

        }

      }


      if ( !isMultiLayer )

        continue;


      const QString driverExtensions = GDALGetMetadataItem( driver, GDAL_DMD_EXTENSIONS, "" );

      if ( driverExtensions.isEmpty() )

        continue;


      const QStringList splitExtensions = driverExtensions.split( ' ', Qt::SkipEmptyParts );


      for ( const QString &ext : splitExtensions )

      {

        // maintain older behavior -- don't always expose tiff files as containers

        if ( ext == "tif"_L1 || ext == "tiff"_L1 )

          continue;


        extensions.insert( ext );

      }

    }


    SUPPORTED_DB_LAYERS_EXTENSIONS = QStringList( extensions.constBegin(), extensions.constEnd() );

  } );

  return SUPPORTED_DB_LAYERS_EXTENSIONS;


#else

  static const QStringList SUPPORTED_DB_LAYERS_EXTENSIONS { u"gpkg"_s, u"sqlite"_s, u"db"_s,  u"gdb"_s, u"kml"_s, u"kmz"_s, u"osm"_s, u"mdb"_s, u"accdb"_s,   u"xls"_s,

                                                            u"xlsx"_s, u"ods"_s,    u"gpx"_s, u"pdf"_s, u"pbf"_s, u"vrt"_s, u"nc"_s,  u"dxf"_s, u"shp.zip"_s, u"gdb.zip"_s };

  return SUPPORTED_DB_LAYERS_EXTENSIONS;

#endif

}


QString QgsGdalUtils::vsiPrefixForPath( const QString &path )

{

  const QStringList vsiPrefixes = QgsGdalUtils::vsiArchivePrefixes();


  const thread_local QRegularExpression vsiRx( u"^(/vsi.+?/)"_s, QRegularExpression::PatternOption::CaseInsensitiveOption );

  const QRegularExpressionMatch vsiMatch = vsiRx.match( path );

  if ( vsiMatch.hasMatch() )

    return vsiMatch.captured( 1 );


  if ( path.endsWith( ".shp.zip"_L1, Qt::CaseInsensitive ) || path.endsWith( ".gdb.zip"_L1, Qt::CaseInsensitive ) )

  {

    // GDAL 3.1 Shapefile/OpenFileGDB drivers directly handle .shp.zip and .gdb.zip files

    if ( GDALIdentifyDriverEx( path.toUtf8().constData(), GDAL_OF_VECTOR, nullptr, nullptr ) )

      return QString();

    return u"/vsizip/"_s;

  }

  else if ( path.endsWith( ".zip"_L1, Qt::CaseInsensitive ) )

  {

    // GTFS driver directly handles .zip files

    const char *const apszAllowedDrivers[] = { "GTFS", nullptr };

    if ( GDALIdentifyDriverEx( path.toUtf8().constData(), GDAL_OF_VECTOR, apszAllowedDrivers, nullptr ) )

      return QString();

    return u"/vsizip/"_s;

  }

  else if ( path.endsWith( ".tar"_L1, Qt::CaseInsensitive ) || path.endsWith( ".tar.gz"_L1, Qt::CaseInsensitive ) || path.endsWith( ".tgz"_L1, Qt::CaseInsensitive ) )

    return u"/vsitar/"_s;

  else if ( path.endsWith( ".gz"_L1, Qt::CaseInsensitive ) )

    return u"/vsigzip/"_s;

#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 7, 0 )

  else if ( vsiPrefixes.contains( u"/vsi7z/"_s ) &&

            ( path.endsWith( ".7z"_L1, Qt::CaseInsensitive ) ||

              path.endsWith( ".lpk"_L1, Qt::CaseInsensitive ) ||

              path.endsWith( ".lpkx"_L1, Qt::CaseInsensitive ) ||

              path.endsWith( ".mpk"_L1, Qt::CaseInsensitive ) ||

              path.endsWith( ".mpkx"_L1, Qt::CaseInsensitive ) ) )

    return u"/vsi7z/"_s;

  else if ( vsiPrefixes.contains( u"/vsirar/"_s ) && path.endsWith( ".rar"_L1, Qt::CaseInsensitive ) )

    return u"/vsirar/"_s;

#endif


  return QString();

}


QStringList QgsGdalUtils::vsiArchivePrefixes()

{

  QStringList res {

    u"/vsizip/"_s,

    u"/vsitar/"_s,

    u"/vsigzip/"_s,

  };

#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 7, 0 )

  res.append( u"/vsi7z/"_s );

  res.append( u"/vsirar/"_s );

#endif

  return res;

}


QList<QgsGdalUtils::VsiNetworkFileSystemDetails> QgsGdalUtils::vsiNetworkFileSystems()

{

  // get supported extensions

  static std::once_flag initialized;

  static QList<QgsGdalUtils::VsiNetworkFileSystemDetails> VSI_FILE_SYSTEM_DETAILS;

  std::call_once( initialized, [] {

    if ( char **papszPrefixes = VSIGetFileSystemsPrefixes() )

    {

      for ( int i = 0; papszPrefixes[i]; i++ )

      {

        QgsGdalUtils::VsiNetworkFileSystemDetails details;

        details.identifier = QString( papszPrefixes[i] );

        if ( details.identifier.startsWith( '/' ) )

          details.identifier = details.identifier.mid( 1 );

        if ( details.identifier.endsWith( '/' ) )

          details.identifier.chop( 1 );


        if ( details.identifier == "vsicurl"_L1 )

          details.name = QObject::tr( "HTTP/HTTPS/FTP" );

        else if ( details.identifier == "vsis3"_L1 )

          details.name = QObject::tr( "AWS S3" );

        else if ( details.identifier == "vsigs"_L1 )

          details.name = QObject::tr( "Google Cloud Storage" );

        else if ( details.identifier == "vsiaz"_L1 )

          details.name = QObject::tr( "Microsoft Azure Blob" );

        else if ( details.identifier == "vsiadls"_L1 )

          details.name = QObject::tr( "Microsoft Azure Data Lake Storage" );

        else if ( details.identifier == "vsioss"_L1 )

          details.name = QObject::tr( "Alibaba Cloud OSS" );

        else if ( details.identifier == "vsiswift"_L1 )

          details.name = QObject::tr( "OpenStack Swift Object Storage" );

        else if ( details.identifier == "vsihdfs"_L1 )

          details.name = QObject::tr( "Hadoop File System" );

        else

          continue;

        VSI_FILE_SYSTEM_DETAILS.append( details );

      }


      CSLDestroy( papszPrefixes );

    }

  } );


  return VSI_FILE_SYSTEM_DETAILS;

}


bool QgsGdalUtils::isVsiArchivePrefix( const QString &prefix )

{

  const QStringList prefixes = vsiArchivePrefixes();

  for ( const QString &archivePrefix : prefixes )

  {

    // catch chained prefixes, eg "/vsizip/vsicurl"

    if ( prefix.contains( archivePrefix ) )

      return true;

  }

  return false;

}


QStringList QgsGdalUtils::vsiArchiveFileExtensions()

{

  QStringList res {

    u".zip"_s,

    u".tar"_s,

    u".tar.gz"_s,

    u".tgz"_s,

    u".gz"_s,

  };

#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 7, 0 )

  res.append( { u".7z"_s, u".lpk"_s, u".lpkx"_s, u".mpk"_s, u".mpkx"_s, u".rar"_s } );

#endif

  return res;

}


bool QgsGdalUtils::isVsiArchiveFileExtension( const QString &extension )

{

  const QString extWithDot = extension.startsWith( '.' ) ? extension : ( '.' + extension );

  return vsiArchiveFileExtensions().contains( extWithDot.toLower() );

}


Qgis::VsiHandlerType QgsGdalUtils::vsiHandlerType( const QString &prefix )

{

  if ( prefix.isEmpty() )

    return Qgis::VsiHandlerType::Invalid;


  QString vsiPrefix = prefix;

  if ( vsiPrefix.startsWith( '/' ) )

    vsiPrefix = vsiPrefix.mid( 1 );

  if ( vsiPrefix.endsWith( '/' ) )

    vsiPrefix.chop( 1 );


  if ( !vsiPrefix.startsWith( "vsi"_L1 ) )

    return Qgis::VsiHandlerType::Invalid;


  if ( vsiPrefix == "vsizip"_L1 || vsiPrefix == "vsigzip"_L1 || vsiPrefix == "vsitar"_L1 || vsiPrefix == "vsi7z"_L1 || vsiPrefix == "vsirar"_L1 )

    return Qgis::VsiHandlerType::Archive;


  else if ( vsiPrefix == "vsicurl"_L1 || vsiPrefix == "vsicurl_streaming"_L1 )

    return Qgis::VsiHandlerType::Network;


  else if ( vsiPrefix == "vsis3"_L1

            || vsiPrefix == "vsicurl_streaming"_L1

            || vsiPrefix == "vsigs"_L1

            || vsiPrefix == "vsigs_streaming"_L1

            || vsiPrefix == "vsiaz"_L1

            || vsiPrefix == "vsiaz_streaming"_L1

            || vsiPrefix == "vsiadls"_L1

            || vsiPrefix == "vsioss"_L1

            || vsiPrefix == "vsioss_streaming"_L1

            || vsiPrefix == "vsiswift"_L1

            || vsiPrefix == "vsiswift_streaming"_L1

            || vsiPrefix == "vsihdfs"_L1

            || vsiPrefix == "vsiwebhdfs"_L1 )

    return Qgis::VsiHandlerType::Cloud;


  else if ( vsiPrefix == "vsimem"_L1 )

    return Qgis::VsiHandlerType::Memory;


  return Qgis::VsiHandlerType::Other;

}


bool QgsGdalUtils::vrtMatchesLayerType( const QString &vrtPath, Qgis::LayerType type )

{

  CPLPushErrorHandler( CPLQuietErrorHandler );

  CPLErrorReset();

  GDALDriverH hDriver = nullptr;


  switch ( type )

  {

    case Qgis::LayerType::Vector:

      hDriver = GDALIdentifyDriverEx( vrtPath.toUtf8().constData(), GDAL_OF_VECTOR, nullptr, nullptr );

      break;


    case Qgis::LayerType::Raster:

      hDriver = GDALIdentifyDriverEx( vrtPath.toUtf8().constData(), GDAL_OF_RASTER, nullptr, nullptr );

      break;


    case Qgis::LayerType::Plugin:

    case Qgis::LayerType::Mesh:

    case Qgis::LayerType::VectorTile:

    case Qgis::LayerType::Annotation:

    case Qgis::LayerType::PointCloud:

    case Qgis::LayerType::Group:

    case Qgis::LayerType::TiledScene:

      break;

  }


  CPLPopErrorHandler();

  return static_cast< bool >( hDriver );

}


QString QgsGdalUtils::gdalDocumentationUrlForDriver( GDALDriverH hDriver )

{

  if ( hDriver )

  {

    const QString gdalDriverHelpTopic = GDALGetMetadataItem( hDriver, GDAL_DMD_HELPTOPIC, nullptr ); // e.g. "drivers/vector/ili.html"

    if ( !gdalDriverHelpTopic.isEmpty() )

      return u"https://gdal.org/%1"_s.arg( gdalDriverHelpTopic );

  }

  return QString();

}


bool QgsGdalUtils::supportsMrfLercCompression()

{

  GDALDriverH hDriver = GDALGetDriverByName( "MRF" );

  if ( hDriver )

  {

    const char *creationOptions = GDALGetMetadataItem( hDriver, GDAL_DMD_CREATIONOPTIONLIST, NULL );

    if ( creationOptions && strstr( creationOptions, "LERC" ) )

    {

      return true;

    }

  }

  return false;

}


bool QgsGdalUtils::supportsTiffLercCompression()

{

  GDALDriverH hDriver = GDALGetDriverByName( "GTiff" );

  if ( hDriver )

  {

    const char *creationOptions = GDALGetMetadataItem( hDriver, GDAL_DMD_CREATIONOPTIONLIST, NULL );

    if ( creationOptions && strstr( creationOptions, "LERC" ) )

    {

      return true;

    }

  }

  return false;

}


bool QgsGdalUtils::applyVsiCredentialOptions( const QString &prefix, const QString &path, const QVariantMap &options )

{

  QString vsiPrefix = prefix;

  if ( !vsiPrefix.startsWith( '/' ) )

    vsiPrefix.prepend( '/' );

  if ( !vsiPrefix.endsWith( '/' ) )

    vsiPrefix.append( '/' );


  QString vsiPath = path;

  if ( vsiPath.endsWith( '/' ) )

    vsiPath.chop( 1 );


  const QString bucket = vsiPrefix + vsiPath;


  for ( auto it = options.constBegin(); it != options.constEnd(); ++it )

  {

#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 6, 0 )

    VSISetPathSpecificOption( bucket.toUtf8().constData(), it.key().toUtf8().constData(), it.value().toString().toUtf8().constData() );

#elif GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION( 3, 5, 0 )

    VSISetCredential( bucket.toUtf8().constData(), it.key().toUtf8().constData(), it.value().toString().toUtf8().constData() );

#else

    ( void ) bucket;

    QgsMessageLog::logMessage( QObject::tr( "Cannot use VSI credential options on GDAL versions earlier than 3.5" ), u"GDAL"_s, Qgis::MessageLevel::Critical );

    return false;

#endif

  }

  return true;

}


#endif


QgsGdalProgressAdapter::QgsGdalProgressAdapter( QgsFeedback *feedback, double startPercentage, double endPercentage )

  : mFeedback( feedback )

  , mStartPercentage( startPercentage )

  , mEndPercentage( endPercentage )

{}


/* static */


int CPL_STDCALL QgsGdalProgressAdapter::progressCallback( double dfComplete, const char * /* pszMessage */, void *pProgressArg )

{

  const QgsGdalProgressAdapter *adapter = static_cast<QgsGdalProgressAdapter *>( pProgressArg );


  if ( QgsFeedback *feedback = adapter->mFeedback )

  {

    feedback->setProgress( adapter->mStartPercentage + ( adapter->mEndPercentage - adapter->mStartPercentage ) * dfComplete );


    if ( feedback->isCanceled() )

      return false;

  }


  return true;

}


Qgis::VsiHandlerType
VsiHandlerType
GDAL VSI handler types.
Definition qgis.h:6564

Qgis::VsiHandlerType::Memory
@ Memory
In-memory types (e.g. vsimem).
Definition qgis.h:6569

Qgis::VsiHandlerType::Invalid
@ Invalid
Invalid type, i.e. not a valid VSI handler.
Definition qgis.h:6565

Qgis::VsiHandlerType::Other
@ Other
All other types.
Definition qgis.h:6570

Qgis::VsiHandlerType::Cloud
@ Cloud
Specific cloud provider types (e.g. vsis3).
Definition qgis.h:6568

Qgis::VsiHandlerType::Archive
@ Archive
File archive type (e.g. vsizip).
Definition qgis.h:6566

Qgis::VsiHandlerType::Network
@ Network
Generic network types (e.g. vsicurl).
Definition qgis.h:6567

Qgis::RasterResamplingMethod
RasterResamplingMethod
Resampling method for raster provider-level resampling.
Definition qgis.h:1653

Qgis::RasterResamplingMethod::Lanczos
@ Lanczos
Lanczos windowed sinc interpolation (6x6 kernel).
Definition qgis.h:1658

Qgis::RasterResamplingMethod::Nearest
@ Nearest
Nearest-neighbour resampling.
Definition qgis.h:1654

Qgis::RasterResamplingMethod::Mode
@ Mode
Mode (selects the value which appears most often of all the sampled points).
Definition qgis.h:1660

Qgis::RasterResamplingMethod::Bilinear
@ Bilinear
Bilinear (2x2 kernel) resampling.
Definition qgis.h:1655

Qgis::RasterResamplingMethod::Average
@ Average
Average resampling.
Definition qgis.h:1659

Qgis::RasterResamplingMethod::CubicSpline
@ CubicSpline
Cubic B-Spline Approximation (4x4 kernel).
Definition qgis.h:1657

Qgis::RasterResamplingMethod::Cubic
@ Cubic
Cubic Convolution Approximation (4x4 kernel) resampling.
Definition qgis.h:1656

Qgis::RasterResamplingMethod::Gauss
@ Gauss
Gauss blurring.
Definition qgis.h:1661

Qgis::Critical
@ Critical
Critical/error message.
Definition qgis.h:163

Qgis::DataType
DataType
Raster data types.
Definition qgis.h:413

Qgis::DataType::CInt32
@ CInt32
Complex Int32.
Definition qgis.h:424

Qgis::DataType::Float32
@ Float32
Thirty two bit floating point (float).
Definition qgis.h:421

Qgis::DataType::CFloat64
@ CFloat64
Complex Float64.
Definition qgis.h:426

Qgis::DataType::Int16
@ Int16
Sixteen bit signed integer (qint16).
Definition qgis.h:418

Qgis::DataType::ARGB32_Premultiplied
@ ARGB32_Premultiplied
Color, alpha, red, green, blue, 4 bytes the same as QImage::Format_ARGB32_Premultiplied.
Definition qgis.h:428

Qgis::DataType::Int8
@ Int8
Eight bit signed integer (qint8) (added in QGIS 3.30).
Definition qgis.h:416

Qgis::DataType::UInt16
@ UInt16
Sixteen bit unsigned integer (quint16).
Definition qgis.h:417

Qgis::DataType::Byte
@ Byte
Eight bit unsigned integer (quint8).
Definition qgis.h:415

Qgis::DataType::UnknownDataType
@ UnknownDataType
Unknown or unspecified type.
Definition qgis.h:414

Qgis::DataType::ARGB32
@ ARGB32
Color, alpha, red, green, blue, 4 bytes the same as QImage::Format_ARGB32.
Definition qgis.h:427

Qgis::DataType::Int32
@ Int32
Thirty two bit signed integer (qint32).
Definition qgis.h:420

Qgis::DataType::Float64
@ Float64
Sixty four bit floating point (double).
Definition qgis.h:422

Qgis::DataType::CFloat32
@ CFloat32
Complex Float32.
Definition qgis.h:425

Qgis::DataType::CInt16
@ CInt16
Complex Int16.
Definition qgis.h:423

Qgis::DataType::UInt32
@ UInt32
Thirty two bit unsigned integer (quint32).
Definition qgis.h:419

Qgis::LayerType
LayerType
Types of layers that can be added to a map.
Definition qgis.h:206

Qgis::LayerType::Group
@ Group
Composite group layer. Added in QGIS 3.24.
Definition qgis.h:214

Qgis::LayerType::Plugin
@ Plugin
Plugin based layer.
Definition qgis.h:209

Qgis::LayerType::TiledScene
@ TiledScene
Tiled scene layer. Added in QGIS 3.34.
Definition qgis.h:215

Qgis::LayerType::Annotation
@ Annotation
Contains freeform, georeferenced annotations. Added in QGIS 3.16.
Definition qgis.h:212

Qgis::LayerType::Vector
@ Vector
Vector layer.
Definition qgis.h:207

Qgis::LayerType::VectorTile
@ VectorTile
Vector tile layer. Added in QGIS 3.14.
Definition qgis.h:211

Qgis::LayerType::Mesh
@ Mesh
Mesh layer. Added in QGIS 3.2.
Definition qgis.h:210

Qgis::LayerType::Raster
@ Raster
Raster layer.
Definition qgis.h:208

Qgis::LayerType::PointCloud
@ PointCloud
Point cloud layer. Added in QGIS 3.18.
Definition qgis.h:213

Qgis::CrsWktVariant::PreferredGdal
@ PreferredGdal
Preferred format for conversion of CRS to WKT for use with the GDAL library.
Definition qgis.h:2634

QgsCoordinateReferenceSystem
Represents a coordinate reference system (CRS).
Definition qgscoordinatereferencesystem.h:216

QgsCoordinateReferenceSystem::toWkt
QString toWkt(Qgis::CrsWktVariant variant=Qgis::CrsWktVariant::Wkt1Gdal, bool multiline=false, int indentationWidth=4) const
Returns a WKT representation of this CRS.
Definition qgscoordinatereferencesystem.cpp:2088

QgsFeedback
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition qgsfeedback.h:44

QgsGdalOption
Encapsulates the definition of a GDAL configuration option.
Definition qgsgdalutils.h:38

QgsGdalOption::defaultValue
QVariant defaultValue
Default value.
Definition qgsgdalutils.h:66

QgsGdalOption::maximum
QVariant maximum
Maximum acceptable value.
Definition qgsgdalutils.h:72

QgsGdalOption::name
QString name
Option name.
Definition qgsgdalutils.h:54

QgsGdalOption::options
QStringList options
Available choices, for Select options.
Definition qgsgdalutils.h:63

QgsGdalOption::minimum
QVariant minimum
Minimum acceptable value.
Definition qgsgdalutils.h:69

QgsGdalOption::Type::Int
@ Int
Integer option.
Definition qgsgdalutils.h:49

QgsGdalOption::Type::Boolean
@ Boolean
Boolean option.
Definition qgsgdalutils.h:47

QgsGdalOption::Type::Invalid
@ Invalid
Invalid option.
Definition qgsgdalutils.h:45

QgsGdalOption::Type::Text
@ Text
Text option.
Definition qgsgdalutils.h:48

QgsGdalOption::Type::Double
@ Double
Double option.
Definition qgsgdalutils.h:50

QgsGdalOption::Type::Select
@ Select
Selection option.
Definition qgsgdalutils.h:46

QgsGdalOption::scope
QString scope
Option scope.
Definition qgsgdalutils.h:75

QgsGdalOption::optionsFromXml
static QList< QgsGdalOption > optionsFromXml(const CPLXMLNode *node)
Returns a list of all GDAL options from an XML node.
Definition qgsgdalutils.cpp:146

QgsGdalOption::fromXmlNode
static QgsGdalOption fromXmlNode(const CPLXMLNode *node)
Creates a QgsGdalOption from an XML node.
Definition qgsgdalutils.cpp:41

QgsGdalOption::description
QString description
Option description.
Definition qgsgdalutils.h:60

QgsGdalOption::type
Type type
Option type.
Definition qgsgdalutils.h:57

QgsGdalProgressAdapter::QgsGdalProgressAdapter
QgsGdalProgressAdapter(QgsFeedback *feedback, double startPercentage=0.0, double endPercentage=100.0)
Constructor from feedback (which may be NULL).
Definition qgsgdalutils.cpp:1120

QgsGdalProgressAdapter::progressCallback
static int CPL_STDCALL progressCallback(double dfComplete, const char *pszMessage, void *pProgressArg)
GDAL progress callback.
Definition qgsgdalutils.cpp:1127

QgsGdalUtils::vsiHandlerType
static Qgis::VsiHandlerType vsiHandlerType(const QString &prefix)
Returns the VSI handler type for a given VSI prefix.
Definition qgsgdalutils.cpp:980

QgsGdalUtils::applyVsiCredentialOptions
static bool applyVsiCredentialOptions(const QString &prefix, const QString &path, const QVariantMap &options)
Attempts to apply VSI credential options.
Definition qgsgdalutils.cpp:1090

QgsGdalUtils::pathIsCheapToOpen
static bool pathIsCheapToOpen(const QString &path, int smallFileSizeLimit=50000)
Returns true if the dataset at the specified path is considered "cheap" to open.
Definition qgsgdalutils.cpp:755

QgsGdalUtils::vsiPrefixForPath
static QString vsiPrefixForPath(const QString &path)
Returns a the vsi prefix which corresponds to a file path, or an empty string if the path is not asso...
Definition qgsgdalutils.cpp:845

QgsGdalUtils::helpCreationOptionsFormat
static QString helpCreationOptionsFormat(const QString &format)
Gets creation options metadata for a given format.
Definition qgsgdalutils.cpp:477

QgsGdalUtils::vrtMatchesLayerType
static bool vrtMatchesLayerType(const QString &vrtPath, Qgis::LayerType type)
Returns true if the VRT file at the specified path is a VRT matching the given layer type.
Definition qgsgdalutils.cpp:1021

QgsGdalUtils::resampleSingleBandRaster
static bool resampleSingleBandRaster(GDALDatasetH hSrcDS, GDALDatasetH hDstDS, GDALResampleAlg resampleAlg, const char *pszCoordinateOperation)
Resamples a single band raster to the destination dataset with different resolution (and possibly wit...
Definition qgsgdalutils.cpp:404

QgsGdalUtils::rpcAwareAutoCreateWarpedVrt
static GDALDatasetH rpcAwareAutoCreateWarpedVrt(GDALDatasetH hSrcDS, const char *pszSrcWKT, const char *pszDstWKT, GDALResampleAlg eResampleAlg, double dfMaxError, const GDALWarpOptions *psOptionsIn)
This is a copy of GDALAutoCreateWarpedVRT optimized for imagery using RPC georeferencing that also se...
Definition qgsgdalutils.cpp:597

QgsGdalUtils::supportsTiffLercCompression
static bool supportsTiffLercCompression()
Returns true if the GDAL library used by this QGIS install supports the LERC compression technique fo...
Definition qgsgdalutils.cpp:1076

QgsGdalUtils::supportsRasterCreate
static bool supportsRasterCreate(GDALDriverH driver)
Reads whether a driver supports GDALCreate() for raster purposes.
Definition qgsgdalutils.cpp:165

QgsGdalUtils::isVsiArchiveFileExtension
static bool isVsiArchiveFileExtension(const QString &extension)
Returns true if a file extension is a supported archive style container (e.g.
Definition qgsgdalutils.cpp:974

QgsGdalUtils::gdalResamplingAlgorithm
static GDALResampleAlg gdalResamplingAlgorithm(Qgis::RasterResamplingMethod method)
Returns the GDAL resampling method corresponding to the QGIS resampling method.
Definition qgsgdalutils.cpp:671

QgsGdalUtils::createSingleBandTiffDataset
static gdal::dataset_unique_ptr createSingleBandTiffDataset(const QString &filename, GDALDataType dataType, const QgsRectangle &extent, int width, int height, const QgsCoordinateReferenceSystem &crs)
Creates a new single band TIFF dataset with given parameters.
Definition qgsgdalutils.cpp:206

QgsGdalUtils::gdalDataTypeFromQgisDataType
static GDALDataType gdalDataTypeFromQgisDataType(Qgis::DataType dataType)
Returns the GDAL data type corresponding to the QGIS data type dataType.
Definition qgsgdalutils.cpp:615

QgsGdalUtils::isVsiArchivePrefix
static bool isVsiArchivePrefix(const QString &prefix)
Returns true if prefix is a supported archive style container prefix (e.g.
Definition qgsgdalutils.cpp:947

QgsGdalUtils::gdalDocumentationUrlForDriver
static QString gdalDocumentationUrlForDriver(GDALDriverH hDriver)
Returns the URL for the GDAL documentation for the specified driver.
Definition qgsgdalutils.cpp:1051

QgsGdalUtils::createSingleBandMemoryDataset
static gdal::dataset_unique_ptr createSingleBandMemoryDataset(GDALDataType dataType, const QgsRectangle &extent, int width, int height, const QgsCoordinateReferenceSystem &crs)
Creates a new single band memory dataset with given parameters.
Definition qgsgdalutils.cpp:176

QgsGdalUtils::blockToSingleBandMemoryDataset
static gdal::dataset_unique_ptr blockToSingleBandMemoryDataset(int pixelWidth, int pixelHeight, const QgsRectangle &extent, void *block, GDALDataType dataType)
Converts a data block to a single band GDAL memory dataset.
Definition qgsgdalutils.cpp:277

QgsGdalUtils::vsiNetworkFileSystems
static QList< VsiNetworkFileSystemDetails > vsiNetworkFileSystems()
Returns a list of available GDAL VSI network file systems.
Definition qgsgdalutils.cpp:902

QgsGdalUtils::validateCreationOptionsFormat
static QString validateCreationOptionsFormat(const QStringList &creationOptions, const QString &format)
Validates creation options for a given format, regardless of layer.
Definition qgsgdalutils.cpp:563

QgsGdalUtils::supportsMrfLercCompression
static bool supportsMrfLercCompression()
Returns true if the GDAL library used by this QGIS install supports the LERC compression technique fo...
Definition qgsgdalutils.cpp:1062

QgsGdalUtils::imageToMemoryDataset
static gdal::dataset_unique_ptr imageToMemoryDataset(const QImage &image)
Converts an image to a GDAL memory dataset by borrowing image data.
Definition qgsgdalutils.cpp:237

QgsGdalUtils::rpcAwareCreateTransformer
static void * rpcAwareCreateTransformer(GDALDatasetH hSrcDS, GDALDatasetH hDstDS=nullptr, char **papszOptions=nullptr)
This is a wrapper around GDALCreateGenImgProjTransformer2() that takes into account RPC georeferencin...
Definition qgsgdalutils.cpp:606

QgsGdalUtils::setupProxy
static void setupProxy()
Sets the gdal proxy variables.
Definition qgsgdalutils.cpp:710

QgsGdalUtils::vsiArchiveFileExtensions
static QStringList vsiArchiveFileExtensions()
Returns a list of file extensions which correspond to archive style containers supported by GDAL (e....
Definition qgsgdalutils.cpp:959

QgsGdalUtils::papszFromStringList
static char ** papszFromStringList(const QStringList &list)
Helper function.
Definition qgsgdalutils.cpp:552

QgsGdalUtils::resampleImage
static QImage resampleImage(const QImage &image, QSize outputSize, GDALRIOResampleAlg resampleAlg)
Resamples a QImage image using GDAL resampler.
Definition qgsgdalutils.cpp:429

QgsGdalUtils::createMultiBandMemoryDataset
static gdal::dataset_unique_ptr createMultiBandMemoryDataset(GDALDataType dataType, int bands, const QgsRectangle &extent, int width, int height, const QgsCoordinateReferenceSystem &crs)
Creates a new multi band memory dataset with given parameters.
Definition qgsgdalutils.cpp:181

QgsGdalUtils::multiLayerFileExtensions
static QStringList multiLayerFileExtensions()
Returns a list of file extensions which potentially contain multiple layers representing GDAL raster ...
Definition qgsgdalutils.cpp:777

QgsGdalUtils::vsiArchivePrefixes
static QStringList vsiArchivePrefixes()
Returns a list of vsi prefixes which correspond to archive style containers (eg vsizip).
Definition qgsgdalutils.cpp:888

QgsLogger::warning
static void warning(const QString &msg)
Goes to qWarning.
Definition qgslogger.cpp:134

QgsMessageLog::logMessage
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::MessageLevel::Warning, bool notifyUser=true, const char *file=__builtin_FILE(), const char *function=__builtin_FUNCTION(), int line=__builtin_LINE(), Qgis::StringFormat format=Qgis::StringFormat::PlainText)
Adds a message to the log instance (and creates it if necessary).
Definition qgsmessagelog.cpp:35

QgsNetworkAccessManager::settingsProxyEnabled
static const QgsSettingsEntryBool * settingsProxyEnabled
Settings entry for whether proxy is enabled.
Definition qgsnetworkaccessmanager.h:775

QgsNetworkAccessManager::instance
static QgsNetworkAccessManager * instance(Qt::ConnectionType connectionType=Qt::BlockingQueuedConnection)
Returns a pointer to the active QgsNetworkAccessManager for the current thread.
Definition qgsnetworkaccessmanager.cpp:212

QgsPointXY
Represents a 2D point.
Definition qgspointxy.h:62

QgsPointXY::y
double y
Definition qgspointxy.h:66

QgsPointXY::x
double x
Definition qgspointxy.h:65

QgsRasterBlock
Raster data container.
Definition qgsrasterblock.h:42

QgsRasterBlock::height
int height() const
Returns the height (number of rows) of the raster block.
Definition qgsrasterblock.h:751

QgsRasterBlock::bits
char * bits(int row, int column)
Returns a pointer to block data.
Definition qgsrasterblock.cpp:646

QgsRasterBlock::noDataValue
double noDataValue() const
Returns no data value.
Definition qgsrasterblock.h:214

QgsRasterBlock::dataType
Qgis::DataType dataType() const
Returns data type.
Definition qgsrasterblock.h:164

QgsRasterBlock::width
int width() const
Returns the width (number of columns) of the raster block.
Definition qgsrasterblock.h:745

QgsRectangle
A rectangle specified with double values.
Definition qgsrectangle.h:47

QgsRectangle::xMinimum
double xMinimum
Definition qgsrectangle.h:50

QgsRectangle::yMinimum
double yMinimum
Definition qgsrectangle.h:52

QgsRectangle::height
double height
Definition qgsrectangle.h:55

QgsRectangle::width
double width
Definition qgsrectangle.h:54

gdal::warp_options_unique_ptr
std::unique_ptr< GDALWarpOptions, GDALWarpOptionsDeleter > warp_options_unique_ptr
Scoped GDAL warp options.
Definition qgsogrutils.h:159

gdal::dataset_unique_ptr
std::unique_ptr< std::remove_pointer< GDALDatasetH >::type, GDALDatasetCloser > dataset_unique_ptr
Scoped GDAL dataset.
Definition qgsogrutils.h:144

GDALDatasetH
void * GDALDatasetH
Definition qgsalignraster.h:33

qgscoordinatereferencesystem.h

qgsgdalutils.h

qgslogger.h

QgsDebugError
#define QgsDebugError(str)
Definition qgslogger.h:71

qgsmessagelog.h

qgsnetworkaccessmanager.h

qgsrasterblock.h

qgssettingsentryimpl.h

QgsGdalUtils::VsiNetworkFileSystemDetails
Encapsulates details for a GDAL VSI network file system.
Definition qgsgdalutils.h:304

QgsGdalUtils::VsiNetworkFileSystemDetails::name
QString name
Translated, user-friendly name.
Definition qgsgdalutils.h:309

QgsGdalUtils::VsiNetworkFileSystemDetails::identifier
QString identifier
VSI handler identifier, eg "vsis3".
Definition qgsgdalutils.h:306