QGIS API Documentation 3.39.0-Master (52f98f8c831)
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 == nullptr )
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 {
167 // it supports Create() but only for vector side
168 return false;
169 }
170 return GDALGetMetadataItem( driver, GDAL_DCAP_CREATE, nullptr ) &&
171 GDALGetMetadataItem( driver, GDAL_DCAP_RASTER, nullptr );
172}
173
174gdal::dataset_unique_ptr QgsGdalUtils::createSingleBandMemoryDataset( GDALDataType dataType, const QgsRectangle &extent, int width, int height, const QgsCoordinateReferenceSystem &crs )
175{
176 return createMultiBandMemoryDataset( dataType, 1, extent, width, height, crs );
177}
178
179gdal::dataset_unique_ptr QgsGdalUtils::createMultiBandMemoryDataset( GDALDataType dataType, int bands, const QgsRectangle &extent, int width, int height, const QgsCoordinateReferenceSystem &crs )
180{
181 GDALDriverH hDriverMem = GDALGetDriverByName( "MEM" );
182 if ( !hDriverMem )
183 {
184 return gdal::dataset_unique_ptr();
185 }
186
187 gdal::dataset_unique_ptr hSrcDS( GDALCreate( hDriverMem, "", width, height, bands, dataType, nullptr ) );
188
189 const double cellSizeX = extent.width() / width;
190 const double cellSizeY = extent.height() / height;
191 double geoTransform[6];
192 geoTransform[0] = extent.xMinimum();
193 geoTransform[1] = cellSizeX;
194 geoTransform[2] = 0;
195 geoTransform[3] = extent.yMinimum() + ( cellSizeY * height );
196 geoTransform[4] = 0;
197 geoTransform[5] = -cellSizeY;
198
199 GDALSetProjection( hSrcDS.get(), crs.toWkt( Qgis::CrsWktVariant::PreferredGdal ).toLatin1().constData() );
200 GDALSetGeoTransform( hSrcDS.get(), geoTransform );
201 return hSrcDS;
202}
203
204gdal::dataset_unique_ptr QgsGdalUtils::createSingleBandTiffDataset( const QString &filename, GDALDataType dataType, const QgsRectangle &extent, int width, int height, const QgsCoordinateReferenceSystem &crs )
205{
206 const double cellSizeX = extent.width() / width;
207 const double cellSizeY = extent.height() / height;
208 double geoTransform[6];
209 geoTransform[0] = extent.xMinimum();
210 geoTransform[1] = cellSizeX;
211 geoTransform[2] = 0;
212 geoTransform[3] = extent.yMinimum() + ( cellSizeY * height );
213 geoTransform[4] = 0;
214 geoTransform[5] = -cellSizeY;
215
216 GDALDriverH hDriver = GDALGetDriverByName( "GTiff" );
217 if ( !hDriver )
218 {
219 return gdal::dataset_unique_ptr();
220 }
221
222 // Create the output file.
223 gdal::dataset_unique_ptr hDstDS( GDALCreate( hDriver, filename.toUtf8().constData(), width, height, 1, dataType, nullptr ) );
224 if ( !hDstDS )
225 {
226 return gdal::dataset_unique_ptr();
227 }
228
229 // Write out the projection definition.
230 GDALSetProjection( hDstDS.get(), crs.toWkt( Qgis::CrsWktVariant::PreferredGdal ).toLatin1().constData() );
231 GDALSetGeoTransform( hDstDS.get(), geoTransform );
232 return hDstDS;
233}
234
235gdal::dataset_unique_ptr QgsGdalUtils::imageToMemoryDataset( const QImage &image )
236{
237 if ( image.isNull() )
238 return nullptr;
239
240 const QRgb *rgb = reinterpret_cast<const QRgb *>( image.constBits() );
241 GDALDriverH hDriverMem = GDALGetDriverByName( "MEM" );
242 if ( !hDriverMem )
243 {
244 return nullptr;
245 }
246 gdal::dataset_unique_ptr hSrcDS( GDALCreate( hDriverMem, "", image.width(), image.height(), 0, GDT_Byte, nullptr ) );
247
248 char **papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
249 << QStringLiteral( "PIXELOFFSET=%1" ).arg( sizeof( QRgb ) )
250 << QStringLiteral( "LINEOFFSET=%1" ).arg( image.bytesPerLine() )
251 << QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( rgb ) + 2 ) );
252 GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );
253 CSLDestroy( papszOptions );
254
255 papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
256 << QStringLiteral( "PIXELOFFSET=%1" ).arg( sizeof( QRgb ) )
257 << QStringLiteral( "LINEOFFSET=%1" ).arg( image.bytesPerLine() )
258 << QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( rgb ) + 1 ) );
259 GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );
260 CSLDestroy( papszOptions );
261
262 papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
263 << QStringLiteral( "PIXELOFFSET=%1" ).arg( sizeof( QRgb ) )
264 << QStringLiteral( "LINEOFFSET=%1" ).arg( image.bytesPerLine() )
265 << QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( rgb ) ) );
266 GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );
267 CSLDestroy( papszOptions );
268
269 papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
270 << QStringLiteral( "PIXELOFFSET=%1" ).arg( sizeof( QRgb ) )
271 << QStringLiteral( "LINEOFFSET=%1" ).arg( image.bytesPerLine() )
272 << QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( rgb ) + 3 ) );
273 GDALAddBand( hSrcDS.get(), GDT_Byte, papszOptions );
274 CSLDestroy( papszOptions );
275
276 return hSrcDS;
277}
278
279gdal::dataset_unique_ptr QgsGdalUtils::blockToSingleBandMemoryDataset( int pixelWidth, int pixelHeight, const QgsRectangle &extent, void *block, GDALDataType dataType )
280{
281 if ( !block )
282 return nullptr;
283
284 GDALDriverH hDriverMem = GDALGetDriverByName( "MEM" );
285 if ( !hDriverMem )
286 return nullptr;
287
288 const double cellSizeX = extent.width() / pixelWidth;
289 const double cellSizeY = extent.height() / pixelHeight;
290 double geoTransform[6];
291 geoTransform[0] = extent.xMinimum();
292 geoTransform[1] = cellSizeX;
293 geoTransform[2] = 0;
294 geoTransform[3] = extent.yMinimum() + ( cellSizeY * pixelHeight );
295 geoTransform[4] = 0;
296 geoTransform[5] = -cellSizeY;
297
298 gdal::dataset_unique_ptr hDstDS( GDALCreate( hDriverMem, "", pixelWidth, pixelHeight, 0, dataType, nullptr ) );
299
300 int dataTypeSize = GDALGetDataTypeSizeBytes( dataType );
301 char **papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
302 << QStringLiteral( "PIXELOFFSET=%1" ).arg( dataTypeSize )
303 << QStringLiteral( "LINEOFFSET=%1" ).arg( pixelWidth * dataTypeSize )
304 << QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( block ) ) );
305 GDALAddBand( hDstDS.get(), dataType, papszOptions );
306 CSLDestroy( papszOptions );
307
308 GDALSetGeoTransform( hDstDS.get(), geoTransform );
309
310 return hDstDS;
311}
312
313gdal::dataset_unique_ptr QgsGdalUtils::blockToSingleBandMemoryDataset( const QgsRectangle &extent, QgsRasterBlock *block )
314{
315 if ( !block )
316 return nullptr;
317
318 gdal::dataset_unique_ptr ret = blockToSingleBandMemoryDataset( block->width(), block->height(), extent, block->bits(), gdalDataTypeFromQgisDataType( block->dataType() ) );
319 if ( ret )
320 {
321 GDALRasterBandH band = GDALGetRasterBand( ret.get(), 1 );
322 if ( band )
323 GDALSetRasterNoDataValue( band, block->noDataValue() );
324 }
325
326 return ret;
327}
328
329
330
331gdal::dataset_unique_ptr QgsGdalUtils::blockToSingleBandMemoryDataset( double rotation,
332 const QgsPointXY &origin,
333 double gridXSize,
334 double gridYSize,
335 QgsRasterBlock *block )
336{
337 if ( !block )
338 return nullptr;
339
340 GDALDriverH hDriverMem = GDALGetDriverByName( "MEM" );
341 if ( !hDriverMem )
342 return nullptr;
343
344 const double cellSizeX = gridXSize / block->width();
345 const double cellSizeY = gridYSize / block->height();
346 double geoTransform[6];
347 geoTransform[0] = origin.x();
348 geoTransform[1] = cellSizeX * std::cos( rotation );
349 geoTransform[2] = cellSizeY * std::sin( rotation );
350 geoTransform[3] = origin.y();
351 geoTransform[4] = cellSizeX * std::sin( rotation );
352 geoTransform[5] = -cellSizeY * std::cos( rotation );
353
354 GDALDataType dataType = gdalDataTypeFromQgisDataType( block->dataType() );
355 gdal::dataset_unique_ptr hDstDS( GDALCreate( hDriverMem, "", block->width(), block->height(), 0, dataType, nullptr ) );
356
357 int dataTypeSize = GDALGetDataTypeSizeBytes( dataType );
358 char **papszOptions = QgsGdalUtils::papszFromStringList( QStringList()
359 << QStringLiteral( "PIXELOFFSET=%1" ).arg( dataTypeSize )
360 << QStringLiteral( "LINEOFFSET=%1" ).arg( block->width() * dataTypeSize )
361 << QStringLiteral( "DATAPOINTER=%1" ).arg( reinterpret_cast< qulonglong >( block->bits() ) ) );
362 GDALAddBand( hDstDS.get(), dataType, papszOptions );
363 CSLDestroy( papszOptions );
364
365 GDALSetGeoTransform( hDstDS.get(), geoTransform );
366
367 GDALRasterBandH band = GDALGetRasterBand( hDstDS.get(), 1 );
368 if ( band )
369 GDALSetRasterNoDataValue( band, block->noDataValue() );
370
371 return hDstDS;
372}
373
374static bool resampleSingleBandRasterStatic( GDALDatasetH hSrcDS, GDALDatasetH hDstDS, GDALResampleAlg resampleAlg, char **papszOptions )
375{
376 gdal::warp_options_unique_ptr psWarpOptions( GDALCreateWarpOptions() );
377 psWarpOptions->hSrcDS = hSrcDS;
378 psWarpOptions->hDstDS = hDstDS;
379
380 psWarpOptions->nBandCount = 1;
381 psWarpOptions->panSrcBands = reinterpret_cast< int * >( CPLMalloc( sizeof( int ) * 1 ) );
382 psWarpOptions->panDstBands = reinterpret_cast< int * >( CPLMalloc( sizeof( int ) * 1 ) );
383 psWarpOptions->panSrcBands[0] = 1;
384 psWarpOptions->panDstBands[0] = 1;
385 double noDataValue = GDALGetRasterNoDataValue( GDALGetRasterBand( hDstDS, 1 ), nullptr );
386 psWarpOptions->padfDstNoDataReal = reinterpret_cast< double * >( CPLMalloc( sizeof( double ) * 1 ) );
387 psWarpOptions->padfDstNoDataReal[0] = noDataValue;
388 psWarpOptions->eResampleAlg = resampleAlg;
389
390 // Establish reprojection transformer.
391 psWarpOptions->pTransformerArg = GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, papszOptions );
392
393 if ( ! psWarpOptions->pTransformerArg )
394 {
395 return false;
396 }
397
398 psWarpOptions->pfnTransformer = GDALGenImgProjTransform;
399 psWarpOptions->papszWarpOptions = CSLSetNameValue( psWarpOptions-> papszWarpOptions, "INIT_DEST", "NO_DATA" );
400
401 // Initialize and execute the warp operation.
402 bool retVal = false;
403 GDALWarpOperation oOperation;
404 CPLErr initResult = oOperation.Initialize( psWarpOptions.get() );
405 if ( initResult != CE_Failure )
406 retVal = oOperation.ChunkAndWarpImage( 0, 0, GDALGetRasterXSize( hDstDS ), GDALGetRasterYSize( hDstDS ) ) == CE_None;
407 GDALDestroyGenImgProjTransformer( psWarpOptions->pTransformerArg );
408 return retVal;
409}
410
411bool QgsGdalUtils::resampleSingleBandRaster( GDALDatasetH hSrcDS, GDALDatasetH hDstDS, GDALResampleAlg resampleAlg, const char *pszCoordinateOperation )
412{
413 char **papszOptions = nullptr;
414 if ( pszCoordinateOperation != nullptr )
415 papszOptions = CSLSetNameValue( papszOptions, "COORDINATE_OPERATION", pszCoordinateOperation );
416
417 bool result = resampleSingleBandRasterStatic( hSrcDS, hDstDS, resampleAlg, papszOptions );
418 CSLDestroy( papszOptions );
419 return result;
420}
421
422bool QgsGdalUtils::resampleSingleBandRaster( GDALDatasetH hSrcDS,
423 GDALDatasetH hDstDS,
424 GDALResampleAlg resampleAlg,
425 const QgsCoordinateReferenceSystem &sourceCrs,
426 const QgsCoordinateReferenceSystem &destinationCrs )
427{
428 char **papszOptions = nullptr;
429
430 papszOptions = CSLSetNameValue( papszOptions, "SRC_SRS", sourceCrs.toWkt( Qgis::CrsWktVariant::PreferredGdal ).toUtf8().constData() );
431 papszOptions = CSLSetNameValue( papszOptions, "DST_SRS", destinationCrs.toWkt( Qgis::CrsWktVariant::PreferredGdal ).toUtf8().constData() );
432
433 bool result = resampleSingleBandRasterStatic( hSrcDS, hDstDS, resampleAlg, papszOptions );
434 CSLDestroy( papszOptions );
435 return result;
436}
437
438QImage QgsGdalUtils::resampleImage( const QImage &image, QSize outputSize, GDALRIOResampleAlg resampleAlg )
439{
440 const gdal::dataset_unique_ptr srcDS = QgsGdalUtils::imageToMemoryDataset( image );
441 if ( !srcDS )
442 return QImage();
443
444 GDALRasterIOExtraArg extra;
445 INIT_RASTERIO_EXTRA_ARG( extra );
446 extra.eResampleAlg = resampleAlg;
447
448 QImage res( outputSize, image.format() );
449 if ( res.isNull() )
450 return QImage();
451
452 GByte *rgb = reinterpret_cast<GByte *>( res.bits() );
453
454 CPLErr err = GDALRasterIOEx( GDALGetRasterBand( srcDS.get(), 1 ), GF_Read, 0, 0, image.width(), image.height(), rgb + 2, outputSize.width(),
455 outputSize.height(), GDT_Byte, sizeof( QRgb ), res.bytesPerLine(), &extra );
456 if ( err != CE_None )
457 {
458 QgsDebugError( QStringLiteral( "failed to read red band" ) );
459 return QImage();
460 }
461
462 err = GDALRasterIOEx( GDALGetRasterBand( srcDS.get(), 2 ), GF_Read, 0, 0, image.width(), image.height(), rgb + 1, outputSize.width(),
463 outputSize.height(), GDT_Byte, sizeof( QRgb ), res.bytesPerLine(), &extra );
464 if ( err != CE_None )
465 {
466 QgsDebugError( QStringLiteral( "failed to read green band" ) );
467 return QImage();
468 }
469
470 err = GDALRasterIOEx( GDALGetRasterBand( srcDS.get(), 3 ), GF_Read, 0, 0, image.width(), image.height(), rgb, outputSize.width(),
471 outputSize.height(), GDT_Byte, sizeof( QRgb ), res.bytesPerLine(), &extra );
472 if ( err != CE_None )
473 {
474 QgsDebugError( QStringLiteral( "failed to read blue band" ) );
475 return QImage();
476 }
477
478 err = GDALRasterIOEx( GDALGetRasterBand( srcDS.get(), 4 ), GF_Read, 0, 0, image.width(), image.height(), rgb + 3, outputSize.width(),
479 outputSize.height(), GDT_Byte, sizeof( QRgb ), res.bytesPerLine(), &extra );
480 if ( err != CE_None )
481 {
482 QgsDebugError( QStringLiteral( "failed to read alpha band" ) );
483 return QImage();
484 }
485
486 return res;
487}
488
489QString QgsGdalUtils::helpCreationOptionsFormat( const QString &format )
490{
491 QString message;
492 GDALDriverH myGdalDriver = GDALGetDriverByName( format.toLocal8Bit().constData() );
493 if ( myGdalDriver )
494 {
495 // first report details and help page
496 char **GDALmetadata = GDALGetMetadata( myGdalDriver, nullptr );
497 message += QLatin1String( "Format Details:\n" );
498 message += QStringLiteral( " Extension: %1\n" ).arg( CSLFetchNameValue( GDALmetadata, GDAL_DMD_EXTENSION ) );
499 message += QStringLiteral( " Short Name: %1" ).arg( GDALGetDriverShortName( myGdalDriver ) );
500 message += QStringLiteral( " / Long Name: %1\n" ).arg( GDALGetDriverLongName( myGdalDriver ) );
501 message += QStringLiteral( " Help page: http://www.gdal.org/%1\n\n" ).arg( CSLFetchNameValue( GDALmetadata, GDAL_DMD_HELPTOPIC ) );
502
503 // next get creation options
504 // need to serialize xml to get newlines, should we make the basic xml prettier?
505 CPLXMLNode *psCOL = CPLParseXMLString( GDALGetMetadataItem( myGdalDriver,
506 GDAL_DMD_CREATIONOPTIONLIST, "" ) );
507 char *pszFormattedXML = CPLSerializeXMLTree( psCOL );
508 if ( pszFormattedXML )
509 message += QString( pszFormattedXML );
510 if ( psCOL )
511 CPLDestroyXMLNode( psCOL );
512 if ( pszFormattedXML )
513 CPLFree( pszFormattedXML );
514 }
515 return message;
516}
517
518char **QgsGdalUtils::papszFromStringList( const QStringList &list )
519{
520 char **papszRetList = nullptr;
521 const auto constList = list;
522 for ( const QString &elem : constList )
523 {
524 papszRetList = CSLAddString( papszRetList, elem.toLocal8Bit().constData() );
525 }
526 return papszRetList;
527}
528
529QString QgsGdalUtils::validateCreationOptionsFormat( const QStringList &createOptions, const QString &format )
530{
531 GDALDriverH myGdalDriver = GDALGetDriverByName( format.toLocal8Bit().constData() );
532 if ( ! myGdalDriver )
533 return QStringLiteral( "invalid GDAL driver" );
534
535 char **papszOptions = papszFromStringList( createOptions );
536 // get error string?
537 const int ok = GDALValidateCreationOptions( myGdalDriver, papszOptions );
538 CSLDestroy( papszOptions );
539
540 if ( !ok )
541 return QStringLiteral( "Failed GDALValidateCreationOptions() test" );
542 return QString();
543}
544
545GDALDatasetH QgsGdalUtils::rpcAwareAutoCreateWarpedVrt(
546 GDALDatasetH hSrcDS,
547 const char *pszSrcWKT,
548 const char *pszDstWKT,
549 GDALResampleAlg eResampleAlg,
550 double dfMaxError,
551 const GDALWarpOptions *psOptionsIn )
552{
553 char **opts = nullptr;
554 if ( GDALGetMetadata( hSrcDS, "RPC" ) )
555 {
556 // well-behaved RPC should have height offset a good value for RPC_HEIGHT
557 const char *heightOffStr = GDALGetMetadataItem( hSrcDS, "HEIGHT_OFF", "RPC" );
558 if ( heightOffStr )
559 opts = CSLAddNameValue( opts, "RPC_HEIGHT", heightOffStr );
560 }
561
562 return GDALAutoCreateWarpedVRTEx( hSrcDS, pszSrcWKT, pszDstWKT, eResampleAlg, dfMaxError, psOptionsIn, opts );
563}
564
565void *QgsGdalUtils::rpcAwareCreateTransformer( GDALDatasetH hSrcDS, GDALDatasetH hDstDS, char **papszOptions )
566{
567 char **opts = CSLDuplicate( papszOptions );
568 if ( GDALGetMetadata( hSrcDS, "RPC" ) )
569 {
570 // well-behaved RPC should have height offset a good value for RPC_HEIGHT
571 const char *heightOffStr = GDALGetMetadataItem( hSrcDS, "HEIGHT_OFF", "RPC" );
572 if ( heightOffStr )
573 opts = CSLAddNameValue( opts, "RPC_HEIGHT", heightOffStr );
574 }
575 void *transformer = GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, opts );
576 CSLDestroy( opts );
577 return transformer;
578}
579
580GDALDataType QgsGdalUtils::gdalDataTypeFromQgisDataType( Qgis::DataType dataType )
581{
582 switch ( dataType )
583 {
584 case Qgis::DataType::UnknownDataType:
585 return GDALDataType::GDT_Unknown;
586 break;
587 case Qgis::DataType::Byte:
588 return GDALDataType::GDT_Byte;
589 break;
590 case Qgis::DataType::Int8:
591#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3,7,0)
592 return GDALDataType::GDT_Int8;
593#else
594 return GDALDataType::GDT_Unknown;
595#endif
596 break;
597 case Qgis::DataType::UInt16:
598 return GDALDataType::GDT_UInt16;
599 break;
600 case Qgis::DataType::Int16:
601 return GDALDataType::GDT_Int16;
602 break;
603 case Qgis::DataType::UInt32:
604 return GDALDataType::GDT_UInt32;
605 break;
606 case Qgis::DataType::Int32:
607 return GDALDataType::GDT_Int32;
608 break;
609 case Qgis::DataType::Float32:
610 return GDALDataType::GDT_Float32;
611 break;
612 case Qgis::DataType::Float64:
613 return GDALDataType::GDT_Float64;
614 break;
615 case Qgis::DataType::CInt16:
616 return GDALDataType::GDT_CInt16;
617 break;
618 case Qgis::DataType::CInt32:
619 return GDALDataType::GDT_CInt32;
620 break;
621 case Qgis::DataType::CFloat32:
622 return GDALDataType::GDT_CFloat32;
623 break;
624 case Qgis::DataType::CFloat64:
625 return GDALDataType::GDT_CFloat64;
626 break;
627 case Qgis::DataType::ARGB32:
628 case Qgis::DataType::ARGB32_Premultiplied:
629 return GDALDataType::GDT_Unknown;
630 break;
631 };
632
633 return GDALDataType::GDT_Unknown;
634}
635
636GDALResampleAlg QgsGdalUtils::gdalResamplingAlgorithm( QgsRasterDataProvider::ResamplingMethod method )
637{
638 GDALResampleAlg eResampleAlg = GRA_NearestNeighbour;
639 switch ( method )
640 {
641 case QgsRasterDataProvider::ResamplingMethod::Nearest:
642 case QgsRasterDataProvider::ResamplingMethod::Gauss: // Gauss not available in GDALResampleAlg
643 eResampleAlg = GRA_NearestNeighbour;
644 break;
645
646 case QgsRasterDataProvider::ResamplingMethod::Bilinear:
647 eResampleAlg = GRA_Bilinear;
648 break;
649
650 case QgsRasterDataProvider::ResamplingMethod::Cubic:
651 eResampleAlg = GRA_Cubic;
652 break;
653
654 case QgsRasterDataProvider::ResamplingMethod::CubicSpline:
655 eResampleAlg = GRA_CubicSpline;
656 break;
657
658 case QgsRasterDataProvider::ResamplingMethod::Lanczos:
659 eResampleAlg = GRA_Lanczos;
660 break;
661
662 case QgsRasterDataProvider::ResamplingMethod::Average:
663 eResampleAlg = GRA_Average;
664 break;
665
666 case QgsRasterDataProvider::ResamplingMethod::Mode:
667 eResampleAlg = GRA_Mode;
668 break;
669 }
670
671 return eResampleAlg;
672}
673
674#ifndef QT_NO_NETWORKPROXY
675void QgsGdalUtils::setupProxy()
676{
677 // Check proxy configuration, they are application level but
678 // instead of adding an API and complex signal/slot connections
679 // given the limited cost of checking them on every provider instantiation
680 // we can do it here so that new settings are applied whenever a new layer
681 // is created.
682 const QgsSettings settings;
683 // Check that proxy is enabled
684 if ( settings.value( QStringLiteral( "proxy/proxyEnabled" ), false ).toBool() )
685 {
686 // Get the first configured proxy
687 QList<QNetworkProxy> proxies( QgsNetworkAccessManager::instance()->proxyFactory()->queryProxy( ) );
688 if ( ! proxies.isEmpty() )
689 {
690 const QNetworkProxy proxy( proxies.first() );
691 // TODO/FIXME: check excludes (the GDAL config options are global, we need a per-connection config option)
692 //QStringList excludes;
693 //excludes = settings.value( QStringLiteral( "proxy/proxyExcludedUrls" ), "" ).toStringList();
694
695 const QString proxyHost( proxy.hostName() );
696 const quint16 proxyPort( proxy.port() );
697
698 const QString proxyUser( proxy.user() );
699 const QString proxyPassword( proxy.password() );
700
701 if ( ! proxyHost.isEmpty() )
702 {
703 QString connection( proxyHost );
704 if ( proxyPort )
705 {
706 connection += ':' + QString::number( proxyPort );
707 }
708 CPLSetConfigOption( "GDAL_HTTP_PROXY", connection.toUtf8() );
709 if ( ! proxyUser.isEmpty( ) )
710 {
711 QString credentials( proxyUser );
712 if ( ! proxyPassword.isEmpty( ) )
713 {
714 credentials += ':' + proxyPassword;
715 }
716 CPLSetConfigOption( "GDAL_HTTP_PROXYUSERPWD", credentials.toUtf8() );
717 }
718 }
719 }
720 }
721}
722
723bool QgsGdalUtils::pathIsCheapToOpen( const QString &path, int smallFileSizeLimit )
724{
725 const QFileInfo info( path );
726 const long long size = info.size();
727
728 // if size could not be determined, safest to flag path as expensive
729 if ( size == 0 )
730 return false;
731
732 const QString suffix = info.suffix().toLower();
733 static const QStringList sFileSizeDependentExtensions
734 {
735 QStringLiteral( "xlsx" ),
736 QStringLiteral( "ods" ),
737 QStringLiteral( "csv" )
738 };
739 if ( sFileSizeDependentExtensions.contains( suffix ) )
740 {
741 // path corresponds to a file type which is only cheap to open for small files
742 return size < smallFileSizeLimit;
743 }
744
745 // treat all other formats as expensive.
746 // TODO -- flag formats which only require a quick header parse as cheap
747 return false;
748}
749
750QStringList QgsGdalUtils::multiLayerFileExtensions()
751{
752#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3,4,0)
753 // get supported extensions
754 static std::once_flag initialized;
755 static QStringList SUPPORTED_DB_LAYERS_EXTENSIONS;
756 std::call_once( initialized, [ = ]
757 {
758 // iterate through all of the supported drivers, adding the corresponding file extensions for
759 // types which advertise multilayer support
760 GDALDriverH driver = nullptr;
761
762 QSet< QString > extensions;
763
764 for ( int i = 0; i < GDALGetDriverCount(); ++i )
765 {
766 driver = GDALGetDriver( i );
767 if ( !driver )
768 {
769 QgsLogger::warning( "unable to get driver " + QString::number( i ) );
770 continue;
771 }
772
773 bool isMultiLayer = false;
774 if ( QString( GDALGetMetadataItem( driver, GDAL_DCAP_RASTER, nullptr ) ) == QLatin1String( "YES" ) )
775 {
776 if ( GDALGetMetadataItem( driver, GDAL_DMD_SUBDATASETS, nullptr ) != nullptr )
777 {
778 isMultiLayer = true;
779 }
780 }
781 if ( !isMultiLayer && QString( GDALGetMetadataItem( driver, GDAL_DCAP_VECTOR, nullptr ) ) == QLatin1String( "YES" ) )
782 {
783 if ( GDALGetMetadataItem( driver, GDAL_DCAP_MULTIPLE_VECTOR_LAYERS, nullptr ) != nullptr )
784 {
785 isMultiLayer = true;
786 }
787 }
788
789 if ( !isMultiLayer )
790 continue;
791
792 const QString driverExtensions = GDALGetMetadataItem( driver, GDAL_DMD_EXTENSIONS, "" );
793 if ( driverExtensions.isEmpty() )
794 continue;
795
796 const QStringList splitExtensions = driverExtensions.split( ' ', Qt::SkipEmptyParts );
797
798 for ( const QString &ext : splitExtensions )
799 {
800 // maintain older behavior -- don't always expose tiff files as containers
801 if ( ext == QLatin1String( "tif" ) || ext == QLatin1String( "tiff" ) )
802 continue;
803
804 extensions.insert( ext );
805 }
806 }
807
808 SUPPORTED_DB_LAYERS_EXTENSIONS = QStringList( extensions.constBegin(), extensions.constEnd() );
809 } );
810 return SUPPORTED_DB_LAYERS_EXTENSIONS;
811
812#else
813 static const QStringList SUPPORTED_DB_LAYERS_EXTENSIONS
814 {
815 QStringLiteral( "gpkg" ),
816 QStringLiteral( "sqlite" ),
817 QStringLiteral( "db" ),
818 QStringLiteral( "gdb" ),
819 QStringLiteral( "kml" ),
820 QStringLiteral( "kmz" ),
821 QStringLiteral( "osm" ),
822 QStringLiteral( "mdb" ),
823 QStringLiteral( "accdb" ),
824 QStringLiteral( "xls" ),
825 QStringLiteral( "xlsx" ),
826 QStringLiteral( "ods" ),
827 QStringLiteral( "gpx" ),
828 QStringLiteral( "pdf" ),
829 QStringLiteral( "pbf" ),
830 QStringLiteral( "vrt" ),
831 QStringLiteral( "nc" ),
832 QStringLiteral( "dxf" ),
833 QStringLiteral( "shp.zip" ) };
834 return SUPPORTED_DB_LAYERS_EXTENSIONS;
835#endif
836}
837
838QString QgsGdalUtils::vsiPrefixForPath( const QString &path )
839{
840 const QStringList vsiPrefixes = QgsGdalUtils::vsiArchivePrefixes();
841
842 const thread_local QRegularExpression vsiRx( QStringLiteral( "^(/vsi.+?/)" ), QRegularExpression::PatternOption::CaseInsensitiveOption );
843 const QRegularExpressionMatch vsiMatch = vsiRx.match( path );
844 if ( vsiMatch.hasMatch() )
845 return vsiMatch.captured( 1 );
846
847 if ( path.endsWith( QLatin1String( ".shp.zip" ), Qt::CaseInsensitive ) )
848 {
849 // GDAL 3.1 Shapefile driver directly handles .shp.zip files
850 if ( GDALIdentifyDriverEx( path.toUtf8().constData(), GDAL_OF_VECTOR, nullptr, nullptr ) )
851 return QString();
852 return QStringLiteral( "/vsizip/" );
853 }
854 else if ( path.endsWith( QLatin1String( ".zip" ), Qt::CaseInsensitive ) )
855 return QStringLiteral( "/vsizip/" );
856 else if ( path.endsWith( QLatin1String( ".tar" ), Qt::CaseInsensitive ) ||
857 path.endsWith( QLatin1String( ".tar.gz" ), Qt::CaseInsensitive ) ||
858 path.endsWith( QLatin1String( ".tgz" ), Qt::CaseInsensitive ) )
859 return QStringLiteral( "/vsitar/" );
860 else if ( path.endsWith( QLatin1String( ".gz" ), Qt::CaseInsensitive ) )
861 return QStringLiteral( "/vsigzip/" );
862#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3,7,0)
863 else if ( vsiPrefixes.contains( QStringLiteral( "/vsi7z/" ) ) &&
864 ( path.endsWith( QLatin1String( ".7z" ), Qt::CaseInsensitive ) ||
865 path.endsWith( QLatin1String( ".lpk" ), Qt::CaseInsensitive ) ||
866 path.endsWith( QLatin1String( ".lpkx" ), Qt::CaseInsensitive ) ||
867 path.endsWith( QLatin1String( ".mpk" ), Qt::CaseInsensitive ) ||
868 path.endsWith( QLatin1String( ".mpkx" ), Qt::CaseInsensitive ) ) )
869 return QStringLiteral( "/vsi7z/" );
870 else if ( vsiPrefixes.contains( QStringLiteral( "/vsirar/" ) ) &&
871 path.endsWith( QLatin1String( ".rar" ), Qt::CaseInsensitive ) )
872 return QStringLiteral( "/vsirar/" );
873#endif
874
875 return QString();
876}
877
878QStringList QgsGdalUtils::vsiArchivePrefixes()
879{
880 QStringList res { QStringLiteral( "/vsizip/" ),
881 QStringLiteral( "/vsitar/" ),
882 QStringLiteral( "/vsigzip/" ),
883 };
884#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3,7,0)
885 res.append( QStringLiteral( "/vsi7z/" ) );
886 res.append( QStringLiteral( "/vsirar/" ) );
887#endif
888 return res;
889}
890
891QList<QgsGdalUtils::VsiNetworkFileSystemDetails> QgsGdalUtils::vsiNetworkFileSystems()
892{
893 // get supported extensions
894 static std::once_flag initialized;
895 static QList<QgsGdalUtils::VsiNetworkFileSystemDetails> VSI_FILE_SYSTEM_DETAILS;
896 std::call_once( initialized, [ = ]
897 {
898 if ( char **papszPrefixes = VSIGetFileSystemsPrefixes() )
899 {
900 for ( int i = 0; papszPrefixes[i]; i++ )
901 {
902 QgsGdalUtils::VsiNetworkFileSystemDetails details;
903 details.identifier = QString( papszPrefixes[i] );
904 if ( details.identifier.startsWith( '/' ) )
905 details.identifier = details.identifier.mid( 1 );
906 if ( details.identifier.endsWith( '/' ) )
907 details.identifier.chop( 1 );
908
909 if ( details.identifier == QStringLiteral( "vsicurl" ) )
910 details.name = QObject::tr( "HTTP/HTTPS/FTP" );
911 else if ( details.identifier == QStringLiteral( "vsis3" ) )
912 details.name = QObject::tr( "AWS S3" );
913 else if ( details.identifier == QStringLiteral( "vsigs" ) )
914 details.name = QObject::tr( "Google Cloud Storage" );
915 else if ( details.identifier == QStringLiteral( "vsiaz" ) )
916 details.name = QObject::tr( "Microsoft Azure Blob" );
917 else if ( details.identifier == QStringLiteral( "vsiadls" ) )
918 details.name = QObject::tr( "Microsoft Azure Data Lake Storage" );
919 else if ( details.identifier == QStringLiteral( "vsioss" ) )
920 details.name = QObject::tr( "Alibaba Cloud OSS" );
921 else if ( details.identifier == QStringLiteral( "vsiswift" ) )
922 details.name = QObject::tr( "OpenStack Swift Object Storage" );
923 else if ( details.identifier == QStringLiteral( "vsihdfs" ) )
924 details.name = QObject::tr( "Hadoop File System" );
925 else
926 continue;
927 VSI_FILE_SYSTEM_DETAILS.append( details );
928 }
929
930 CSLDestroy( papszPrefixes );
931 }
932 } );
933
934 return VSI_FILE_SYSTEM_DETAILS;
935}
936
937bool QgsGdalUtils::isVsiArchivePrefix( const QString &prefix )
938{
939 return vsiArchivePrefixes().contains( prefix );
940}
941
942QStringList QgsGdalUtils::vsiArchiveFileExtensions()
943{
944 QStringList res { QStringLiteral( ".zip" ),
945 QStringLiteral( ".tar" ),
946 QStringLiteral( ".tar.gz" ),
947 QStringLiteral( ".tgz" ),
948 QStringLiteral( ".gz" ),
949 };
950#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3,7,0)
951 res.append( { QStringLiteral( ".7z" ),
952 QStringLiteral( ".lpk" ),
953 QStringLiteral( ".lpkx" ),
954 QStringLiteral( ".mpk" ),
955 QStringLiteral( ".mpkx" ),
956 QStringLiteral( ".rar" )
957 } );
958#endif
959 return res;
960}
961
962bool QgsGdalUtils::isVsiArchiveFileExtension( const QString &extension )
963{
964 const QString extWithDot = extension.startsWith( '.' ) ? extension : ( '.' + extension );
965 return vsiArchiveFileExtensions().contains( extWithDot.toLower() );
966}
967
968Qgis::VsiHandlerType QgsGdalUtils::vsiHandlerType( const QString &prefix )
969{
970 if ( prefix.isEmpty() )
971 return Qgis::VsiHandlerType::Invalid;
972
973 QString vsiPrefix = prefix;
974 if ( vsiPrefix.startsWith( '/' ) )
975 vsiPrefix = vsiPrefix.mid( 1 );
976 if ( vsiPrefix.endsWith( '/' ) )
977 vsiPrefix.chop( 1 );
978
979 if ( !vsiPrefix.startsWith( QLatin1String( "vsi" ) ) )
980 return Qgis::VsiHandlerType::Invalid;
981
982 if ( vsiPrefix == QLatin1String( "vsizip" ) ||
983 vsiPrefix == QLatin1String( "vsigzip" ) ||
984 vsiPrefix == QLatin1String( "vsitar" ) ||
985 vsiPrefix == QLatin1String( "vsi7z" ) ||
986 vsiPrefix == QLatin1String( "vsirar" ) )
987 return Qgis::VsiHandlerType::Archive;
988
989 else if ( vsiPrefix == QLatin1String( "vsicurl" ) ||
990 vsiPrefix == QLatin1String( "vsicurl_streaming" ) )
991 return Qgis::VsiHandlerType::Network;
992
993 else if ( vsiPrefix == QLatin1String( "vsis3" ) ||
994 vsiPrefix == QLatin1String( "vsicurl_streaming" ) ||
995 vsiPrefix == QLatin1String( "vsigs" ) ||
996 vsiPrefix == QLatin1String( "vsigs_streaming" ) ||
997 vsiPrefix == QLatin1String( "vsiaz" ) ||
998 vsiPrefix == QLatin1String( "vsiaz_streaming" ) ||
999 vsiPrefix == QLatin1String( "vsiadls" ) ||
1000 vsiPrefix == QLatin1String( "vsioss" ) ||
1001 vsiPrefix == QLatin1String( "vsioss_streaming" ) ||
1002 vsiPrefix == QLatin1String( "vsiswift" ) ||
1003 vsiPrefix == QLatin1String( "vsiswift_streaming" ) ||
1004 vsiPrefix == QLatin1String( "vsihdfs" ) ||
1005 vsiPrefix == QLatin1String( "vsiwebhdfs" ) )
1006 return Qgis::VsiHandlerType::Cloud;
1007
1008 else if ( vsiPrefix == QLatin1String( "vsimem" ) )
1009 return Qgis::VsiHandlerType::Memory;
1010
1011 return Qgis::VsiHandlerType::Other;
1012}
1013
1014bool QgsGdalUtils::vrtMatchesLayerType( const QString &vrtPath, Qgis::LayerType type )
1015{
1016 CPLPushErrorHandler( CPLQuietErrorHandler );
1017 CPLErrorReset();
1018 GDALDriverH hDriver = nullptr;
1019
1020 switch ( type )
1021 {
1022 case Qgis::LayerType::Vector:
1023 hDriver = GDALIdentifyDriverEx( vrtPath.toUtf8().constData(), GDAL_OF_VECTOR, nullptr, nullptr );
1024 break;
1025
1026 case Qgis::LayerType::Raster:
1027 hDriver = GDALIdentifyDriverEx( vrtPath.toUtf8().constData(), GDAL_OF_RASTER, nullptr, nullptr );
1028 break;
1029
1030 case Qgis::LayerType::Plugin:
1031 case Qgis::LayerType::Mesh:
1032 case Qgis::LayerType::VectorTile:
1033 case Qgis::LayerType::Annotation:
1034 case Qgis::LayerType::PointCloud:
1035 case Qgis::LayerType::Group:
1036 case Qgis::LayerType::TiledScene:
1037 break;
1038 }
1039
1040 CPLPopErrorHandler();
1041 return static_cast< bool >( hDriver );
1042}
1043
1044bool QgsGdalUtils::applyVsiCredentialOptions( const QString &prefix, const QString &path, const QVariantMap &options )
1045{
1046 QString vsiPrefix = prefix;
1047 if ( !vsiPrefix.startsWith( '/' ) )
1048 vsiPrefix.prepend( '/' );
1049 if ( !vsiPrefix.endsWith( '/' ) )
1050 vsiPrefix.append( '/' );
1051
1052 QString vsiPath = path;
1053 if ( vsiPath.endsWith( '/' ) )
1054 vsiPath.chop( 1 );
1055
1056 const QString bucket = vsiPrefix + vsiPath;
1057
1058 for ( auto it = options.constBegin(); it != options.constEnd(); ++it )
1059 {
1060#if GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3, 6, 0)
1061 VSISetPathSpecificOption( bucket.toUtf8().constData(), it.key().toUtf8().constData(), it.value().toString().toUtf8().constData() );
1062#elif GDAL_VERSION_NUM >= GDAL_COMPUTE_VERSION(3, 5, 0)
1063 VSISetCredential( bucket.toUtf8().constData(), it.key().toUtf8().constData(), it.value().toString().toUtf8().constData() );
1064#else
1065 ( void )bucket;
1066 QgsMessageLog::logMessage( QObject::tr( "Cannot use VSI credential options on GDAL versions earlier than 3.5" ), QStringLiteral( "GDAL" ), Qgis::MessageLevel::Critical );
1067 return false;
1068#endif
1069 }
1070 return true;
1071}
1072#endif
Qgis::VsiHandlerType
VsiHandlerType
GDAL VSI handler types.
Definition qgis.h:4903
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:102
Qgis::DataType
DataType
Raster data types.
Definition qgis.h:288
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:114
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:1973
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:968
QgsGdalUtils::applyVsiCredentialOptions
static bool applyVsiCredentialOptions(const QString &prefix, const QString &path, const QVariantMap &options)
Attempts to apply VSI credential options.
Definition qgsgdalutils.cpp:1044
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:723
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:838
QgsGdalUtils::helpCreationOptionsFormat
static QString helpCreationOptionsFormat(const QString &format)
Gets creation options metadata for a given format.
Definition qgsgdalutils.cpp:489
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:1014
QgsGdalUtils::gdalResamplingAlgorithm
static GDALResampleAlg gdalResamplingAlgorithm(QgsRasterDataProvider::ResamplingMethod method)
Returns the GDAL resampling method corresponding to the QGIS resampling method.
Definition qgsgdalutils.cpp:636
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:411
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:545
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:962
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:204
QgsGdalUtils::gdalDataTypeFromQgisDataType
static GDALDataType gdalDataTypeFromQgisDataType(Qgis::DataType dataType)
Returns the GDAL data type corresponding to the QGIS data type dataType.
Definition qgsgdalutils.cpp:580
QgsGdalUtils::isVsiArchivePrefix
static bool isVsiArchivePrefix(const QString &prefix)
Returns true if prefix is a supported archive style container prefix (e.g.
Definition qgsgdalutils.cpp:937
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:174
QgsGdalUtils::validateCreationOptionsFormat
static QString validateCreationOptionsFormat(const QStringList &createOptions, const QString &format)
Validates creation options for a given format, regardless of layer.
Definition qgsgdalutils.cpp:529
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:279
QgsGdalUtils::vsiNetworkFileSystems
static QList< VsiNetworkFileSystemDetails > vsiNetworkFileSystems()
Returns a list of available GDAL VSI network file systems.
Definition qgsgdalutils.cpp:891
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:235
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:565
QgsGdalUtils::setupProxy
static void setupProxy()
Sets the gdal proxy variables.
Definition qgsgdalutils.cpp:675
QgsGdalUtils::vsiArchiveFileExtensions
static QStringList vsiArchiveFileExtensions()
Returns a list of file extensions which correspond to archive style containers supported by GDAL (e....
Definition qgsgdalutils.cpp:942
QgsGdalUtils::papszFromStringList
static char ** papszFromStringList(const QStringList &list)
Helper function.
Definition qgsgdalutils.cpp:518
QgsGdalUtils::resampleImage
static QImage resampleImage(const QImage &image, QSize outputSize, GDALRIOResampleAlg resampleAlg)
Resamples a QImage image using GDAL resampler.
Definition qgsgdalutils.cpp:438
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:179
QgsGdalUtils::multiLayerFileExtensions
static QStringList multiLayerFileExtensions()
Returns a list of file extensions which potentially contain multiple layers representing GDAL raster ...
Definition qgsgdalutils.cpp:750
QgsGdalUtils::vsiArchivePrefixes
static QStringList vsiArchivePrefixes()
Returns a list of vsi prefixes which correspond to archive style containers (eg vsizip).
Definition qgsgdalutils.cpp:878
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:27
QgsNetworkAccessManager::instance
static QgsNetworkAccessManager * instance(Qt::ConnectionType connectionType=Qt::BlockingQueuedConnection)
Returns a pointer to the active QgsNetworkAccessManager for the current thread.
Definition qgsnetworkaccessmanager.cpp:195
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:668
QgsRasterBlock::bits
char * bits(int row, int column)
Returns a pointer to block data.
Definition qgsrasterblock.cpp:544
QgsRasterBlock::noDataValue
double noDataValue() const
Returns no data value.
Definition qgsrasterblock.h:177
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:662
QgsRasterDataProvider::ResamplingMethod
ResamplingMethod
Resampling method for provider-level resampling.
Definition qgsrasterdataprovider.h:678
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:201
QgsRectangle::yMinimum
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
Definition qgsrectangle.h:211
QgsRectangle::width
double width() const
Returns the width of the rectangle.
Definition qgsrectangle.h:236
QgsRectangle::height
double height() const
Returns the height of the rectangle.
Definition qgsrectangle.h:243
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:174
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 Mon Jul 1 2024 09:21:40 for QGIS API Documentation by doxygen 1.9.8