QGIS API Documentation 3.41.0-Master (45a0abf3bec)
Loading...
Searching...
No Matches
qgsgdalutils.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsgdalutils.cpp
3 ----------------
4 begin : September 2018
5 copyright : (C) 2018 Even Rouault
6 email : even.rouault at spatialys.com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
16#include "qgsgdalutils.h"
17#include "qgslogger.h"
18#include "qgsnetworkaccessmanager.h"
19#include "qgssettings.h"
20#include "qgscoordinatereferencesystem.h"
21#include "qgsrasterblock.h"
22#include "qgsmessagelog.h"
23
24#define CPL_SUPRESS_CPLUSPLUS //#spellok
25#include "gdal.h"
26#include "gdalwarper.h"
27#include "cpl_string.h"
28
29#include <QNetworkProxy>
30#include <QString>
31#include <QImage>
32#include <QFileInfo>
33#include <mutex>
34
35
36QgsGdalOption QgsGdalOption::fromXmlNode( const CPLXMLNode *node )
37{
38 if ( node->eType != CXT_Element || !EQUAL( node->pszValue, "Option" ) )
39 return {};
40
41 const QString optionName( CPLGetXMLValue( node, "name", nullptr ) );
42 if ( optionName.isEmpty() )
43 return {};
44
45 QgsGdalOption option;
46 option.name = optionName;
47
48 option.description = QString( CPLGetXMLValue( node, "description", nullptr ) );
49 option.scope = QString( CPLGetXMLValue( node, "scope", nullptr ) );
50
51 option.type = QgsGdalOption::Type::Text;
52
53 const char *pszType = CPLGetXMLValue( node, "type", nullptr );
54 const char *pszDefault = CPLGetXMLValue( node, "default", nullptr );
55 if ( pszType && EQUAL( pszType, "string-select" ) )
56 {
57 option.type = QgsGdalOption::Type::Select;
58 for ( auto psOption = node->psChild; psOption != nullptr; psOption = psOption->psNext )
59 {
60 if ( psOption->eType != CXT_Element ||
61 !EQUAL( psOption->pszValue, "Value" ) ||
62 !psOption->psChild )
63 {
64 continue;
65 }
66 option.options << psOption->psChild->pszValue;
67 }
68 option.defaultValue = pszDefault ? QString( pszDefault ) : option.options.value( 0 );
69 return option;
70 }
71 else if ( pszType && EQUAL( pszType, "boolean" ) )
72 {
73 option.type = QgsGdalOption::Type::Boolean;
74 option.defaultValue = pszDefault ? QString( pszDefault ) : QStringLiteral( "YES" );
75 return option;
76 }
77 else if ( pszType && EQUAL( pszType, "string" ) )
78 {
79 option.type = QgsGdalOption::Type::Text;
80 if ( pszDefault )
81 option.defaultValue = QString( pszDefault );
82 return option;
83 }
84 else if ( pszType && ( EQUAL( pszType, "int" ) || EQUAL( pszType, "integer" ) ) )
85 {
86 option.type = QgsGdalOption::Type::Int;
87 if ( pszDefault )
88 {
89 bool ok = false;
90 const int defaultInt = QString( pszDefault ).toInt( &ok );
91 if ( ok )
92 option.defaultValue = defaultInt;
93 }
94
95 if ( const char *pszMin = CPLGetXMLValue( node, "min", nullptr ) )
96 {
97 bool ok = false;
98 const int minInt = QString( pszMin ).toInt( &ok );
99 if ( ok )
100 option.minimum = minInt;
101 }
102 if ( const char *pszMax = CPLGetXMLValue( node, "max", nullptr ) )
103 {
104 bool ok = false;
105 const int maxInt = QString( pszMax ).toInt( &ok );
106 if ( ok )
107 option.maximum = maxInt;
108 }
109 return option;
110 }
111 else if ( pszType && EQUAL( pszType, "double" ) )
112 {
113 option.type = QgsGdalOption::Type::Double;
114 if ( pszDefault )
115 {
116 bool ok = false;
117 const double defaultDouble = QString( pszDefault ).toDouble( &ok );
118 if ( ok )
119 option.defaultValue = defaultDouble;
120 }
121
122 if ( const char *pszMin = CPLGetXMLValue( node, "min", nullptr ) )
123 {
124 bool ok = false;
125 const double minDouble = QString( pszMin ).toDouble( &ok );
126 if ( ok )
127 option.minimum = minDouble;
128 }
129 if ( const char *pszMax = CPLGetXMLValue( node, "max", nullptr ) )
130 {
131 bool ok = false;
132 const double maxDouble = QString( pszMax ).toDouble( &ok );
133 if ( ok )
134 option.maximum = maxDouble;
135 }
136 return option;
137 }
138
139 QgsDebugError( QStringLiteral( "Unhandled GDAL option type: %1" ).arg( pszType ) );
140 return {};
141}
142
143QList<QgsGdalOption> QgsGdalOption::optionsFromXml( const CPLXMLNode *node )
144{
145 QList< QgsGdalOption > options;
146 for ( auto psItem = node->psChild; psItem != nullptr; psItem = psItem->psNext )
147 {
148 const QgsGdalOption option = fromXmlNode( psItem );
149 if ( option.type == QgsGdalOption::Type::Invalid )
150 continue;
151
152 options << option;
153 }
154 return options;
155}
156
157
158//
159// QgsGdalUtils
160//
161
162bool QgsGdalUtils::supportsRasterCreate( GDALDriverH driver )
163{
164 const QString driverShortName = GDALGetDriverShortName( driver );
165 if ( driverShortName == QLatin1String( "SQLite" ) ||
166 driverShortName == QLatin1String( "PDF" ) )
167 {
168 // it supports Create() but only for vector side
169 return false;
170 }
171 return GDALGetMetadataItem( driver, GDAL_DCAP_CREATE, nullptr ) &&
172 GDALGetMetadataItem( driver, GDAL_DCAP_RASTER, nullptr );
173}
174
175gdal::dataset_unique_ptr QgsGdalUtils::createSingleBandMemoryDataset( GDALDataType dataType, const QgsRectangle &extent, int width, int height, const QgsCoordinateReferenceSystem &crs )
176{
177 return createMultiBandMemoryDataset( dataType, 1, extent, width, height, crs );
178}
179
180gdal::dataset_unique_ptr QgsGdalUtils::createMultiBandMemoryDataset( GDALDataType dataType, int bands, const QgsRectangle &extent, int width, int height, const QgsCoordinateReferenceSystem &crs )
181{
182 GDALDriverH hDriverMem = GDALGetDriverByName( "MEM" );
183 if ( !hDriverMem )
184 {
185 return gdal::dataset_unique_ptr();
186 }
187
188 gdal::dataset_unique_ptr hSrcDS( GDALCreate( hDriverMem, "", width, height, bands, dataType, nullptr ) );
189
190 const double cellSizeX = extent.width() / width;
191 const double cellSizeY = extent.height() / height;
192 double geoTransform[6];
193 geoTransform[0] = extent.xMinimum();
194 geoTransform[1] = cellSizeX;
195 geoTransform[2] = 0;
196 geoTransform[3] = extent.yMinimum() + ( cellSizeY * height );
197 geoTransform[4] = 0;
198 geoTransform[5] = -cellSizeY;
199
200 GDALSetProjection( hSrcDS.get(), crs.toWkt( Qgis::CrsWktVariant::PreferredGdal ).toLatin1().constData() );
201 GDALSetGeoTransform( hSrcDS.get(), geoTransform );
202 return hSrcDS;
203}
204
205gdal::dataset_unique_ptr QgsGdalUtils::createSingleBandTiffDataset( const QString &filename, GDALDataType dataType, const QgsRectangle &extent, int width, int height, const QgsCoordinateReferenceSystem &crs )
206{
207 const double cellSizeX = extent.width() / width;
208 const double cellSizeY = extent.height() / height;
209 double geoTransform[6];
210 geoTransform[0] = extent.xMinimum();
211 geoTransform[1] = cellSizeX;
212 geoTransform[2] = 0;
213 geoTransform[3] = extent.yMinimum() + ( cellSizeY * height );
214 geoTransform[4] = 0;
215 geoTransform[5] = -cellSizeY;
216
217 GDALDriverH hDriver = GDALGetDriverByName( "GTiff" );
218 if ( !hDriver )
219 {
220 return gdal::dataset_unique_ptr();
221 }
222
223 // Create the output file.
224 gdal::dataset_unique_ptr hDstDS( GDALCreate( hDriver, filename.toUtf8().constData(), width, height, 1, dataType, nullptr ) );
225 if ( !hDstDS )
226 {
227 return gdal::dataset_unique_ptr();
228 }
229
230 // Write out the projection definition.
231 GDALSetProjection( hDstDS.get(), crs.toWkt( Qgis::CrsWktVariant::PreferredGdal ).toLatin1().constData() );
232 GDALSetGeoTransform( hDstDS.get(), geoTransform );
233 return hDstDS;
234}
235
236gdal::dataset_unique_ptr QgsGdalUtils::imageToMemoryDataset( const QImage &image )
237{
238 if ( image.isNull() )
239 return nullptr;
240
241 const QRgb *rgb = reinterpret_cast<const QRgb *>( image.constBits() );
242 GDALDriverH hDriverMem = GDALGetDriverByName( "MEM" );
243 if ( !hDriverMem )
244 {
245 return nullptr;
246 }
247 gdal::dataset_unique_ptr hSrcDS( GDALCreate( hDriverMem, "", image.width(), image.height(), 0, GDT_Byte, nullptr ) );
248
249 char **papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
250 << QStringLiteral( "PIXELOFFSET=%1" ).arg( sizeof( QRgb ) )
251 << QStringLiteral( "LINEOFFSET=%1" ).arg( image.bytesPerLine() )
252 << QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( rgb ) + 2 ) );
253 GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );
254 CSLDestroy( papszOptions );
255
256 papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
257 << QStringLiteral( "PIXELOFFSET=%1" ).arg( sizeof( QRgb ) )
258 << QStringLiteral( "LINEOFFSET=%1" ).arg( image.bytesPerLine() )
259 << QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( rgb ) + 1 ) );
260 GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );
261 CSLDestroy( papszOptions );
262
263 papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
264 << QStringLiteral( "PIXELOFFSET=%1" ).arg( sizeof( QRgb ) )
265 << QStringLiteral( "LINEOFFSET=%1" ).arg( image.bytesPerLine() )
266 << QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( rgb ) ) );
267 GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );
268 CSLDestroy( papszOptions );
269
270 papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
271 << QStringLiteral( "PIXELOFFSET=%1" ).arg( sizeof( QRgb ) )
272 << QStringLiteral( "LINEOFFSET=%1" ).arg( image.bytesPerLine() )
273 << QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( rgb ) + 3 ) );
274 GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );
275 CSLDestroy( papszOptions );
276
277 return hSrcDS;
278}
279
280gdal::dataset_unique_ptr QgsGdalUtils::blockToSingleBandMemoryDataset( int pixelWidth, int pixelHeight, const QgsRectangle &extent, void *block, GDALDataType dataType )
281{
282 if ( !block )
283 return nullptr;
284
285 GDALDriverH hDriverMem = GDALGetDriverByName( "MEM" );
286 if ( !hDriverMem )
287 return nullptr;
288
289 const double cellSizeX = extent.width() / pixelWidth;
290 const double cellSizeY = extent.height() / pixelHeight;
291 double geoTransform[6];
292 geoTransform[0] = extent.xMinimum();
293 geoTransform[1] = cellSizeX;
294 geoTransform[2] = 0;
295 geoTransform[3] = extent.yMinimum() + ( cellSizeY * pixelHeight );
296 geoTransform[4] = 0;
297 geoTransform[5] = -cellSizeY;
298
299 gdal::dataset_unique_ptr hDstDS( GDALCreate( hDriverMem, "", pixelWidth, pixelHeight, 0, dataType, nullptr ) );
300
301 int dataTypeSize = GDALGetDataTypeSizeBytes( dataType );
302 char **papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
303 << QStringLiteral( "PIXELOFFSET=%1" ).arg( dataTypeSize )
304 << QStringLiteral( "LINEOFFSET=%1" ).arg( pixelWidth * dataTypeSize )
305 << QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( block ) ) );
306 GDALAddBand( hDstDS.get(), dataType, papszOptions );
307 CSLDestroy( papszOptions );
308
309 GDALSetGeoTransform( hDstDS.get(), geoTransform );
310
311 return hDstDS;
312}
313
314gdal::dataset_unique_ptr QgsGdalUtils::blockToSingleBandMemoryDataset( const QgsRectangle &extent, QgsRasterBlock *block )
315{
316 if ( !block )
317 return nullptr;
318
319 gdal::dataset_unique_ptr ret = blockToSingleBandMemoryDataset( block->width(), block->height(), extent, block->bits(), gdalDataTypeFromQgisDataType( block->dataType() ) );
320 if ( ret )
321 {
322 GDALRasterBandH band = GDALGetRasterBand( ret.get(), 1 );
323 if ( band )
324 GDALSetRasterNoDataValue( band, block->noDataValue() );
325 }
326
327 return ret;
328}
329
330
331
332gdal::dataset_unique_ptr QgsGdalUtils::blockToSingleBandMemoryDataset( double rotation,
333 const QgsPointXY &origin,
334 double gridXSize,
335 double gridYSize,
336 QgsRasterBlock *block )
337{
338 if ( !block )
339 return nullptr;
340
341 GDALDriverH hDriverMem = GDALGetDriverByName( "MEM" );
342 if ( !hDriverMem )
343 return nullptr;
344
345 const double cellSizeX = gridXSize / block->width();
346 const double cellSizeY = gridYSize / block->height();
347 double geoTransform[6];
348 geoTransform[0] = origin.x();
349 geoTransform[1] = cellSizeX * std::cos( rotation );
350 geoTransform[2] = cellSizeY * std::sin( rotation );
351 geoTransform[3] = origin.y();
352 geoTransform[4] = cellSizeX * std::sin( rotation );
353 geoTransform[5] = -cellSizeY * std::cos( rotation );
354
355 GDALDataType dataType = gdalDataTypeFromQgisDataType( block->dataType() );
356 gdal::dataset_unique_ptr hDstDS( GDALCreate( hDriverMem, "", block->width(), block->height(), 0, dataType, nullptr ) );
357
358 int dataTypeSize = GDALGetDataTypeSizeBytes( dataType );
359 char **papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
360 << QStringLiteral( "PIXELOFFSET=%1" ).arg( dataTypeSize )
361 << QStringLiteral( "LINEOFFSET=%1" ).arg( block->width() * dataTypeSize )
362 << QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( block->bits() ) ) );
363 GDALAddBand( hDstDS.get(), dataType, papszOptions );
364 CSLDestroy( papszOptions );
365
366 GDALSetGeoTransform( hDstDS.get(), geoTransform );
367
368 GDALRasterBandH band = GDALGetRasterBand( hDstDS.get(), 1 );
369 if ( band )
370 GDALSetRasterNoDataValue( band, block->noDataValue() );
371
372 return hDstDS;
373}
374
375static bool resampleSingleBandRasterStatic( GDALDatasetH hSrcDS, GDALDatasetH hDstDS, GDALResampleAlg resampleAlg, char **papszOptions )
376{
377 gdal::warp_options_unique_ptr psWarpOptions( GDALCreateWarpOptions() );
378 psWarpOptions->hSrcDS = hSrcDS;
379 psWarpOptions->hDstDS = hDstDS;
380
381 psWarpOptions->nBandCount = 1;
382 psWarpOptions->panSrcBands = reinterpret_cast< int * >( CPLMalloc( sizeof( int ) * 1 ) );
383 psWarpOptions->panDstBands = reinterpret_cast< int * >( CPLMalloc( sizeof( int ) * 1 ) );
384 psWarpOptions->panSrcBands[0] = 1;
385 psWarpOptions->panDstBands[0] = 1;
386 double noDataValue = GDALGetRasterNoDataValue( GDALGetRasterBand( hDstDS, 1 ), nullptr );
387 psWarpOptions->padfDstNoDataReal = reinterpret_cast< double * >( CPLMalloc( sizeof( double ) * 1 ) );
388 psWarpOptions->padfDstNoDataReal[0] = noDataValue;
389 psWarpOptions->eResampleAlg = resampleAlg;
390
391 // Establish reprojection transformer.
392 psWarpOptions->pTransformerArg = GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, papszOptions );
393
394 if ( ! psWarpOptions->pTransformerArg )
395 {
396 return false;
397 }
398
399 psWarpOptions->pfnTransformer = GDALGenImgProjTransform;
400 psWarpOptions->papszWarpOptions = CSLSetNameValue( psWarpOptions-> papszWarpOptions, "INIT_DEST", "NO_DATA" );
401
402 // Initialize and execute the warp operation.
403 bool retVal = false;
404 GDALWarpOperation oOperation;
405 CPLErr initResult = oOperation.Initialize( psWarpOptions.get() );
406 if ( initResult != CE_Failure )
407 retVal = oOperation.ChunkAndWarpImage( 0, 0, GDALGetRasterXSize( hDstDS ), GDALGetRasterYSize( hDstDS ) ) == CE_None;
408 GDALDestroyGenImgProjTransformer( psWarpOptions->pTransformerArg );
409 return retVal;
410}
411
412bool QgsGdalUtils::resampleSingleBandRaster( GDALDatasetH hSrcDS, GDALDatasetH hDstDS, GDALResampleAlg resampleAlg, const char *pszCoordinateOperation )
413{
414 char **papszOptions = nullptr;
415 if ( pszCoordinateOperation )
416 papszOptions = CSLSetNameValue( papszOptions, "COORDINATE_OPERATION", pszCoordinateOperation );
417
418 bool result = resampleSingleBandRasterStatic( hSrcDS, hDstDS, resampleAlg, papszOptions );
419 CSLDestroy( papszOptions );
420 return result;
421}
422
423bool QgsGdalUtils::resampleSingleBandRaster( GDALDatasetH hSrcDS,
424 GDALDatasetH hDstDS,
425 GDALResampleAlg resampleAlg,
426 const QgsCoordinateReferenceSystem &sourceCrs,
427 const QgsCoordinateReferenceSystem &destinationCrs )
428{
429 char **papszOptions = nullptr;
430
431 papszOptions = CSLSetNameValue( papszOptions, "SRC_SRS", sourceCrs.toWkt( Qgis::CrsWktVariant::PreferredGdal ).toUtf8().constData() );
432 papszOptions = CSLSetNameValue( papszOptions, "DST_SRS", destinationCrs.toWkt( Qgis::CrsWktVariant::PreferredGdal ).toUtf8().constData() );
433
434 bool result = resampleSingleBandRasterStatic( hSrcDS, hDstDS, resampleAlg, papszOptions );
435 CSLDestroy( papszOptions );
436 return result;
437}
438
439QImage QgsGdalUtils::resampleImage( const QImage &image, QSize outputSize, GDALRIOResampleAlg resampleAlg )
440{
441 const gdal::dataset_unique_ptr srcDS = QgsGdalUtils::imageToMemoryDataset( image );
442 if ( !srcDS )
443 return QImage();
444
445 GDALRasterIOExtraArg extra;
446 INIT_RASTERIO_EXTRA_ARG( extra );
447 extra.eResampleAlg = resampleAlg;
448
449 QImage res( outputSize, image.format() );
450 if ( res.isNull() )
451 return QImage();
452
453 GByte *rgb = reinterpret_cast<GByte *>( res.bits() );
454
455 CPLErr err = GDALRasterIOEx( GDALGetRasterBand( srcDS.get(), 1 ), GF_Read, 0, 0, image.width(), image.height(), rgb + 2, outputSize.width(),
456 outputSize.height(), GDT_Byte, sizeof( QRgb ), res.bytesPerLine(), &extra );
457 if ( err != CE_None )
458 {
459 QgsDebugError( QStringLiteral( "failed to read red band" ) );
460 return QImage();
461 }
462
463 err = GDALRasterIOEx( GDALGetRasterBand( srcDS.get(), 2 ), GF_Read, 0, 0, image.width(), image.height(), rgb + 1, outputSize.width(),
464 outputSize.height(), GDT_Byte, sizeof( QRgb ), res.bytesPerLine(), &extra );
465 if ( err != CE_None )
466 {
467 QgsDebugError( QStringLiteral( "failed to read green band" ) );
468 return QImage();
469 }
470
471 err = GDALRasterIOEx( GDALGetRasterBand( srcDS.get(), 3 ), GF_Read, 0, 0, image.width(), image.height(), rgb, outputSize.width(),
472 outputSize.height(), GDT_Byte, sizeof( QRgb ), res.bytesPerLine(), &extra );
473 if ( err != CE_None )
474 {
475 QgsDebugError( QStringLiteral( "failed to read blue band" ) );
476 return QImage();
477 }
478
479 err = GDALRasterIOEx( GDALGetRasterBand( srcDS.get(), 4 ), GF_Read, 0, 0, image.width(), image.height(), rgb + 3, outputSize.width(),
480 outputSize.height(), GDT_Byte, sizeof( QRgb ), res.bytesPerLine(), &extra );
481 if ( err != CE_None )
482 {
483 QgsDebugError( QStringLiteral( "failed to read alpha band" ) );
484 return QImage();
485 }
486
487 return res;
488}
489
490QString QgsGdalUtils::helpCreationOptionsFormat( const QString &format )
491{
492 QString message;
493 GDALDriverH myGdalDriver = GDALGetDriverByName( format.toLocal8Bit().constData() );
494 if ( myGdalDriver )
495 {
496 // first report details and help page
497 char **GDALmetadata = GDALGetMetadata( myGdalDriver, nullptr );
498 message += QLatin1String( "Format Details:\n" );
499 message += QStringLiteral( " Extension: %1\n" ).arg( CSLFetchNameValue( GDALmetadata, GDAL_DMD_EXTENSION ) );
500 message += QStringLiteral( " Short Name: %1" ).arg( GDALGetDriverShortName( myGdalDriver ) );
501 message += QStringLiteral( " / Long Name: %1\n" ).arg( GDALGetDriverLongName( myGdalDriver ) );
502 const QString helpUrl = gdalDocumentationUrlForDriver( myGdalDriver );
503 if ( !helpUrl.isEmpty() )
504 message += QStringLiteral( " Help page: %1\n\n" ).arg( helpUrl );
505
506 // next get creation options
507 // need to serialize xml to get newlines, should we make the basic xml prettier?
508 CPLXMLNode *psCOL = CPLParseXMLString( GDALGetMetadataItem( myGdalDriver,
509 GDAL_DMD_CREATIONOPTIONLIST, "" ) );
510 char *pszFormattedXML = CPLSerializeXMLTree( psCOL );
511 if ( pszFormattedXML )
512 message += QString( pszFormattedXML );
513 if ( psCOL )
514 CPLDestroyXMLNode( psCOL );
515 if ( pszFormattedXML )
516 CPLFree( pszFormattedXML );
517 }
518 return message;
519}
520
521char **QgsGdalUtils::papszFromStringList( const QStringList &list )
522{
523 char **papszRetList = nullptr;
524 const auto constList = list;
525 for ( const QString &elem : constList )
526 {
527 papszRetList = CSLAddString( papszRetList, elem.toLocal8Bit().constData() );
528 }
529 return papszRetList;
530}
531
532QString QgsGdalUtils::validateCreationOptionsFormat( const QStringList &createOptions, const QString &format )
533{
534 GDALDriverH myGdalDriver = GDALGetDriverByName( format.toLocal8Bit().constData() );
535 if ( ! myGdalDriver )
536 return QStringLiteral( "invalid GDAL driver" );
537
538 char **papszOptions = papszFromStringList( createOptions );
539 // get error string?
540 const int ok = GDALValidateCreationOptions( myGdalDriver, papszOptions );
541 CSLDestroy( papszOptions );
542
543 if ( !ok )
544 return QStringLiteral( "Failed GDALValidateCreationOptions() test" );
545 return QString();
546}
547
548GDALDatasetH QgsGdalUtils::rpcAwareAutoCreateWarpedVrt(
549 GDALDatasetH hSrcDS,
550 const char *pszSrcWKT,
551 const char *pszDstWKT,
552 GDALResampleAlg eResampleAlg,
553 double dfMaxError,
554 const GDALWarpOptions *psOptionsIn )
555{
556 char **opts = nullptr;
557 if ( GDALGetMetadata( hSrcDS, "RPC" ) )
558 {
559 // well-behaved RPC should have height offset a good value for RPC_HEIGHT
560 const char *heightOffStr = GDALGetMetadataItem( hSrcDS, "HEIGHT_OFF", "RPC" );
561 if ( heightOffStr )
562 opts = CSLAddNameValue( opts, "RPC_HEIGHT", heightOffStr );
563 }
564
565 return GDALAutoCreateWarpedVRTEx( hSrcDS, pszSrcWKT, pszDstWKT, eResampleAlg, dfMaxError, psOptionsIn, opts );
566}
567
568void *QgsGdalUtils::rpcAwareCreateTransformer( GDALDatasetH hSrcDS, GDALDatasetH hDstDS, char **papszOptions )
569{
570 char **opts = CSLDuplicate( papszOptions );
571 if ( GDALGetMetadata( hSrcDS, "RPC" ) )
572 {
573 // well-behaved RPC should have height offset a good value for RPC_HEIGHT
574 const char *heightOffStr = GDALGetMetadataItem( hSrcDS, "HEIGHT_OFF", "RPC" );
575 if ( heightOffStr )
576 opts = CSLAddNameValue( opts, "RPC_HEIGHT", heightOffStr );
577 }
578 void *transformer = GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, opts );
579 CSLDestroy( opts );
580 return transformer;
581}
582
583GDALDataType QgsGdalUtils::gdalDataTypeFromQgisDataType( Qgis::DataType dataType )
584{
585 switch ( dataType )
586 {
587 case Qgis::DataType::UnknownDataType:
588 return GDALDataType::GDT_Unknown;
589 break;
590 case Qgis::DataType::Byte:
591 return GDALDataType::GDT_Byte;
592 break;
593 case Qgis::DataType::Int8:
594#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3,7,0)
595 return GDALDataType::GDT_Int8;
596#else
597 return GDALDataType::GDT_Unknown;
598#endif
599 break;
600 case Qgis::DataType::UInt16:
601 return GDALDataType::GDT_UInt16;
602 break;
603 case Qgis::DataType::Int16:
604 return GDALDataType::GDT_Int16;
605 break;
606 case Qgis::DataType::UInt32:
607 return GDALDataType::GDT_UInt32;
608 break;
609 case Qgis::DataType::Int32:
610 return GDALDataType::GDT_Int32;
611 break;
612 case Qgis::DataType::Float32:
613 return GDALDataType::GDT_Float32;
614 break;
615 case Qgis::DataType::Float64:
616 return GDALDataType::GDT_Float64;
617 break;
618 case Qgis::DataType::CInt16:
619 return GDALDataType::GDT_CInt16;
620 break;
621 case Qgis::DataType::CInt32:
622 return GDALDataType::GDT_CInt32;
623 break;
624 case Qgis::DataType::CFloat32:
625 return GDALDataType::GDT_CFloat32;
626 break;
627 case Qgis::DataType::CFloat64:
628 return GDALDataType::GDT_CFloat64;
629 break;
630 case Qgis::DataType::ARGB32:
631 case Qgis::DataType::ARGB32_Premultiplied:
632 return GDALDataType::GDT_Unknown;
633 break;
634 };
635
636 return GDALDataType::GDT_Unknown;
637}
638
639GDALResampleAlg QgsGdalUtils::gdalResamplingAlgorithm( QgsRasterDataProvider::ResamplingMethod method )
640{
641 GDALResampleAlg eResampleAlg = GRA_NearestNeighbour;
642 switch ( method )
643 {
644 case QgsRasterDataProvider::ResamplingMethod::Nearest:
645 case QgsRasterDataProvider::ResamplingMethod::Gauss: // Gauss not available in GDALResampleAlg
646 eResampleAlg = GRA_NearestNeighbour;
647 break;
648
649 case QgsRasterDataProvider::ResamplingMethod::Bilinear:
650 eResampleAlg = GRA_Bilinear;
651 break;
652
653 case QgsRasterDataProvider::ResamplingMethod::Cubic:
654 eResampleAlg = GRA_Cubic;
655 break;
656
657 case QgsRasterDataProvider::ResamplingMethod::CubicSpline:
658 eResampleAlg = GRA_CubicSpline;
659 break;
660
661 case QgsRasterDataProvider::ResamplingMethod::Lanczos:
662 eResampleAlg = GRA_Lanczos;
663 break;
664
665 case QgsRasterDataProvider::ResamplingMethod::Average:
666 eResampleAlg = GRA_Average;
667 break;
668
669 case QgsRasterDataProvider::ResamplingMethod::Mode:
670 eResampleAlg = GRA_Mode;
671 break;
672 }
673
674 return eResampleAlg;
675}
676
677#ifndef QT_NO_NETWORKPROXY
678void QgsGdalUtils::setupProxy()
679{
680 // Check proxy configuration, they are application level but
681 // instead of adding an API and complex signal/slot connections
682 // given the limited cost of checking them on every provider instantiation
683 // we can do it here so that new settings are applied whenever a new layer
684 // is created.
685 const QgsSettings settings;
686 // Check that proxy is enabled
687 if ( settings.value( QStringLiteral( "proxy/proxyEnabled" ), false ).toBool() )
688 {
689 // Get the first configured proxy
690 QList<QNetworkProxy> proxies( QgsNetworkAccessManager::instance()->proxyFactory()->queryProxy( ) );
691 if ( ! proxies.isEmpty() )
692 {
693 const QNetworkProxy proxy( proxies.first() );
694 // TODO/FIXME: check excludes (the GDAL config options are global, we need a per-connection config option)
695 //QStringList excludes;
696 //excludes = settings.value( QStringLiteral( "proxy/proxyExcludedUrls" ), "" ).toStringList();
697
698 const QString proxyHost( proxy.hostName() );
699 const quint16 proxyPort( proxy.port() );
700
701 const QString proxyUser( proxy.user() );
702 const QString proxyPassword( proxy.password() );
703
704 if ( ! proxyHost.isEmpty() )
705 {
706 QString connection( proxyHost );
707 if ( proxyPort )
708 {
709 connection += ':' + QString::number( proxyPort );
710 }
711 CPLSetConfigOption( "GDAL_HTTP_PROXY", connection.toUtf8() );
712 if ( ! proxyUser.isEmpty( ) )
713 {
714 QString credentials( proxyUser );
715 if ( ! proxyPassword.isEmpty( ) )
716 {
717 credentials += ':' + proxyPassword;
718 }
719 CPLSetConfigOption( "GDAL_HTTP_PROXYUSERPWD", credentials.toUtf8() );
720 }
721 }
722 }
723 }
724}
725
726bool QgsGdalUtils::pathIsCheapToOpen( const QString &path, int smallFileSizeLimit )
727{
728 const QFileInfo info( path );
729 const long long size = info.size();
730
731 // if size could not be determined, safest to flag path as expensive
732 if ( size == 0 )
733 return false;
734
735 const QString suffix = info.suffix().toLower();
736 static const QStringList sFileSizeDependentExtensions
737 {
738 QStringLiteral( "xlsx" ),
739 QStringLiteral( "ods" ),
740 QStringLiteral( "csv" )
741 };
742 if ( sFileSizeDependentExtensions.contains( suffix ) )
743 {
744 // path corresponds to a file type which is only cheap to open for small files
745 return size < smallFileSizeLimit;
746 }
747
748 // treat all other formats as expensive.
749 // TODO -- flag formats which only require a quick header parse as cheap
750 return false;
751}
752
753QStringList QgsGdalUtils::multiLayerFileExtensions()
754{
755#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3,4,0)
756 // get supported extensions
757 static std::once_flag initialized;
758 static QStringList SUPPORTED_DB_LAYERS_EXTENSIONS;
759 std::call_once( initialized, [ = ]
760 {
761 // iterate through all of the supported drivers, adding the corresponding file extensions for
762 // types which advertise multilayer support
763 GDALDriverH driver = nullptr;
764
765 QSet< QString > extensions;
766
767 for ( int i = 0; i < GDALGetDriverCount(); ++i )
768 {
769 driver = GDALGetDriver( i );
770 if ( !driver )
771 {
772 QgsLogger::warning( "unable to get driver " + QString::number( i ) );
773 continue;
774 }
775
776 bool isMultiLayer = false;
777 if ( QString( GDALGetMetadataItem( driver, GDAL_DCAP_RASTER, nullptr ) ) == QLatin1String( "YES" ) )
778 {
779 if ( GDALGetMetadataItem( driver, GDAL_DMD_SUBDATASETS, nullptr ) )
780 {
781 isMultiLayer = true;
782 }
783 }
784 if ( !isMultiLayer && QString( GDALGetMetadataItem( driver, GDAL_DCAP_VECTOR, nullptr ) ) == QLatin1String( "YES" ) )
785 {
786 if ( GDALGetMetadataItem( driver, GDAL_DCAP_MULTIPLE_VECTOR_LAYERS, nullptr ) )
787 {
788 isMultiLayer = true;
789 }
790 }
791
792 if ( !isMultiLayer )
793 continue;
794
795 const QString driverExtensions = GDALGetMetadataItem( driver, GDAL_DMD_EXTENSIONS, "" );
796 if ( driverExtensions.isEmpty() )
797 continue;
798
799 const QStringList splitExtensions = driverExtensions.split( ' ', Qt::SkipEmptyParts );
800
801 for ( const QString &ext : splitExtensions )
802 {
803 // maintain older behavior -- don't always expose tiff files as containers
804 if ( ext == QLatin1String( "tif" ) || ext == QLatin1String( "tiff" ) )
805 continue;
806
807 extensions.insert( ext );
808 }
809 }
810
811 SUPPORTED_DB_LAYERS_EXTENSIONS = QStringList( extensions.constBegin(), extensions.constEnd() );
812 } );
813 return SUPPORTED_DB_LAYERS_EXTENSIONS;
814
815#else
816 static const QStringList SUPPORTED_DB_LAYERS_EXTENSIONS
817 {
818 QStringLiteral( "gpkg" ),
819 QStringLiteral( "sqlite" ),
820 QStringLiteral( "db" ),
821 QStringLiteral( "gdb" ),
822 QStringLiteral( "kml" ),
823 QStringLiteral( "kmz" ),
824 QStringLiteral( "osm" ),
825 QStringLiteral( "mdb" ),
826 QStringLiteral( "accdb" ),
827 QStringLiteral( "xls" ),
828 QStringLiteral( "xlsx" ),
829 QStringLiteral( "ods" ),
830 QStringLiteral( "gpx" ),
831 QStringLiteral( "pdf" ),
832 QStringLiteral( "pbf" ),
833 QStringLiteral( "vrt" ),
834 QStringLiteral( "nc" ),
835 QStringLiteral( "dxf" ),
836 QStringLiteral( "shp.zip" ) };
837 return SUPPORTED_DB_LAYERS_EXTENSIONS;
838#endif
839}
840
841QString QgsGdalUtils::vsiPrefixForPath( const QString &path )
842{
843 const QStringList vsiPrefixes = QgsGdalUtils::vsiArchivePrefixes();
844
845 const thread_local QRegularExpression vsiRx( QStringLiteral( "^(/vsi.+?/)" ), QRegularExpression::PatternOption::CaseInsensitiveOption );
846 const QRegularExpressionMatch vsiMatch = vsiRx.match( path );
847 if ( vsiMatch.hasMatch() )
848 return vsiMatch.captured( 1 );
849
850 if ( path.endsWith( QLatin1String( ".shp.zip" ), Qt::CaseInsensitive ) )
851 {
852 // GDAL 3.1 Shapefile driver directly handles .shp.zip files
853 if ( GDALIdentifyDriverEx( path.toUtf8().constData(), GDAL_OF_VECTOR, nullptr, nullptr ) )
854 return QString();
855 return QStringLiteral( "/vsizip/" );
856 }
857 else if ( path.endsWith( QLatin1String( ".zip" ), Qt::CaseInsensitive ) )
858 {
859 // GTFS driver directly handles .zip files
860 const char *const apszAllowedDrivers[] = { "GTFS", nullptr };
861 if ( GDALIdentifyDriverEx( path.toUtf8().constData(), GDAL_OF_VECTOR, apszAllowedDrivers, nullptr ) )
862 return QString();
863 return QStringLiteral( "/vsizip/" );
864 }
865 else if ( path.endsWith( QLatin1String( ".tar" ), Qt::CaseInsensitive ) ||
866 path.endsWith( QLatin1String( ".tar.gz" ), Qt::CaseInsensitive ) ||
867 path.endsWith( QLatin1String( ".tgz" ), Qt::CaseInsensitive ) )
868 return QStringLiteral( "/vsitar/" );
869 else if ( path.endsWith( QLatin1String( ".gz" ), Qt::CaseInsensitive ) )
870 return QStringLiteral( "/vsigzip/" );
871#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3,7,0)
872 else if ( vsiPrefixes.contains( QStringLiteral( "/vsi7z/" ) ) &&
873 ( path.endsWith( QLatin1String( ".7z" ), Qt::CaseInsensitive ) ||
874 path.endsWith( QLatin1String( ".lpk" ), Qt::CaseInsensitive ) ||
875 path.endsWith( QLatin1String( ".lpkx" ), Qt::CaseInsensitive ) ||
876 path.endsWith( QLatin1String( ".mpk" ), Qt::CaseInsensitive ) ||
877 path.endsWith( QLatin1String( ".mpkx" ), Qt::CaseInsensitive ) ) )
878 return QStringLiteral( "/vsi7z/" );
879 else if ( vsiPrefixes.contains( QStringLiteral( "/vsirar/" ) ) &&
880 path.endsWith( QLatin1String( ".rar" ), Qt::CaseInsensitive ) )
881 return QStringLiteral( "/vsirar/" );
882#endif
883
884 return QString();
885}
886
887QStringList QgsGdalUtils::vsiArchivePrefixes()
888{
889 QStringList res { QStringLiteral( "/vsizip/" ),
890 QStringLiteral( "/vsitar/" ),
891 QStringLiteral( "/vsigzip/" ),
892 };
893#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3,7,0)
894 res.append( QStringLiteral( "/vsi7z/" ) );
895 res.append( QStringLiteral( "/vsirar/" ) );
896#endif
897 return res;
898}
899
900QList<QgsGdalUtils::VsiNetworkFileSystemDetails> QgsGdalUtils::vsiNetworkFileSystems()
901{
902 // get supported extensions
903 static std::once_flag initialized;
904 static QList<QgsGdalUtils::VsiNetworkFileSystemDetails> VSI_FILE_SYSTEM_DETAILS;
905 std::call_once( initialized, [ = ]
906 {
907 if ( char **papszPrefixes = VSIGetFileSystemsPrefixes() )
908 {
909 for ( int i = 0; papszPrefixes[i]; i++ )
910 {
911 QgsGdalUtils::VsiNetworkFileSystemDetails details;
912 details.identifier = QString( papszPrefixes[i] );
913 if ( details.identifier.startsWith( '/' ) )
914 details.identifier = details.identifier.mid( 1 );
915 if ( details.identifier.endsWith( '/' ) )
916 details.identifier.chop( 1 );
917
918 if ( details.identifier == QLatin1String( "vsicurl" ) )
919 details.name = QObject::tr( "HTTP/HTTPS/FTP" );
920 else if ( details.identifier == QLatin1String( "vsis3" ) )
921 details.name = QObject::tr( "AWS S3" );
922 else if ( details.identifier == QLatin1String( "vsigs" ) )
923 details.name = QObject::tr( "Google Cloud Storage" );
924 else if ( details.identifier == QLatin1String( "vsiaz" ) )
925 details.name = QObject::tr( "Microsoft Azure Blob" );
926 else if ( details.identifier == QLatin1String( "vsiadls" ) )
927 details.name = QObject::tr( "Microsoft Azure Data Lake Storage" );
928 else if ( details.identifier == QLatin1String( "vsioss" ) )
929 details.name = QObject::tr( "Alibaba Cloud OSS" );
930 else if ( details.identifier == QLatin1String( "vsiswift" ) )
931 details.name = QObject::tr( "OpenStack Swift Object Storage" );
932 else if ( details.identifier == QLatin1String( "vsihdfs" ) )
933 details.name = QObject::tr( "Hadoop File System" );
934 else
935 continue;
936 VSI_FILE_SYSTEM_DETAILS.append( details );
937 }
938
939 CSLDestroy( papszPrefixes );
940 }
941 } );
942
943 return VSI_FILE_SYSTEM_DETAILS;
944}
945
946bool QgsGdalUtils::isVsiArchivePrefix( const QString &prefix )
947{
948 return vsiArchivePrefixes().contains( prefix );
949}
950
951QStringList QgsGdalUtils::vsiArchiveFileExtensions()
952{
953 QStringList res { QStringLiteral( ".zip" ),
954 QStringLiteral( ".tar" ),
955 QStringLiteral( ".tar.gz" ),
956 QStringLiteral( ".tgz" ),
957 QStringLiteral( ".gz" ),
958 };
959#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3,7,0)
960 res.append( { QStringLiteral( ".7z" ),
961 QStringLiteral( ".lpk" ),
962 QStringLiteral( ".lpkx" ),
963 QStringLiteral( ".mpk" ),
964 QStringLiteral( ".mpkx" ),
965 QStringLiteral( ".rar" )
966 } );
967#endif
968 return res;
969}
970
971bool QgsGdalUtils::isVsiArchiveFileExtension( const QString &extension )
972{
973 const QString extWithDot = extension.startsWith( '.' ) ? extension : ( '.' + extension );
974 return vsiArchiveFileExtensions().contains( extWithDot.toLower() );
975}
976
977Qgis::VsiHandlerType QgsGdalUtils::vsiHandlerType( const QString &prefix )
978{
979 if ( prefix.isEmpty() )
980 return Qgis::VsiHandlerType::Invalid;
981
982 QString vsiPrefix = prefix;
983 if ( vsiPrefix.startsWith( '/' ) )
984 vsiPrefix = vsiPrefix.mid( 1 );
985 if ( vsiPrefix.endsWith( '/' ) )
986 vsiPrefix.chop( 1 );
987
988 if ( !vsiPrefix.startsWith( QLatin1String( "vsi" ) ) )
989 return Qgis::VsiHandlerType::Invalid;
990
991 if ( vsiPrefix == QLatin1String( "vsizip" ) ||
992 vsiPrefix == QLatin1String( "vsigzip" ) ||
993 vsiPrefix == QLatin1String( "vsitar" ) ||
994 vsiPrefix == QLatin1String( "vsi7z" ) ||
995 vsiPrefix == QLatin1String( "vsirar" ) )
996 return Qgis::VsiHandlerType::Archive;
997
998 else if ( vsiPrefix == QLatin1String( "vsicurl" ) ||
999 vsiPrefix == QLatin1String( "vsicurl_streaming" ) )
1000 return Qgis::VsiHandlerType::Network;
1001
1002 else if ( vsiPrefix == QLatin1String( "vsis3" ) ||
1003 vsiPrefix == QLatin1String( "vsicurl_streaming" ) ||
1004 vsiPrefix == QLatin1String( "vsigs" ) ||
1005 vsiPrefix == QLatin1String( "vsigs_streaming" ) ||
1006 vsiPrefix == QLatin1String( "vsiaz" ) ||
1007 vsiPrefix == QLatin1String( "vsiaz_streaming" ) ||
1008 vsiPrefix == QLatin1String( "vsiadls" ) ||
1009 vsiPrefix == QLatin1String( "vsioss" ) ||
1010 vsiPrefix == QLatin1String( "vsioss_streaming" ) ||
1011 vsiPrefix == QLatin1String( "vsiswift" ) ||
1012 vsiPrefix == QLatin1String( "vsiswift_streaming" ) ||
1013 vsiPrefix == QLatin1String( "vsihdfs" ) ||
1014 vsiPrefix == QLatin1String( "vsiwebhdfs" ) )
1015 return Qgis::VsiHandlerType::Cloud;
1016
1017 else if ( vsiPrefix == QLatin1String( "vsimem" ) )
1018 return Qgis::VsiHandlerType::Memory;
1019
1020 return Qgis::VsiHandlerType::Other;
1021}
1022
1023bool QgsGdalUtils::vrtMatchesLayerType( const QString &vrtPath, Qgis::LayerType type )
1024{
1025 CPLPushErrorHandler( CPLQuietErrorHandler );
1026 CPLErrorReset();
1027 GDALDriverH hDriver = nullptr;
1028
1029 switch ( type )
1030 {
1031 case Qgis::LayerType::Vector:
1032 hDriver = GDALIdentifyDriverEx( vrtPath.toUtf8().constData(), GDAL_OF_VECTOR, nullptr, nullptr );
1033 break;
1034
1035 case Qgis::LayerType::Raster:
1036 hDriver = GDALIdentifyDriverEx( vrtPath.toUtf8().constData(), GDAL_OF_RASTER, nullptr, nullptr );
1037 break;
1038
1039 case Qgis::LayerType::Plugin:
1040 case Qgis::LayerType::Mesh:
1041 case Qgis::LayerType::VectorTile:
1042 case Qgis::LayerType::Annotation:
1043 case Qgis::LayerType::PointCloud:
1044 case Qgis::LayerType::Group:
1045 case Qgis::LayerType::TiledScene:
1046 break;
1047 }
1048
1049 CPLPopErrorHandler();
1050 return static_cast< bool >( hDriver );
1051}
1052
1053QString QgsGdalUtils::gdalDocumentationUrlForDriver( GDALDriverH hDriver )
1054{
1055 if ( hDriver )
1056 {
1057 const QString gdalDriverHelpTopic = GDALGetMetadataItem( hDriver, GDAL_DMD_HELPTOPIC, nullptr ); // e.g. "drivers/vector/ili.html"
1058 if ( !gdalDriverHelpTopic.isEmpty() )
1059 return QStringLiteral( "https://gdal.org/%1" ).arg( gdalDriverHelpTopic );
1060 }
1061 return QString();
1062}
1063
1064bool QgsGdalUtils::applyVsiCredentialOptions( const QString &prefix, const QString &path, const QVariantMap &options )
1065{
1066 QString vsiPrefix = prefix;
1067 if ( !vsiPrefix.startsWith( '/' ) )
1068 vsiPrefix.prepend( '/' );
1069 if ( !vsiPrefix.endsWith( '/' ) )
1070 vsiPrefix.append( '/' );
1071
1072 QString vsiPath = path;
1073 if ( vsiPath.endsWith( '/' ) )
1074 vsiPath.chop( 1 );
1075
1076 const QString bucket = vsiPrefix + vsiPath;
1077
1078 for ( auto it = options.constBegin(); it != options.constEnd(); ++it )
1079 {
1080#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3, 6, 0)
1081 VSISetPathSpecificOption( bucket.toUtf8().constData(), it.key().toUtf8().constData(), it.value().toString().toUtf8().constData() );
1082#elif GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3, 5, 0)
1083 VSISetCredential( bucket.toUtf8().constData(), it.key().toUtf8().constData(), it.value().toString().toUtf8().constData() );
1084#else
1085 ( void )bucket;
1086 QgsMessageLog::logMessage( QObject::tr( "Cannot use VSI credential options on GDAL versions earlier than 3.5" ), QStringLiteral( "GDAL" ), Qgis::MessageLevel::Critical );
1087 return false;
1088#endif
1089 }
1090 return true;
1091}
1092#endif
Qgis::VsiHandlerType
VsiHandlerType
GDAL VSI handler types.
Definition qgis.h:5342
Qgis::VsiHandlerType::Memory
@ Memory
In-memory types (e.g. vsimem)
Qgis::VsiHandlerType::Invalid
@ Invalid
Invalid type, i.e. not a valid VSI handler.
Qgis::VsiHandlerType::Other
@ Other
All other types.
Qgis::VsiHandlerType::Cloud
@ Cloud
Specific cloud provider types (e.g. vsis3)
Qgis::VsiHandlerType::Archive
@ Archive
File archive type (e.g. vsizip)
Qgis::VsiHandlerType::Network
@ Network
Generic network types (e.g. vsicurl)
Qgis::Critical
@ Critical
Critical/error message.
Definition qgis.h:157
Qgis::DataType
DataType
Raster data types.
Definition qgis.h:351
Qgis::DataType::CInt32
@ CInt32
Complex Int32.
Qgis::DataType::Float32
@ Float32
Thirty two bit floating point (float)
Qgis::DataType::CFloat64
@ CFloat64
Complex Float64.
Qgis::DataType::Int16
@ Int16
Sixteen bit signed integer (qint16)
Qgis::DataType::ARGB32_Premultiplied
@ ARGB32_Premultiplied
Color, alpha, red, green, blue, 4 bytes the same as QImage::Format_ARGB32_Premultiplied.
Qgis::DataType::Int8
@ Int8
Eight bit signed integer (qint8) (added in QGIS 3.30)
Qgis::DataType::UInt16
@ UInt16
Sixteen bit unsigned integer (quint16)
Qgis::DataType::Byte
@ Byte
Eight bit unsigned integer (quint8)
Qgis::DataType::UnknownDataType
@ UnknownDataType
Unknown or unspecified type.
Qgis::DataType::ARGB32
@ ARGB32
Color, alpha, red, green, blue, 4 bytes the same as QImage::Format_ARGB32.
Qgis::DataType::Int32
@ Int32
Thirty two bit signed integer (qint32)
Qgis::DataType::Float64
@ Float64
Sixty four bit floating point (double)
Qgis::DataType::CFloat32
@ CFloat32
Complex Float32.
Qgis::DataType::CInt16
@ CInt16
Complex Int16.
Qgis::DataType::UInt32
@ UInt32
Thirty two bit unsigned integer (quint32)
Qgis::LayerType
LayerType
Types of layers that can be added to a map.
Definition qgis.h:169
Qgis::LayerType::Group
@ Group
Composite group layer. Added in QGIS 3.24.
Qgis::LayerType::Plugin
@ Plugin
Plugin based layer.
Qgis::LayerType::TiledScene
@ TiledScene
Tiled scene layer. Added in QGIS 3.34.
Qgis::LayerType::Annotation
@ Annotation
Contains freeform, georeferenced annotations. Added in QGIS 3.16.
Qgis::LayerType::Vector
@ Vector
Vector layer.
Qgis::LayerType::VectorTile
@ VectorTile
Vector tile layer. Added in QGIS 3.14.
Qgis::LayerType::Mesh
@ Mesh
Mesh layer. Added in QGIS 3.2.
Qgis::LayerType::Raster
@ Raster
Raster layer.
Qgis::LayerType::PointCloud
@ PointCloud
Point cloud layer. Added in QGIS 3.18.
Qgis::CrsWktVariant::PreferredGdal
@ PreferredGdal
Preferred format for conversion of CRS to WKT for use with the GDAL library.
QgsCoordinateReferenceSystem
This class represents a coordinate reference system (CRS).
Definition qgscoordinatereferencesystem.h:212
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:2053
QgsGdalOption
Encapsulates the definition of a GDAL configuration option.
Definition qgsgdalutils.h:36
QgsGdalOption::defaultValue
QVariant defaultValue
Default value.
Definition qgsgdalutils.h:65
QgsGdalOption::maximum
QVariant maximum
Maximum acceptable value.
Definition qgsgdalutils.h:71
QgsGdalOption::name
QString name
Option name.
Definition qgsgdalutils.h:53
QgsGdalOption::options
QStringList options
Available choices, for Select options.
Definition qgsgdalutils.h:62
QgsGdalOption::minimum
QVariant minimum
Minimum acceptable value.
Definition qgsgdalutils.h:68
QgsGdalOption::Type::Int
@ Int
Integer option.
QgsGdalOption::Type::Boolean
@ Boolean
Boolean option.
QgsGdalOption::Type::Invalid
@ Invalid
Invalid option.
QgsGdalOption::Type::Text
@ Text
Text option.
QgsGdalOption::Type::Double
@ Double
Double option.
QgsGdalOption::Type::Select
@ Select
Selection option.
QgsGdalOption::scope
QString scope
Option scope.
Definition qgsgdalutils.h:74
QgsGdalOption::optionsFromXml
static QList< QgsGdalOption > optionsFromXml(const CPLXMLNode *node)
Returns a list of all GDAL options from an XML node.
Definition qgsgdalutils.cpp:143
QgsGdalOption::fromXmlNode
static QgsGdalOption fromXmlNode(const CPLXMLNode *node)
Creates a QgsGdalOption from an XML node.
Definition qgsgdalutils.cpp:36
QgsGdalOption::description
QString description
Option description.
Definition qgsgdalutils.h:59
QgsGdalOption::type
Type type
Option type.
Definition qgsgdalutils.h:56
QgsGdalUtils::vsiHandlerType
static Qgis::VsiHandlerType vsiHandlerType(const QString &prefix)
Returns the VSI handler type for a given VSI prefix.
Definition qgsgdalutils.cpp:977
QgsGdalUtils::applyVsiCredentialOptions
static bool applyVsiCredentialOptions(const QString &prefix, const QString &path, const QVariantMap &options)
Attempts to apply VSI credential options.
Definition qgsgdalutils.cpp:1064
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:726
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:841
QgsGdalUtils::helpCreationOptionsFormat
static QString helpCreationOptionsFormat(const QString &format)
Gets creation options metadata for a given format.
Definition qgsgdalutils.cpp:490
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:1023
QgsGdalUtils::gdalResamplingAlgorithm
static GDALResampleAlg gdalResamplingAlgorithm(QgsRasterDataProvider::ResamplingMethod method)
Returns the GDAL resampling method corresponding to the QGIS resampling method.
Definition qgsgdalutils.cpp:639
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:412
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:548
QgsGdalUtils::supportsRasterCreate
static bool supportsRasterCreate(GDALDriverH driver)
Reads whether a driver supports GDALCreate() for raster purposes.
Definition qgsgdalutils.cpp:162
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:971
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:205
QgsGdalUtils::gdalDataTypeFromQgisDataType
static GDALDataType gdalDataTypeFromQgisDataType(Qgis::DataType dataType)
Returns the GDAL data type corresponding to the QGIS data type dataType.
Definition qgsgdalutils.cpp:583
QgsGdalUtils::isVsiArchivePrefix
static bool isVsiArchivePrefix(const QString &prefix)
Returns true if prefix is a supported archive style container prefix (e.g.
Definition qgsgdalutils.cpp:946
QgsGdalUtils::gdalDocumentationUrlForDriver
static QString gdalDocumentationUrlForDriver(GDALDriverH hDriver)
Returns the URL for the GDAL documentation for the specified driver.
Definition qgsgdalutils.cpp:1053
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:175
QgsGdalUtils::validateCreationOptionsFormat
static QString validateCreationOptionsFormat(const QStringList &createOptions, const QString &format)
Validates creation options for a given format, regardless of layer.
Definition qgsgdalutils.cpp:532
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:280
QgsGdalUtils::vsiNetworkFileSystems
static QList< VsiNetworkFileSystemDetails > vsiNetworkFileSystems()
Returns a list of available GDAL VSI network file systems.
Definition qgsgdalutils.cpp:900
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:236
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:568
QgsGdalUtils::setupProxy
static void setupProxy()
Sets the gdal proxy variables.
Definition qgsgdalutils.cpp:678
QgsGdalUtils::vsiArchiveFileExtensions
static QStringList vsiArchiveFileExtensions()
Returns a list of file extensions which correspond to archive style containers supported by GDAL (e....
Definition qgsgdalutils.cpp:951
QgsGdalUtils::papszFromStringList
static char ** papszFromStringList(const QStringList &list)
Helper function.
Definition qgsgdalutils.cpp:521
QgsGdalUtils::resampleImage
static QImage resampleImage(const QImage &image, QSize outputSize, GDALRIOResampleAlg resampleAlg)
Resamples a QImage image using GDAL resampler.
Definition qgsgdalutils.cpp:439
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:180
QgsGdalUtils::multiLayerFileExtensions
static QStringList multiLayerFileExtensions()
Returns a list of file extensions which potentially contain multiple layers representing GDAL raster ...
Definition qgsgdalutils.cpp:753
QgsGdalUtils::vsiArchivePrefixes
static QStringList vsiArchivePrefixes()
Returns a list of vsi prefixes which correspond to archive style containers (eg vsizip).
Definition qgsgdalutils.cpp:887
QgsLogger::warning
static void warning(const QString &msg)
Goes to qWarning.
Definition qgslogger.cpp:131
QgsMessageLog::logMessage
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::MessageLevel::Warning, bool notifyUser=true)
Adds a message to the log instance (and creates it if necessary).
Definition qgsmessagelog.cpp:28
QgsNetworkAccessManager::instance
static QgsNetworkAccessManager * instance(Qt::ConnectionType connectionType=Qt::BlockingQueuedConnection)
Returns a pointer to the active QgsNetworkAccessManager for the current thread.
Definition qgsnetworkaccessmanager.cpp:197
QgsPointXY
A class to represent a 2D point.
Definition qgspointxy.h:60
QgsPointXY::y
double y
Definition qgspointxy.h:64
QgsPointXY::x
double x
Definition qgspointxy.h:63
QgsRasterBlock
Raster data container.
Definition qgsrasterblock.h:37
QgsRasterBlock::height
int height() const
Returns the height (number of rows) of the raster block.
Definition qgsrasterblock.h:676
QgsRasterBlock::bits
char * bits(int row, int column)
Returns a pointer to block data.
Definition qgsrasterblock.cpp:548
QgsRasterBlock::noDataValue
double noDataValue() const
Returns no data value.
Definition qgsrasterblock.h:185
QgsRasterBlock::dataType
Qgis::DataType dataType() const
Returns data type.
Definition qgsrasterblock.h:135
QgsRasterBlock::width
int width() const
Returns the width (number of columns) of the raster block.
Definition qgsrasterblock.h:670
QgsRasterDataProvider::ResamplingMethod
ResamplingMethod
Resampling method for provider-level resampling.
Definition qgsrasterdataprovider.h:631
QgsRasterDataProvider::ResamplingMethod::Lanczos
@ Lanczos
Lanczos windowed sinc interpolation (6x6 kernel)
QgsRasterDataProvider::ResamplingMethod::Nearest
@ Nearest
Nearest-neighbour resampling.
QgsRasterDataProvider::ResamplingMethod::Mode
@ Mode
Mode (selects the value which appears most often of all the sampled points)
QgsRasterDataProvider::ResamplingMethod::Bilinear
@ Bilinear
Bilinear (2x2 kernel) resampling.
QgsRasterDataProvider::ResamplingMethod::CubicSpline
@ CubicSpline
Cubic B-Spline Approximation (4x4 kernel)
QgsRasterDataProvider::ResamplingMethod::Cubic
@ Cubic
Cubic Convolution Approximation (4x4 kernel) resampling.
QgsRectangle
A rectangle specified with double values.
Definition qgsrectangle.h:42
QgsRectangle::xMinimum
double xMinimum() const
Returns the x minimum value (left side of rectangle).
Definition qgsrectangle.h:200
QgsRectangle::yMinimum
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
Definition qgsrectangle.h:210
QgsRectangle::width
double width() const
Returns the width of the rectangle.
Definition qgsrectangle.h:235
QgsRectangle::height
double height() const
Returns the height of the rectangle.
Definition qgsrectangle.h:242
QgsSettings
This class is a composition of two QSettings instances:
Definition qgssettings.h:64
QgsSettings::value
QVariant value(const QString &key, const QVariant &defaultValue=QVariant(), Section section=NoSection) const
Returns the value for setting key.
Definition qgssettings.cpp:175
gdal::dataset_unique_ptr
std::unique_ptr< std::remove_pointer< GDALDatasetH >::type, GDALDatasetCloser > dataset_unique_ptr
Scoped GDAL dataset.
Definition qgsogrutils.h:157
gdal::warp_options_unique_ptr
std::unique_ptr< GDALWarpOptions, GDALWarpOptionsDeleter > warp_options_unique_ptr
Scoped GDAL warp options.
Definition qgsogrutils.h:172
GDALDatasetH
void * GDALDatasetH
Definition qgsalignraster.h:31
QgsDebugError
#define QgsDebugError(str)
Definition qgslogger.h:38
crs
const QgsCoordinateReferenceSystem & crs
Definition qgswfsgetfeature.cpp:53
QgsGdalUtils::VsiNetworkFileSystemDetails
Encapsulates details for a GDAL VSI network file system.
Definition qgsgdalutils.h:308
QgsGdalUtils::VsiNetworkFileSystemDetails::name
QString name
Translated, user-friendly name.
Definition qgsgdalutils.h:313
QgsGdalUtils::VsiNetworkFileSystemDetails::identifier
QString identifier
VSI handler identifier, eg "vsis3".
Definition qgsgdalutils.h:310
Generated on Tue Nov 19 2024 18:20:01 for QGIS API Documentation by doxygen 1.9.8