sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-10-06 00:07:29 -04:00
Code Issues Packages Projects Releases Wiki Activity
QGIS/src/core/qgsgdalutils.cpp
Alessandro Pasotti 5b3f5b9a9c [pg][raster] Fix nodata ignored 
Fix #63171

TODO: test
2025-09-21 09:34:46 +00:00

1109 lines
39 KiB
C++
Raw Blame History

/***************************************************************************
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 "qgslogger.h"
#include "qgsnetworkaccessmanager.h"
#include "qgssettings.h"
#include "qgscoordinatereferencesystem.h"
#include "qgsrasterblock.h"
#include "qgsmessagelog.h"
#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 ) : QStringLiteral( "YES" );
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( QStringLiteral( "Unhandled GDAL option type: %1" ).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 == QLatin1String( "SQLite" ) ||
driverShortName == QLatin1String( "PDF" ) )
{
// 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()
<< QStringLiteral( "PIXELOFFSET=%1" ).arg( sizeof( QRgb ) )
<< QStringLiteral( "LINEOFFSET=%1" ).arg( image.bytesPerLine() )
<< QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( rgb ) + 2 ) );
GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );
CSLDestroy( papszOptions );
papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
<< QStringLiteral( "PIXELOFFSET=%1" ).arg( sizeof( QRgb ) )
<< QStringLiteral( "LINEOFFSET=%1" ).arg( image.bytesPerLine() )
<< QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( rgb ) + 1 ) );
GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );
CSLDestroy( papszOptions );
papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
<< QStringLiteral( "PIXELOFFSET=%1" ).arg( sizeof( QRgb ) )
<< QStringLiteral( "LINEOFFSET=%1" ).arg( image.bytesPerLine() )
<< QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( rgb ) ) );
GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );
CSLDestroy( papszOptions );
papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
<< QStringLiteral( "PIXELOFFSET=%1" ).arg( sizeof( QRgb ) )
<< QStringLiteral( "LINEOFFSET=%1" ).arg( image.bytesPerLine() )
<< QStringLiteral( "DATAPOINTER=%1" ).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()
<< QStringLiteral( "PIXELOFFSET=%1" ).arg( dataTypeSize )
<< QStringLiteral( "LINEOFFSET=%1" ).arg( pixelWidth * dataTypeSize )
<< QStringLiteral( "DATAPOINTER=%1" ).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()
<< QStringLiteral( "PIXELOFFSET=%1" ).arg( dataTypeSize )
<< QStringLiteral( "LINEOFFSET=%1" ).arg( block->width() * dataTypeSize )
<< QStringLiteral( "DATAPOINTER=%1" ).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( QStringLiteral( "failed to read red band" ) );
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( QStringLiteral( "failed to read green band" ) );
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( QStringLiteral( "failed to read blue band" ) );
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( QStringLiteral( "failed to read alpha band" ) );
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
char **GDALmetadata = GDALGetMetadata( myGdalDriver, nullptr );
message += QLatin1String( "Format Details:\n" );
message += QStringLiteral( " Extension: %1\n" ).arg( CSLFetchNameValue( GDALmetadata, GDAL_DMD_EXTENSION ) );
message += QStringLiteral( " Short Name: %1" ).arg( GDALGetDriverShortName( myGdalDriver ) );
message += QStringLiteral( " / Long Name: %1\n" ).arg( GDALGetDriverLongName( myGdalDriver ) );
const QString helpUrl = gdalDocumentationUrlForDriver( myGdalDriver );
if ( !helpUrl.isEmpty() )
message += QStringLiteral( " Help page: %1\n\n" ).arg( helpUrl );
// next get creation options
// need to serialize xml to get newlines, should we make the basic xml prettier?
CPLXMLNode *psCOL = CPLParseXMLString( GDALGetMetadataItem( myGdalDriver,
GDAL_DMD_CREATIONOPTIONLIST, "" ) );
char *pszFormattedXML = CPLSerializeXMLTree( psCOL );
if ( pszFormattedXML )
message += QString( pszFormattedXML );
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 QStringLiteral( "invalid GDAL driver" );
char **papszOptions = papszFromStringList( creationOptions );
// get error string?
const int ok = GDALValidateCreationOptions( myGdalDriver, papszOptions );
CSLDestroy( papszOptions );
if ( !ok )
return QStringLiteral( "Failed GDALValidateCreationOptions() test" );
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.
const QgsSettings settings;
// Check that proxy is enabled
if ( settings.value( QStringLiteral( "proxy/proxyEnabled" ), false ).toBool() )
{
// 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)
//QStringList excludes;
//excludes = settings.value( QStringLiteral( "proxy/proxyExcludedUrls" ), "" ).toStringList();
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
{
QStringLiteral( "xlsx" ),
QStringLiteral( "ods" ),
QStringLiteral( "csv" )
};
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 ) ) == QLatin1String( "YES" ) )
{
if ( GDALGetMetadataItem( driver, GDAL_DMD_SUBDATASETS, nullptr ) )
{
isMultiLayer = true;
}
}
if ( !isMultiLayer && QString( GDALGetMetadataItem( driver, GDAL_DCAP_VECTOR, nullptr ) ) == QLatin1String( "YES" ) )
{
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 == QLatin1String( "tif" ) || ext == QLatin1String( "tiff" ) )
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
{
QStringLiteral( "gpkg" ),
QStringLiteral( "sqlite" ),
QStringLiteral( "db" ),
QStringLiteral( "gdb" ),
QStringLiteral( "kml" ),
QStringLiteral( "kmz" ),
QStringLiteral( "osm" ),
QStringLiteral( "mdb" ),
QStringLiteral( "accdb" ),
QStringLiteral( "xls" ),
QStringLiteral( "xlsx" ),
QStringLiteral( "ods" ),
QStringLiteral( "gpx" ),
QStringLiteral( "pdf" ),
QStringLiteral( "pbf" ),
QStringLiteral( "vrt" ),
QStringLiteral( "nc" ),
QStringLiteral( "dxf" ),
QStringLiteral( "shp.zip" ) };
return SUPPORTED_DB_LAYERS_EXTENSIONS;
#endif
}
QString QgsGdalUtils::vsiPrefixForPath( const QString &path )
{
const QStringList vsiPrefixes = QgsGdalUtils::vsiArchivePrefixes();
const thread_local QRegularExpression vsiRx( QStringLiteral( "^(/vsi.+?/)" ), QRegularExpression::PatternOption::CaseInsensitiveOption );
const QRegularExpressionMatch vsiMatch = vsiRx.match( path );
if ( vsiMatch.hasMatch() )
return vsiMatch.captured( 1 );
if ( path.endsWith( QLatin1String( ".shp.zip" ), Qt::CaseInsensitive ) )
{
// GDAL 3.1 Shapefile driver directly handles .shp.zip files
if ( GDALIdentifyDriverEx( path.toUtf8().constData(), GDAL_OF_VECTOR, nullptr, nullptr ) )
return QString();
return QStringLiteral( "/vsizip/" );
}
else if ( path.endsWith( QLatin1String( ".zip" ), 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 QStringLiteral( "/vsizip/" );
}
else if ( path.endsWith( QLatin1String( ".tar" ), Qt::CaseInsensitive ) ||
path.endsWith( QLatin1String( ".tar.gz" ), Qt::CaseInsensitive ) ||
path.endsWith( QLatin1String( ".tgz" ), Qt::CaseInsensitive ) )
return QStringLiteral( "/vsitar/" );
else if ( path.endsWith( QLatin1String( ".gz" ), Qt::CaseInsensitive ) )
return QStringLiteral( "/vsigzip/" );
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3,7,0)
else if ( vsiPrefixes.contains( QStringLiteral( "/vsi7z/" ) ) &&
( path.endsWith( QLatin1String( ".7z" ), Qt::CaseInsensitive ) ||
path.endsWith( QLatin1String( ".lpk" ), Qt::CaseInsensitive ) ||
path.endsWith( QLatin1String( ".lpkx" ), Qt::CaseInsensitive ) ||
path.endsWith( QLatin1String( ".mpk" ), Qt::CaseInsensitive ) ||
path.endsWith( QLatin1String( ".mpkx" ), Qt::CaseInsensitive ) ) )
return QStringLiteral( "/vsi7z/" );
else if ( vsiPrefixes.contains( QStringLiteral( "/vsirar/" ) ) &&
path.endsWith( QLatin1String( ".rar" ), Qt::CaseInsensitive ) )
return QStringLiteral( "/vsirar/" );
#endif
return QString();
}
QStringList QgsGdalUtils::vsiArchivePrefixes()
{
QStringList res { QStringLiteral( "/vsizip/" ),
QStringLiteral( "/vsitar/" ),
QStringLiteral( "/vsigzip/" ),
};
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3,7,0)
res.append( QStringLiteral( "/vsi7z/" ) );
res.append( QStringLiteral( "/vsirar/" ) );
#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 == QLatin1String( "vsicurl" ) )
details.name = QObject::tr( "HTTP/HTTPS/FTP" );
else if ( details.identifier == QLatin1String( "vsis3" ) )
details.name = QObject::tr( "AWS S3" );
else if ( details.identifier == QLatin1String( "vsigs" ) )
details.name = QObject::tr( "Google Cloud Storage" );
else if ( details.identifier == QLatin1String( "vsiaz" ) )
details.name = QObject::tr( "Microsoft Azure Blob" );
else if ( details.identifier == QLatin1String( "vsiadls" ) )
details.name = QObject::tr( "Microsoft Azure Data Lake Storage" );
else if ( details.identifier == QLatin1String( "vsioss" ) )
details.name = QObject::tr( "Alibaba Cloud OSS" );
else if ( details.identifier == QLatin1String( "vsiswift" ) )
details.name = QObject::tr( "OpenStack Swift Object Storage" );
else if ( details.identifier == QLatin1String( "vsihdfs" ) )
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 { QStringLiteral( ".zip" ),
QStringLiteral( ".tar" ),
QStringLiteral( ".tar.gz" ),
QStringLiteral( ".tgz" ),
QStringLiteral( ".gz" ),
};
#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3,7,0)
res.append( { QStringLiteral( ".7z" ),
QStringLiteral( ".lpk" ),
QStringLiteral( ".lpkx" ),
QStringLiteral( ".mpk" ),
QStringLiteral( ".mpkx" ),
QStringLiteral( ".rar" )
} );
#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( QLatin1String( "vsi" ) ) )
return Qgis::VsiHandlerType::Invalid;
if ( vsiPrefix == QLatin1String( "vsizip" ) ||
vsiPrefix == QLatin1String( "vsigzip" ) ||
vsiPrefix == QLatin1String( "vsitar" ) ||
vsiPrefix == QLatin1String( "vsi7z" ) ||
vsiPrefix == QLatin1String( "vsirar" ) )
return Qgis::VsiHandlerType::Archive;
else if ( vsiPrefix == QLatin1String( "vsicurl" ) ||
vsiPrefix == QLatin1String( "vsicurl_streaming" ) )
return Qgis::VsiHandlerType::Network;
else if ( vsiPrefix == QLatin1String( "vsis3" ) ||
vsiPrefix == QLatin1String( "vsicurl_streaming" ) ||
vsiPrefix == QLatin1String( "vsigs" ) ||
vsiPrefix == QLatin1String( "vsigs_streaming" ) ||
vsiPrefix == QLatin1String( "vsiaz" ) ||
vsiPrefix == QLatin1String( "vsiaz_streaming" ) ||
vsiPrefix == QLatin1String( "vsiadls" ) ||
vsiPrefix == QLatin1String( "vsioss" ) ||
vsiPrefix == QLatin1String( "vsioss_streaming" ) ||
vsiPrefix == QLatin1String( "vsiswift" ) ||
vsiPrefix == QLatin1String( "vsiswift_streaming" ) ||
vsiPrefix == QLatin1String( "vsihdfs" ) ||
vsiPrefix == QLatin1String( "vsiwebhdfs" ) )
return Qgis::VsiHandlerType::Cloud;
else if ( vsiPrefix == QLatin1String( "vsimem" ) )
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 QStringLiteral( "https://gdal.org/%1" ).arg( gdalDriverHelpTopic );
}
return QString();
}
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" ), QStringLiteral( "GDAL" ), Qgis::MessageLevel::Critical );
return false;
#endif
}
return true;
}
#endif
Reference in New Issue View Git Blame Copy Permalink