GDALDatasetH gv_manager_add_dataset( GvManager *manager, GDALDatasetH dataset )
{
int i;
GvDataset *ds;
if( dataset == NULL || manager == NULL )
return NULL;
/*
* Check for dataset in existing list of open files. Note that our
* filename check does not account for different possible names for
* one dataset.
*/
for( i = 0; i < manager->datasets->len; i++ )
{
ds = (GvDataset *) g_ptr_array_index(manager->datasets, i);
if( EQUAL(GDALGetDescription(ds->dataset),GDALGetDescription(dataset)) )
{
return ds->dataset;
}
}
/*
* Add the dataset to the list of managed datasets.
*/
GDALReferenceDataset(dataset);
ds = g_new(GvDataset,1);
ds->dataset = dataset;
ds->rasters = g_new0(GvRaster *, GDALGetRasterCount(dataset));
g_ptr_array_add( manager->datasets, ds );
return dataset;
}
ImageProperties::ImageProperties(GDALDataset* dataset, const std::string& filename) :
width(0),
height(0),
numBands(0),
driverName(NULL),
driverLongName(NULL),
imageFileName(filename)
{
assert(dataset != NULL);
driverName = (char *) GDALGetDescription(GDALGetDatasetDriver(dataset));
driverLongName = (char *) GDALGetMetadataItem(GDALGetDatasetDriver(dataset),
GDAL_DMD_LONGNAME,0);
width = GDALGetRasterXSize(dataset);
height = GDALGetRasterYSize(dataset);
numBands = GDALGetRasterCount(dataset);
string::size_type position = imageFileName.find_last_of("\\");
if (position != string::npos) {
shortFileName = imageFileName.substr(position + 1);
} else {
shortFileName = imageFileName;
}
}
GDALDatasetH gv_manager_get_dataset( GvManager *manager, const char * filename)
{
int i;
GvDataset *ds;
GDALDatasetH dataset;
/*
* Check for dataset in existing list of open files. Note that our
* filename check does not account for different possible names for
* one dataset.
*/
for( i = 0; i < manager->datasets->len; i++ )
{
ds = (GvDataset *) g_ptr_array_index(manager->datasets, i);
if( EQUAL(GDALGetDescription(ds->dataset),filename) )
{
return ds->dataset;
}
}
/*
* Try to open the dataset, preferably with update access. We don't
* want to report update access errors so we supress error reporting
* temporarily.
*/
CPLErrorReset();
CPLPushErrorHandler( CPLQuietErrorHandler );
dataset = GDALOpen( filename, GA_Update );
CPLPopErrorHandler();
if( dataset == NULL )
{
dataset = GDALOpen( filename, GA_ReadOnly );
}
if( dataset == NULL )
return NULL;
/*
* Add the dataset to the list of managed datasets.
*/
ds = g_new(GvDataset,1);
ds->dataset = dataset;
ds->rasters = g_new0(GvRaster *, GDALGetRasterCount(dataset));
g_ptr_array_add( manager->datasets, ds );
return dataset;
}
void gv_manager_dump( GvManager *manager )
{
FILE *fp = stderr;
int i;
GvIdleTask *task;
fprintf( fp, "GvManager Status Report\n" );
fprintf( fp, "=======================\n" );
fprintf( fp, "\n" );
fprintf( fp, "Preferences:\n" );
for( i = 0; i < gv_properties_count( &(manager->preferences) ); i++ )
{
fprintf( fp, " %s=%s\n",
gv_properties_get_name_by_index( &(manager->preferences), i),
gv_properties_get_value_by_index( &(manager->preferences),i));
}
fprintf( fp, "\n" );
fprintf( fp, "Datasets:\n" );
for( i = 0; i < manager->datasets->len; i++ )
{
GvDataset *ds = (GvDataset *) g_ptr_array_index(manager->datasets,i);
int band;
fprintf( fp, " %s:", GDALGetDescription( ds->dataset ) );
for( band = 0; band < GDALGetRasterCount(ds->dataset); band++ )
{
if( ds->rasters[band] != NULL )
fprintf( fp, "R" );
else
fprintf( fp, "_" );
}
fprintf( fp, "\n" );
}
fprintf( fp, "\n" );
fprintf( fp, "Idle Tasks:\n" );
for( task = manager->idle_tasks; task != NULL; task = task->next )
{
fprintf( fp, " %s: priority=%d, cb=%p, cb_data=%p\n",
task->name, task->priority, task->callback, task->task_info );
}
}
void QgsOptions::loadGdalDriverList()
{
QStringList mySkippedDrivers = QgsApplication::skippedGdalDrivers();
GDALDriverH myGdalDriver; // current driver
QString myGdalDriverDescription;
QStringList myDrivers;
for ( int i = 0; i < GDALGetDriverCount(); ++i )
{
myGdalDriver = GDALGetDriver( i );
Q_CHECK_PTR( myGdalDriver );
if ( !myGdalDriver )
{
QgsLogger::warning( "unable to get driver " + QString::number( i ) );
continue;
}
myGdalDriverDescription = GDALGetDescription( myGdalDriver );
myDrivers << myGdalDriverDescription;
}
// add the skipped drivers to the list too in case their drivers are
// already unloaded...may result in false positive if underlying
// sys config has changed and that driver no longer exists...
myDrivers.append( mySkippedDrivers );
myDrivers.removeDuplicates();
myDrivers.sort();
QStringListIterator myIterator( myDrivers );
while ( myIterator.hasNext() )
{
QString myName = myIterator.next();
QListWidgetItem * mypItem = new QListWidgetItem( myName );
if ( mySkippedDrivers.contains( myName ) )
{
mypItem->setCheckState( Qt::Unchecked );
}
else
{
mypItem->setCheckState( Qt::Checked );
}
lstGdalDrivers->addItem( mypItem );
}
}
GDALDatasetH GDALRasterize( const char *pszDest, GDALDatasetH hDstDS,
GDALDatasetH hSrcDataset,
const GDALRasterizeOptions *psOptionsIn, int *pbUsageError )
{
if( pszDest == NULL && hDstDS == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined, "pszDest == NULL && hDstDS == NULL");
if(pbUsageError)
*pbUsageError = TRUE;
return NULL;
}
if( hSrcDataset == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined, "hSrcDataset== NULL");
if(pbUsageError)
*pbUsageError = TRUE;
return NULL;
}
if( hDstDS != NULL && psOptionsIn && psOptionsIn->bCreateOutput )
{
CPLError( CE_Failure, CPLE_AppDefined, "hDstDS != NULL but options that imply creating a new dataset have been set.");
if(pbUsageError)
*pbUsageError = TRUE;
return NULL;
}
GDALRasterizeOptions* psOptionsToFree = NULL;
const GDALRasterizeOptions* psOptions;
if( psOptionsIn )
psOptions = psOptionsIn;
else
{
psOptionsToFree = GDALRasterizeOptionsNew(NULL, NULL);
psOptions = psOptionsToFree;
}
int bCloseOutDSOnError = (hDstDS == NULL);
if( pszDest == NULL )
pszDest = GDALGetDescription(hDstDS);
if( psOptions->pszSQL == NULL && psOptions->papszLayers == NULL &&
GDALDatasetGetLayerCount(hSrcDataset) != 1 )
{
CPLError(CE_Failure, CPLE_NotSupported,
"Neither -sql nor -l are specified, but the source dataset has not one single layer.");
if( pbUsageError )
*pbUsageError = TRUE;
GDALRasterizeOptionsFree(psOptionsToFree);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Open target raster file. Eventually we will add optional */
/* creation. */
/* -------------------------------------------------------------------- */
int bCreateOutput = psOptions->bCreateOutput;
if( hDstDS == NULL )
bCreateOutput = TRUE;
GDALDriverH hDriver = NULL;
if (psOptions->bCreateOutput)
{
/* -------------------------------------------------------------------- */
/* Find the output driver. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDriverByName( psOptions->pszFormat );
if( hDriver == NULL
|| GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) == NULL )
{
int iDr;
CPLError( CE_Failure, CPLE_NotSupported,
"Output driver `%s' not recognised or does not support "
" direct output file creation.", psOptions->pszFormat);
fprintf(stderr, "The following format drivers are configured\n"
"and support direct output:\n" );
for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ )
{
hDriver = GDALGetDriver(iDr);
if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL) != NULL )
{
fprintf(stderr, " %s: %s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
}
}
fprintf(stderr, "\n" );
GDALRasterizeOptionsFree(psOptionsToFree);
return NULL;
}
}
/* -------------------------------------------------------------------- */
/* Process SQL request. */
/* -------------------------------------------------------------------- */
CPLErr eErr = CE_Failure;
if( psOptions->pszSQL != NULL )
{
OGRLayerH hLayer;
hLayer = GDALDatasetExecuteSQL( hSrcDataset, psOptions->pszSQL, NULL, psOptions->pszDialect );
if( hLayer != NULL )
{
if (bCreateOutput)
{
std::vector<OGRLayerH> ahLayers;
ahLayers.push_back(hLayer);
hDstDS = CreateOutputDataset(ahLayers, psOptions->hSRS,
psOptions->bGotBounds, psOptions->sEnvelop,
hDriver, pszDest,
psOptions->nXSize, psOptions->nYSize, psOptions->dfXRes, psOptions->dfYRes,
psOptions->bTargetAlignedPixels,
static_cast<int>(psOptions->anBandList.size()), psOptions->eOutputType,
psOptions->papszCreationOptions, psOptions->adfInitVals,
psOptions->bNoDataSet, psOptions->dfNoData);
if( hDstDS == NULL )
{
GDALDatasetReleaseResultSet( hSrcDataset, hLayer );
GDALRasterizeOptionsFree(psOptionsToFree);
return NULL;
}
}
eErr = ProcessLayer( hLayer, psOptions->hSRS != NULL, hDstDS, psOptions->anBandList,
psOptions->adfBurnValues, psOptions->b3D, psOptions->bInverse, psOptions->pszBurnAttribute,
psOptions->papszRasterizeOptions, psOptions->pfnProgress, psOptions->pProgressData );
GDALDatasetReleaseResultSet( hSrcDataset, hLayer );
}
}
/* -------------------------------------------------------------------- */
/* Create output file if necessary. */
/* -------------------------------------------------------------------- */
int nLayerCount = (psOptions->pszSQL == NULL && psOptions->papszLayers == NULL) ? 1 : CSLCount(psOptions->papszLayers);
if (psOptions->bCreateOutput && hDstDS == NULL)
{
std::vector<OGRLayerH> ahLayers;
for( int i = 0; i < nLayerCount; i++ )
{
OGRLayerH hLayer;
if( psOptions->papszLayers )
hLayer = GDALDatasetGetLayerByName( hSrcDataset, psOptions->papszLayers[i] );
else
hLayer = GDALDatasetGetLayer(hSrcDataset, 0);
if( hLayer == NULL )
{
continue;
}
ahLayers.push_back(hLayer);
}
hDstDS = CreateOutputDataset(ahLayers, psOptions->hSRS,
psOptions->bGotBounds, psOptions->sEnvelop,
hDriver, pszDest,
psOptions->nXSize, psOptions->nYSize, psOptions->dfXRes, psOptions->dfYRes,
psOptions->bTargetAlignedPixels,
static_cast<int>(psOptions->anBandList.size()), psOptions->eOutputType,
psOptions->papszCreationOptions, psOptions->adfInitVals,
psOptions->bNoDataSet, psOptions->dfNoData);
if( hDstDS == NULL )
{
GDALRasterizeOptionsFree(psOptionsToFree);
return NULL;
}
}
/* -------------------------------------------------------------------- */
/* Process each layer. */
/* -------------------------------------------------------------------- */
for( int i = 0; i < nLayerCount; i++ )
{
OGRLayerH hLayer;
if( psOptions->papszLayers )
hLayer = GDALDatasetGetLayerByName( hSrcDataset, psOptions->papszLayers[i] );
else
hLayer = GDALDatasetGetLayer(hSrcDataset, 0);
if( hLayer == NULL )
{
CPLError(CE_Failure, CPLE_AppDefined, "Unable to find layer \"%s\", skipping.",
psOptions->papszLayers ? psOptions->papszLayers[i] : "0" );
continue;
}
if( psOptions->pszWHERE )
{
if( OGR_L_SetAttributeFilter( hLayer, psOptions->pszWHERE ) != OGRERR_NONE )
break;
}
void *pScaledProgress;
pScaledProgress =
GDALCreateScaledProgress( 0.0, 1.0 * (i + 1) / nLayerCount,
psOptions->pfnProgress, psOptions->pProgressData );
eErr = ProcessLayer( hLayer, psOptions->hSRS != NULL, hDstDS, psOptions->anBandList,
psOptions->adfBurnValues, psOptions->b3D, psOptions->bInverse, psOptions->pszBurnAttribute,
psOptions->papszRasterizeOptions, GDALScaledProgress, pScaledProgress );
GDALDestroyScaledProgress( pScaledProgress );
if( eErr != CE_None )
break;
}
GDALRasterizeOptionsFree(psOptionsToFree);
if( eErr != CE_None )
{
if( bCloseOutDSOnError )
GDALClose(hDstDS);
return NULL;
}
return hDstDS;
}
int main( int argc, char ** argv )
{
GDALDatasetH hDataset;
GDALRasterBandH hBand;
int i, iBand;
double adfGeoTransform[6];
GDALDriverH hDriver;
char **papszMetadata;
int bComputeMinMax = FALSE, bSample = FALSE;
int bShowGCPs = TRUE, bShowMetadata = TRUE, bShowRAT=TRUE;
int bStats = FALSE, bApproxStats = TRUE, iMDD;
int bShowColorTable = TRUE, bComputeChecksum = FALSE;
int bReportHistograms = FALSE;
const char *pszFilename = NULL;
char **papszExtraMDDomains = NULL, **papszFileList;
const char *pszProjection = NULL;
OGRCoordinateTransformationH hTransform = NULL;
/* Check that we are running against at least GDAL 1.5 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1500)
{
fprintf(stderr, "At least, GDAL >= 1.5.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
exit(1);
}
/* Must process GDAL_SKIP before GDALAllRegister(), but we can't call */
/* GDALGeneralCmdLineProcessor before it needs the drivers to be registered */
/* for the --format or --formats options */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i],"--config") && i + 2 < argc && EQUAL(argv[i + 1], "GDAL_SKIP") )
{
CPLSetConfigOption( argv[i+1], argv[i+2] );
i += 2;
}
}
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(argv[i], "-mm") )
bComputeMinMax = TRUE;
else if( EQUAL(argv[i], "-hist") )
bReportHistograms = TRUE;
else if( EQUAL(argv[i], "-stats") )
{
bStats = TRUE;
bApproxStats = FALSE;
}
else if( EQUAL(argv[i], "-approx_stats") )
{
bStats = TRUE;
bApproxStats = TRUE;
}
else if( EQUAL(argv[i], "-sample") )
bSample = TRUE;
else if( EQUAL(argv[i], "-checksum") )
bComputeChecksum = TRUE;
else if( EQUAL(argv[i], "-nogcp") )
bShowGCPs = FALSE;
else if( EQUAL(argv[i], "-nomd") )
bShowMetadata = FALSE;
else if( EQUAL(argv[i], "-norat") )
bShowRAT = FALSE;
else if( EQUAL(argv[i], "-noct") )
bShowColorTable = FALSE;
else if( EQUAL(argv[i], "-mdd") && i < argc-1 )
papszExtraMDDomains = CSLAddString( papszExtraMDDomains,
argv[++i] );
else if( argv[i][0] == '-' )
Usage();
else if( pszFilename == NULL )
pszFilename = argv[i];
else
Usage();
}
if( pszFilename == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open dataset. */
/* -------------------------------------------------------------------- */
hDataset = GDALOpen( pszFilename, GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"gdalinfo failed - unable to open '%s'.\n",
pszFilename );
CSLDestroy( argv );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLDumpSharedList( NULL );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Report general info. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDatasetDriver( hDataset );
printf( "Driver: %s/%s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
papszFileList = GDALGetFileList( hDataset );
if( CSLCount(papszFileList) == 0 )
{
printf( "Files: none associated\n" );
}
else
{
printf( "Files: %s\n", papszFileList[0] );
for( i = 1; papszFileList[i] != NULL; i++ )
printf( " %s\n", papszFileList[i] );
}
CSLDestroy( papszFileList );
printf( "Size is %d, %d\n",
GDALGetRasterXSize( hDataset ),
GDALGetRasterYSize( hDataset ) );
/* -------------------------------------------------------------------- */
/* Report projection. */
/* -------------------------------------------------------------------- */
if( GDALGetProjectionRef( hDataset ) != NULL )
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetProjectionRef( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "Coordinate System is:\n%s\n", pszPrettyWkt );
CPLFree( pszPrettyWkt );
}
else
printf( "Coordinate System is `%s'\n",
GDALGetProjectionRef( hDataset ) );
OSRDestroySpatialReference( hSRS );
}
/* -------------------------------------------------------------------- */
/* Report Geotransform. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
{
if( adfGeoTransform[2] == 0.0 && adfGeoTransform[4] == 0.0 )
{
printf( "Origin = (%.15f,%.15f)\n",
adfGeoTransform[0], adfGeoTransform[3] );
printf( "Pixel Size = (%.15f,%.15f)\n",
adfGeoTransform[1], adfGeoTransform[5] );
}
else
printf( "GeoTransform =\n"
" %.16g, %.16g, %.16g\n"
" %.16g, %.16g, %.16g\n",
adfGeoTransform[0],
adfGeoTransform[1],
adfGeoTransform[2],
adfGeoTransform[3],
adfGeoTransform[4],
adfGeoTransform[5] );
}
/* -------------------------------------------------------------------- */
/* Report GCPs. */
/* -------------------------------------------------------------------- */
if( bShowGCPs && GDALGetGCPCount( hDataset ) > 0 )
{
if (GDALGetGCPProjection(hDataset) != NULL)
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetGCPProjection( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "GCP Projection = \n%s\n", pszPrettyWkt );
CPLFree( pszPrettyWkt );
}
else
printf( "GCP Projection = %s\n",
GDALGetGCPProjection( hDataset ) );
OSRDestroySpatialReference( hSRS );
}
for( i = 0; i < GDALGetGCPCount(hDataset); i++ )
{
const GDAL_GCP *psGCP;
psGCP = GDALGetGCPs( hDataset ) + i;
printf( "GCP[%3d]: Id=%s, Info=%s\n"
" (%.15g,%.15g) -> (%.15g,%.15g,%.15g)\n",
i, psGCP->pszId, psGCP->pszInfo,
psGCP->dfGCPPixel, psGCP->dfGCPLine,
psGCP->dfGCPX, psGCP->dfGCPY, psGCP->dfGCPZ );
}
}
/* -------------------------------------------------------------------- */
/* Report metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, NULL ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
for( iMDD = 0; bShowMetadata && iMDD < CSLCount(papszExtraMDDomains); iMDD++ )
{
papszMetadata = GDALGetMetadata( hDataset, papszExtraMDDomains[iMDD] );
if( CSLCount(papszMetadata) > 0 )
{
printf( "Metadata (%s):\n", papszExtraMDDomains[iMDD]);
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
}
/* -------------------------------------------------------------------- */
/* Report "IMAGE_STRUCTURE" metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "IMAGE_STRUCTURE" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Image Structure Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report subdatasets. */
/* -------------------------------------------------------------------- */
papszMetadata = GDALGetMetadata( hDataset, "SUBDATASETS" );
if( CSLCount(papszMetadata) > 0 )
{
printf( "Subdatasets:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report geolocation. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "GEOLOCATION" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Geolocation:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report RPCs */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "RPC" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "RPC Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Setup projected to lat/long transform if appropriate. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
pszProjection = GDALGetProjectionRef(hDataset);
if( pszProjection != NULL && strlen(pszProjection) > 0 )
{
OGRSpatialReferenceH hProj, hLatLong = NULL;
hProj = OSRNewSpatialReference( pszProjection );
if( hProj != NULL )
hLatLong = OSRCloneGeogCS( hProj );
if( hLatLong != NULL )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
hTransform = OCTNewCoordinateTransformation( hProj, hLatLong );
CPLPopErrorHandler();
OSRDestroySpatialReference( hLatLong );
}
if( hProj != NULL )
OSRDestroySpatialReference( hProj );
}
/* -------------------------------------------------------------------- */
/* Report corners. */
/* -------------------------------------------------------------------- */
printf( "Corner Coordinates:\n" );
GDALInfoReportCorner( hDataset, hTransform, "Upper Left",
0.0, 0.0 );
GDALInfoReportCorner( hDataset, hTransform, "Lower Left",
0.0, GDALGetRasterYSize(hDataset));
GDALInfoReportCorner( hDataset, hTransform, "Upper Right",
GDALGetRasterXSize(hDataset), 0.0 );
GDALInfoReportCorner( hDataset, hTransform, "Lower Right",
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset) );
GDALInfoReportCorner( hDataset, hTransform, "Center",
GDALGetRasterXSize(hDataset)/2.0,
GDALGetRasterYSize(hDataset)/2.0 );
if( hTransform != NULL )
{
OCTDestroyCoordinateTransformation( hTransform );
hTransform = NULL;
}
/* ==================================================================== */
/* Loop over bands. */
/* ==================================================================== */
for( iBand = 0; iBand < GDALGetRasterCount( hDataset ); iBand++ )
{
double dfMin, dfMax, adfCMinMax[2], dfNoData;
int bGotMin, bGotMax, bGotNodata, bSuccess;
int nBlockXSize, nBlockYSize, nMaskFlags;
double dfMean, dfStdDev;
GDALColorTableH hTable;
CPLErr eErr;
hBand = GDALGetRasterBand( hDataset, iBand+1 );
if( bSample )
{
float afSample[10000];
int nCount;
nCount = GDALGetRandomRasterSample( hBand, 10000, afSample );
printf( "Got %d samples.\n", nCount );
}
GDALGetBlockSize( hBand, &nBlockXSize, &nBlockYSize );
printf( "Band %d Block=%dx%d Type=%s, ColorInterp=%s\n", iBand+1,
nBlockXSize, nBlockYSize,
GDALGetDataTypeName(
GDALGetRasterDataType(hBand)),
GDALGetColorInterpretationName(
GDALGetRasterColorInterpretation(hBand)) );
if( GDALGetDescription( hBand ) != NULL
&& strlen(GDALGetDescription( hBand )) > 0 )
printf( " Description = %s\n", GDALGetDescription(hBand) );
dfMin = GDALGetRasterMinimum( hBand, &bGotMin );
dfMax = GDALGetRasterMaximum( hBand, &bGotMax );
if( bGotMin || bGotMax || bComputeMinMax )
{
printf( " " );
if( bGotMin )
printf( "Min=%.3f ", dfMin );
if( bGotMax )
printf( "Max=%.3f ", dfMax );
if( bComputeMinMax )
{
CPLErrorReset();
GDALComputeRasterMinMax( hBand, FALSE, adfCMinMax );
if (CPLGetLastErrorType() == CE_None)
{
printf( " Computed Min/Max=%.3f,%.3f",
adfCMinMax[0], adfCMinMax[1] );
}
}
printf( "\n" );
}
eErr = GDALGetRasterStatistics( hBand, bApproxStats, bStats,
&dfMin, &dfMax, &dfMean, &dfStdDev );
if( eErr == CE_None )
{
printf( " Minimum=%.3f, Maximum=%.3f, Mean=%.3f, StdDev=%.3f\n",
dfMin, dfMax, dfMean, dfStdDev );
}
if( bReportHistograms )
{
int nBucketCount, *panHistogram = NULL;
eErr = GDALGetDefaultHistogram( hBand, &dfMin, &dfMax,
&nBucketCount, &panHistogram,
TRUE, GDALTermProgress, NULL );
if( eErr == CE_None )
{
int iBucket;
printf( " %d buckets from %g to %g:\n ",
nBucketCount, dfMin, dfMax );
for( iBucket = 0; iBucket < nBucketCount; iBucket++ )
printf( "%d ", panHistogram[iBucket] );
printf( "\n" );
CPLFree( panHistogram );
}
}
if ( bComputeChecksum)
{
printf( " Checksum=%d\n",
GDALChecksumImage(hBand, 0, 0,
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset)));
}
dfNoData = GDALGetRasterNoDataValue( hBand, &bGotNodata );
if( bGotNodata )
{
printf( " NoData Value=%.18g\n", dfNoData );
}
if( GDALGetOverviewCount(hBand) > 0 )
{
int iOverview;
printf( " Overviews: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
const char *pszResampling = NULL;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
pszResampling =
GDALGetMetadataItem( hOverview, "RESAMPLING", "" );
if( pszResampling != NULL
&& EQUALN(pszResampling,"AVERAGE_BIT2",12) )
printf( "*" );
}
printf( "\n" );
if ( bComputeChecksum)
{
printf( " Overviews checksum: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
printf( "%d",
GDALChecksumImage(hOverview, 0, 0,
GDALGetRasterBandXSize(hOverview),
GDALGetRasterBandYSize(hOverview)));
}
printf( "\n" );
}
}
if( GDALHasArbitraryOverviews( hBand ) )
{
printf( " Overviews: arbitrary\n" );
}
nMaskFlags = GDALGetMaskFlags( hBand );
if( (nMaskFlags & (GMF_NODATA|GMF_ALL_VALID)) == 0 )
{
GDALRasterBandH hMaskBand = GDALGetMaskBand(hBand) ;
printf( " Mask Flags: " );
if( nMaskFlags & GMF_PER_DATASET )
printf( "PER_DATASET " );
if( nMaskFlags & GMF_ALPHA )
printf( "ALPHA " );
if( nMaskFlags & GMF_NODATA )
printf( "NODATA " );
if( nMaskFlags & GMF_ALL_VALID )
printf( "ALL_VALID " );
printf( "\n" );
if( hMaskBand != NULL &&
GDALGetOverviewCount(hMaskBand) > 0 )
{
int iOverview;
printf( " Overviews of mask band: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hMaskBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hMaskBand, iOverview );
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
}
printf( "\n" );
}
}
if( strlen(GDALGetRasterUnitType(hBand)) > 0 )
{
printf( " Unit Type: %s\n", GDALGetRasterUnitType(hBand) );
}
if( GDALGetRasterCategoryNames(hBand) != NULL )
{
char **papszCategories = GDALGetRasterCategoryNames(hBand);
int i;
printf( " Categories:\n" );
for( i = 0; papszCategories[i] != NULL; i++ )
printf( " %3d: %s\n", i, papszCategories[i] );
}
if( GDALGetRasterScale( hBand, &bSuccess ) != 1.0
|| GDALGetRasterOffset( hBand, &bSuccess ) != 0.0 )
printf( " Offset: %.15g, Scale:%.15g\n",
GDALGetRasterOffset( hBand, &bSuccess ),
GDALGetRasterScale( hBand, &bSuccess ) );
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hBand, NULL ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( " Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hBand, "IMAGE_STRUCTURE" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( " Image Structure Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
if( GDALGetRasterColorInterpretation(hBand) == GCI_PaletteIndex
&& (hTable = GDALGetRasterColorTable( hBand )) != NULL )
{
int i;
printf( " Color Table (%s with %d entries)\n",
GDALGetPaletteInterpretationName(
GDALGetPaletteInterpretation( hTable )),
GDALGetColorEntryCount( hTable ) );
if (bShowColorTable)
{
for( i = 0; i < GDALGetColorEntryCount( hTable ); i++ )
{
GDALColorEntry sEntry;
GDALGetColorEntryAsRGB( hTable, i, &sEntry );
printf( " %3d: %d,%d,%d,%d\n",
i,
sEntry.c1,
sEntry.c2,
sEntry.c3,
sEntry.c4 );
}
}
}
if( bShowRAT && GDALGetDefaultRAT( hBand ) != NULL )
{
GDALRasterAttributeTableH hRAT = GDALGetDefaultRAT( hBand );
GDALRATDumpReadable( hRAT, NULL );
}
}
GDALClose( hDataset );
CSLDestroy( papszExtraMDDomains );
CSLDestroy( argv );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLDumpSharedList( NULL );
CPLCleanupTLS();
exit( 0 );
}
GDALDataset *
RasterliteCreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError(CE_Failure, CPLE_NotSupported, "nBands == 0");
return NULL;
}
const char* pszDriverName = CSLFetchNameValueDef(papszOptions, "DRIVER", "GTiff");
GDALDriverH hTileDriver = GDALGetDriverByName(pszDriverName);
if ( hTileDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL %s driver", pszDriverName);
return NULL;
}
GDALDriverH hMemDriver = GDALGetDriverByName("MEM");
if (hMemDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL MEM driver");
return NULL;
}
int nXSize = GDALGetRasterXSize(poSrcDS);
int nYSize = GDALGetRasterYSize(poSrcDS);
double adfGeoTransform[6];
if (poSrcDS->GetGeoTransform(adfGeoTransform) != CE_None)
{
adfGeoTransform[0] = 0;
adfGeoTransform[1] = 1;
adfGeoTransform[2] = 0;
adfGeoTransform[3] = 0;
adfGeoTransform[4] = 0;
adfGeoTransform[5] = -1;
}
else if (adfGeoTransform[2] != 0.0 || adfGeoTransform[4] != 0.0)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot use geotransform with rotational terms");
return NULL;
}
int bTiled = CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "TILED", "YES"));
int nBlockXSize, nBlockYSize;
if (bTiled)
{
nBlockXSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKXSIZE", "256"));
nBlockYSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKYSIZE", "256"));
if (nBlockXSize < 64) nBlockXSize = 64;
else if (nBlockXSize > 4096) nBlockXSize = 4096;
if (nBlockYSize < 64) nBlockYSize = 64;
else if (nBlockYSize > 4096) nBlockYSize = 4096;
}
else
{
nBlockXSize = nXSize;
nBlockYSize = nYSize;
}
/* -------------------------------------------------------------------- */
/* Analyze arguments */
/* -------------------------------------------------------------------- */
CPLString osDBName;
CPLString osTableName;
VSIStatBuf sBuf;
int bExists;
/* Skip optionnal RASTERLITE: prefix */
const char* pszFilenameWithoutPrefix = pszFilename;
if (EQUALN(pszFilename, "RASTERLITE:", 11))
pszFilenameWithoutPrefix += 11;
char** papszTokens = CSLTokenizeStringComplex(
pszFilenameWithoutPrefix, ", ", FALSE, FALSE );
int nTokens = CSLCount(papszTokens);
if (nTokens == 0)
{
osDBName = pszFilenameWithoutPrefix;
osTableName = CPLGetBasename(pszFilenameWithoutPrefix);
}
else
{
osDBName = papszTokens[0];
int i;
for(i=1;i<nTokens;i++)
{
if (EQUALN(papszTokens[i], "table=", 6))
osTableName = papszTokens[i] + 6;
else
{
CPLError(CE_Warning, CPLE_AppDefined,
"Invalid option : %s", papszTokens[i]);
}
}
}
CSLDestroy(papszTokens);
papszTokens = NULL;
bExists = (VSIStat(osDBName.c_str(), &sBuf) == 0);
if (osTableName.size() == 0)
{
if (bExists)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Database already exists. Explicit table name must be specified");
return NULL;
}
osTableName = CPLGetBasename(osDBName.c_str());
}
CPLString osRasterLayer;
osRasterLayer.Printf("%s_rasters", osTableName.c_str());
CPLString osMetatadataLayer;
osMetatadataLayer.Printf("%s_metadata", osTableName.c_str());
/* -------------------------------------------------------------------- */
/* Create or open the SQLite DB */
/* -------------------------------------------------------------------- */
if (OGRGetDriverCount() == 0)
OGRRegisterAll();
OGRSFDriverH hSQLiteDriver = OGRGetDriverByName("SQLite");
if (hSQLiteDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load OGR SQLite driver");
return NULL;
}
OGRDataSourceH hDS;
CPLString osOldVal =
CPLGetConfigOption("SQLITE_LIST_ALL_TABLES", "FALSE");
CPLSetConfigOption("SQLITE_LIST_ALL_TABLES", "TRUE");
if (!bExists)
{
char** papszOGROptions = CSLAddString(NULL, "SPATIALITE=YES");
hDS = OGR_Dr_CreateDataSource(hSQLiteDriver,
osDBName.c_str(), papszOGROptions);
CSLDestroy(papszOGROptions);
}
else
{
hDS = OGROpen(osDBName.c_str(), TRUE, NULL);
}
CPLSetConfigOption("SQLITE_LIST_ALL_TABLES", osOldVal.c_str());
if (hDS == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot load or create SQLite database");
return NULL;
}
CPLString osSQL;
/* -------------------------------------------------------------------- */
/* Get the SRID for the SRS */
/* -------------------------------------------------------------------- */
int nSRSId = RasterliteInsertSRID(hDS, poSrcDS->GetProjectionRef());
/* -------------------------------------------------------------------- */
/* Create or wipe existing tables */
/* -------------------------------------------------------------------- */
int bWipeExistingData =
CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "WIPE", "NO"));
hDS = RasterliteCreateTables(hDS, osTableName.c_str(),
nSRSId, bWipeExistingData);
if (hDS == NULL)
return NULL;
OGRLayerH hRasterLayer = OGR_DS_GetLayerByName(hDS, osRasterLayer.c_str());
OGRLayerH hMetadataLayer = OGR_DS_GetLayerByName(hDS, osMetatadataLayer.c_str());
if (hRasterLayer == NULL || hMetadataLayer == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot find metadata and/or raster tables");
OGRReleaseDataSource(hDS);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Check if there is overlapping data and warn the user */
/* -------------------------------------------------------------------- */
double minx = adfGeoTransform[0];
double maxx = adfGeoTransform[0] + nXSize * adfGeoTransform[1];
double maxy = adfGeoTransform[3];
double miny = adfGeoTransform[3] + nYSize * adfGeoTransform[5];
osSQL.Printf("SELECT COUNT(geometry) FROM \"%s\" "
"WHERE rowid IN "
"(SELECT pkid FROM \"idx_%s_metadata_geometry\" "
"WHERE xmin < %.15f AND xmax > %.15f "
"AND ymin < %.15f AND ymax > %.15f) "
"AND pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND "
"pixel_y_size >= %.15f AND pixel_y_size <= %.15f",
osMetatadataLayer.c_str(),
osTableName.c_str(),
maxx, minx, maxy, miny,
adfGeoTransform[1] - 1e-15, adfGeoTransform[1] + 1e-15,
- adfGeoTransform[5] - 1e-15, - adfGeoTransform[5] + 1e-15);
int nOverlappingGeoms = 0;
OGRLayerH hCountLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hCountLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hCountLyr);
if (hFeat)
{
nOverlappingGeoms = OGR_F_GetFieldAsInteger(hFeat, 0);
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hCountLyr);
}
if (nOverlappingGeoms != 0)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Raster tiles already exist in the %s table within "
"the extent of the data to be inserted in",
osTableName.c_str());
}
/* -------------------------------------------------------------------- */
/* Iterate over blocks to add data into raster and metadata tables */
/* -------------------------------------------------------------------- */
int nXBlocks = (nXSize + nBlockXSize - 1) / nBlockXSize;
int nYBlocks = (nYSize + nBlockYSize - 1) / nBlockYSize;
GDALDataType eDataType = poSrcDS->GetRasterBand(1)->GetRasterDataType();
int nDataTypeSize = GDALGetDataTypeSize(eDataType) / 8;
GByte* pabyMEMDSBuffer =
(GByte*)VSIMalloc3(nBlockXSize, nBlockYSize, nBands * nDataTypeSize);
if (pabyMEMDSBuffer == NULL)
{
OGRReleaseDataSource(hDS);
return NULL;
}
CPLString osTempFileName;
osTempFileName.Printf("/vsimem/%p", hDS);
int nTileId = 0;
int nBlocks = 0;
int nTotalBlocks = nXBlocks * nYBlocks;
char** papszTileDriverOptions = RasterliteGetTileDriverOptions(papszOptions);
OGR_DS_ExecuteSQL(hDS, "BEGIN", NULL, NULL);
CPLErr eErr = CE_None;
int nBlockXOff, nBlockYOff;
for(nBlockYOff=0;eErr == CE_None && nBlockYOff<nYBlocks;nBlockYOff++)
{
for(nBlockXOff=0;eErr == CE_None && nBlockXOff<nXBlocks;nBlockXOff++)
{
/* -------------------------------------------------------------------- */
/* Create in-memory tile */
/* -------------------------------------------------------------------- */
int nReqXSize = nBlockXSize, nReqYSize = nBlockYSize;
if ((nBlockXOff+1) * nBlockXSize > nXSize)
nReqXSize = nXSize - nBlockXOff * nBlockXSize;
if ((nBlockYOff+1) * nBlockYSize > nYSize)
nReqYSize = nYSize - nBlockYOff * nBlockYSize;
eErr = poSrcDS->RasterIO(GF_Read,
nBlockXOff * nBlockXSize,
nBlockYOff * nBlockYSize,
nReqXSize, nReqYSize,
pabyMEMDSBuffer, nReqXSize, nReqYSize,
eDataType, nBands, NULL,
0, 0, 0);
if (eErr != CE_None)
{
break;
}
GDALDatasetH hMemDS = GDALCreate(hMemDriver, "MEM:::",
nReqXSize, nReqYSize, 0,
eDataType, NULL);
if (hMemDS == NULL)
{
eErr = CE_Failure;
break;
}
int iBand;
for(iBand = 0; iBand < nBands; iBand ++)
{
char** papszMEMDSOptions = NULL;
char szTmp[64];
memset(szTmp, 0, sizeof(szTmp));
CPLPrintPointer(szTmp,
pabyMEMDSBuffer + iBand * nDataTypeSize *
nReqXSize * nReqYSize, sizeof(szTmp));
papszMEMDSOptions = CSLSetNameValue(papszMEMDSOptions, "DATAPOINTER", szTmp);
GDALAddBand(hMemDS, eDataType, papszMEMDSOptions);
CSLDestroy(papszMEMDSOptions);
}
GDALDatasetH hOutDS = GDALCreateCopy(hTileDriver,
osTempFileName.c_str(), hMemDS, FALSE,
papszTileDriverOptions, NULL, NULL);
GDALClose(hMemDS);
if (hOutDS)
GDALClose(hOutDS);
else
{
eErr = CE_Failure;
break;
}
/* -------------------------------------------------------------------- */
/* Insert new entry into raster table */
/* -------------------------------------------------------------------- */
vsi_l_offset nDataLength;
GByte *pabyData = VSIGetMemFileBuffer( osTempFileName.c_str(),
&nDataLength, FALSE);
OGRFeatureH hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hRasterLayer) );
OGR_F_SetFieldBinary(hFeat, 0, (int)nDataLength, pabyData);
OGR_L_CreateFeature(hRasterLayer, hFeat);
/* Query raster ID to set it as the ID of the associated metadata */
int nRasterID = (int)OGR_F_GetFID(hFeat);
OGR_F_Destroy(hFeat);
VSIUnlink(osTempFileName.c_str());
/* -------------------------------------------------------------------- */
/* Insert new entry into metadata table */
/* -------------------------------------------------------------------- */
hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hMetadataLayer) );
OGR_F_SetFID(hFeat, nRasterID);
OGR_F_SetFieldString(hFeat, 0, GDALGetDescription(poSrcDS));
OGR_F_SetFieldInteger(hFeat, 1, nTileId ++);
OGR_F_SetFieldInteger(hFeat, 2, nReqXSize);
OGR_F_SetFieldInteger(hFeat, 3, nReqYSize);
OGR_F_SetFieldDouble(hFeat, 4, adfGeoTransform[1]);
OGR_F_SetFieldDouble(hFeat, 5, -adfGeoTransform[5]);
minx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff) * adfGeoTransform[1];
maxx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff + nReqXSize) * adfGeoTransform[1];
maxy = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff) * adfGeoTransform[5];
miny = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff + nReqYSize) * adfGeoTransform[5];
OGRGeometryH hRectangle = OGR_G_CreateGeometry(wkbPolygon);
OGRGeometryH hLinearRing = OGR_G_CreateGeometry(wkbLinearRing);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddGeometryDirectly(hRectangle, hLinearRing);
OGR_F_SetGeometryDirectly(hFeat, hRectangle);
OGR_L_CreateFeature(hMetadataLayer, hFeat);
OGR_F_Destroy(hFeat);
nBlocks++;
if (pfnProgress && !pfnProgress(1.0 * nBlocks / nTotalBlocks,
NULL, pProgressData))
eErr = CE_Failure;
}
}
if (eErr == CE_None)
OGR_DS_ExecuteSQL(hDS, "COMMIT", NULL, NULL);
else
OGR_DS_ExecuteSQL(hDS, "ROLLBACK", NULL, NULL);
CSLDestroy(papszTileDriverOptions);
VSIFree(pabyMEMDSBuffer);
OGRReleaseDataSource(hDS);
return (GDALDataset*) GDALOpen(pszFilename, GA_Update);
}
void *GDALCreateGeoLocTransformer( GDALDatasetH hBaseDS,
char **papszGeolocationInfo,
int bReversed )
{
GDALGeoLocTransformInfo *psTransform;
if( CSLFetchNameValue(papszGeolocationInfo,"PIXEL_OFFSET") == NULL
|| CSLFetchNameValue(papszGeolocationInfo,"LINE_OFFSET") == NULL
|| CSLFetchNameValue(papszGeolocationInfo,"PIXEL_STEP") == NULL
|| CSLFetchNameValue(papszGeolocationInfo,"LINE_STEP") == NULL
|| CSLFetchNameValue(papszGeolocationInfo,"X_BAND") == NULL
|| CSLFetchNameValue(papszGeolocationInfo,"Y_BAND") == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Missing some geolocation fields in GDALCreateGeoLocTransformer()" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Initialize core info. */
/* -------------------------------------------------------------------- */
psTransform = (GDALGeoLocTransformInfo *)
CPLCalloc(sizeof(GDALGeoLocTransformInfo),1);
psTransform->bReversed = bReversed;
memcpy( psTransform->sTI.abySignature, GDAL_GTI2_SIGNATURE, strlen(GDAL_GTI2_SIGNATURE) );
psTransform->sTI.pszClassName = "GDALGeoLocTransformer";
psTransform->sTI.pfnTransform = GDALGeoLocTransform;
psTransform->sTI.pfnCleanup = GDALDestroyGeoLocTransformer;
psTransform->sTI.pfnSerialize = GDALSerializeGeoLocTransformer;
psTransform->sTI.pfnCreateSimilar = GDALCreateSimilarGeoLocTransformer;
psTransform->papszGeolocationInfo = CSLDuplicate( papszGeolocationInfo );
/* -------------------------------------------------------------------- */
/* Pull geolocation info from the options/metadata. */
/* -------------------------------------------------------------------- */
psTransform->dfPIXEL_OFFSET = CPLAtof(CSLFetchNameValue( papszGeolocationInfo,
"PIXEL_OFFSET" ));
psTransform->dfLINE_OFFSET = CPLAtof(CSLFetchNameValue( papszGeolocationInfo,
"LINE_OFFSET" ));
psTransform->dfPIXEL_STEP = CPLAtof(CSLFetchNameValue( papszGeolocationInfo,
"PIXEL_STEP" ));
psTransform->dfLINE_STEP = CPLAtof(CSLFetchNameValue( papszGeolocationInfo,
"LINE_STEP" ));
/* -------------------------------------------------------------------- */
/* Establish access to geolocation dataset(s). */
/* -------------------------------------------------------------------- */
const char *pszDSName = CSLFetchNameValue( papszGeolocationInfo,
"X_DATASET" );
if( pszDSName != NULL )
{
psTransform->hDS_X = GDALOpenShared( pszDSName, GA_ReadOnly );
}
else
{
psTransform->hDS_X = hBaseDS;
GDALReferenceDataset( psTransform->hDS_X );
psTransform->papszGeolocationInfo =
CSLSetNameValue( psTransform->papszGeolocationInfo,
"X_DATASET",
GDALGetDescription( hBaseDS ) );
}
pszDSName = CSLFetchNameValue( papszGeolocationInfo, "Y_DATASET" );
if( pszDSName != NULL )
{
psTransform->hDS_Y = GDALOpenShared( pszDSName, GA_ReadOnly );
}
else
{
psTransform->hDS_Y = hBaseDS;
GDALReferenceDataset( psTransform->hDS_Y );
psTransform->papszGeolocationInfo =
CSLSetNameValue( psTransform->papszGeolocationInfo,
"Y_DATASET",
GDALGetDescription( hBaseDS ) );
}
if (psTransform->hDS_X == NULL ||
psTransform->hDS_Y == NULL)
{
GDALDestroyGeoLocTransformer( psTransform );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Get the band handles. */
/* -------------------------------------------------------------------- */
int nBand;
nBand = MAX(1,atoi(CSLFetchNameValue( papszGeolocationInfo, "X_BAND" )));
psTransform->hBand_X = GDALGetRasterBand( psTransform->hDS_X, nBand );
nBand = MAX(1,atoi(CSLFetchNameValue( papszGeolocationInfo, "Y_BAND" )));
psTransform->hBand_Y = GDALGetRasterBand( psTransform->hDS_Y, nBand );
if (psTransform->hBand_X == NULL ||
psTransform->hBand_Y == NULL)
{
GDALDestroyGeoLocTransformer( psTransform );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Check that X and Y bands have the same dimensions */
/* -------------------------------------------------------------------- */
int nXSize_XBand = GDALGetRasterXSize( psTransform->hDS_X );
int nYSize_XBand = GDALGetRasterYSize( psTransform->hDS_X );
int nXSize_YBand = GDALGetRasterXSize( psTransform->hDS_Y );
int nYSize_YBand = GDALGetRasterYSize( psTransform->hDS_Y );
if (nYSize_XBand == 1 || nYSize_YBand == 1)
{
if (nYSize_XBand != 1 || nYSize_YBand != 1)
{
CPLError(CE_Failure, CPLE_AppDefined,
"X_BAND and Y_BAND should have both nYSize == 1");
GDALDestroyGeoLocTransformer( psTransform );
return NULL;
}
}
else if (nXSize_XBand != nXSize_YBand ||
nYSize_XBand != nYSize_YBand )
{
CPLError(CE_Failure, CPLE_AppDefined,
"X_BAND and Y_BAND do not have the same dimensions");
GDALDestroyGeoLocTransformer( psTransform );
return NULL;
}
if (nXSize_XBand > INT_MAX / nYSize_XBand)
{
CPLError(CE_Failure, CPLE_AppDefined, "Int overflow : %d x %d",
nXSize_XBand, nYSize_XBand);
GDALDestroyGeoLocTransformer( psTransform );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Load the geolocation array. */
/* -------------------------------------------------------------------- */
if( !GeoLocLoadFullData( psTransform )
|| !GeoLocGenerateBackMap( psTransform ) )
{
GDALDestroyGeoLocTransformer( psTransform );
return NULL;
}
return psTransform;
}
static ERL_NIF_TERM gdal_nif_get_meta(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
gdal_img_handle* handle;
if (enif_get_resource(env, argv[0], gdal_img_RESOURCE, (void**)&handle)) {
GDALDatasetH in_ds = handle->in_ds;
if (in_ds != NULL) {
ERL_NIF_TERM terms[8];
int idx = 0;
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "description"),
enif_make_string(env, GDALGetDescription(in_ds), ERL_NIF_LATIN1));
GDALDriverH hDriver = GDALGetDatasetDriver(in_ds);
char buf[256];
sprintf(buf, "%s/%s",
GDALGetDriverShortName(hDriver), GDALGetDriverLongName(hDriver));
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "driver"),
enif_make_string(env, buf, ERL_NIF_LATIN1));
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "rasterSize"),
enif_make_tuple2(env,
enif_make_int(env, GDALGetRasterXSize(in_ds)),
enif_make_int(env, GDALGetRasterYSize(in_ds))));
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "rasterCount"),
enif_make_int(env, GDALGetRasterCount(in_ds)));
double adfGeoTransform[6];
if( GDALGetGeoTransform( in_ds, adfGeoTransform ) == CE_None ) {
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "origin"),
enif_make_tuple2(env,
enif_make_double(env, adfGeoTransform[0]),
enif_make_double(env, adfGeoTransform[3])));
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "pixelSize"),
enif_make_tuple2(env,
enif_make_double(env, adfGeoTransform[1]),
enif_make_double(env, adfGeoTransform[5])));
}
if (GDALGetProjectionRef(in_ds) != NULL) {
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "projection"),
enif_make_string(env,
GDALGetProjectionRef(in_ds), ERL_NIF_LATIN1));
}
char** fileList = GDALGetFileList(in_ds);
if (fileList != NULL) {
ERL_NIF_TERM fileTerms[16];
int fileIdx = 0;
char** files = fileList;
do {
fileTerms[ fileIdx++ ] = enif_make_string(env, *files, ERL_NIF_LATIN1);
} while(*(++files)) ;
CSLDestroy(fileList);
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "fileList"),
enif_make_list_from_array(env, fileTerms, fileIdx));
}
return enif_make_list_from_array(env, terms, idx);
}
else {
return ATOM_NOT_OPEN;
}
}
else {
return enif_make_badarg(env);
}
}
CPLErr CPL_STDCALL
GDALComputeProximity(GDALRasterBandH hSrcBand,
GDALRasterBandH hProximityBand,
char **papszOptions,
GDALProgressFunc pfnProgress,
void *pProgressArg)
{
int nXSize, nYSize, i, bFixedBufVal = FALSE;
const char *pszOpt;
double dfMaxDist;
double dfFixedBufVal = 0.0;
VALIDATE_POINTER1(hSrcBand, "GDALComputeProximity", CE_Failure);
VALIDATE_POINTER1(hProximityBand, "GDALComputeProximity", CE_Failure);
if (pfnProgress == NULL)
pfnProgress = GDALDummyProgress;
/* -------------------------------------------------------------------- */
/* Are we using pixels or georeferenced coordinates for distances? */
/* -------------------------------------------------------------------- */
double dfDistMult = 1.0;
pszOpt = CSLFetchNameValue(papszOptions, "DISTUNITS");
if (pszOpt)
{
if (EQUAL(pszOpt, "GEO"))
{
GDALDatasetH hSrcDS = GDALGetBandDataset(hSrcBand);
if (hSrcDS)
{
double adfGeoTransform[6];
GDALGetGeoTransform(hSrcDS, adfGeoTransform);
if (ABS(adfGeoTransform[1]) != ABS(adfGeoTransform[5]))
CPLError(CE_Warning, CPLE_AppDefined,
"Pixels not square, distances will be inaccurate.");
dfDistMult = ABS(adfGeoTransform[1]);
}
}
else if (!EQUAL(pszOpt, "PIXEL"))
{
CPLError(CE_Failure, CPLE_AppDefined,
"Unrecognised DISTUNITS value '%s', should be GEO or PIXEL.",
pszOpt);
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* What is our maxdist value? */
/* -------------------------------------------------------------------- */
pszOpt = CSLFetchNameValue(papszOptions, "MAXDIST");
if (pszOpt)
dfMaxDist = atof(pszOpt) / dfDistMult;
else
dfMaxDist = GDALGetRasterBandXSize(hSrcBand) + GDALGetRasterBandYSize(hSrcBand);
CPLDebug("GDAL", "MAXDIST=%g, DISTMULT=%g", dfMaxDist, dfDistMult);
/* -------------------------------------------------------------------- */
/* Verify the source and destination are compatible. */
/* -------------------------------------------------------------------- */
nXSize = GDALGetRasterBandXSize(hSrcBand);
nYSize = GDALGetRasterBandYSize(hSrcBand);
if (nXSize != GDALGetRasterBandXSize(hProximityBand)
|| nYSize != GDALGetRasterBandYSize(hProximityBand))
{
CPLError(CE_Failure, CPLE_AppDefined,
"Source and proximity bands are not the same size.");
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Get output NODATA value. */
/* -------------------------------------------------------------------- */
float fNoDataValue;
pszOpt = CSLFetchNameValue(papszOptions, "NODATA");
if (pszOpt != NULL)
fNoDataValue = (float) atof(pszOpt);
else
{
int bSuccess;
fNoDataValue = (float) GDALGetRasterNoDataValue(hProximityBand, &bSuccess);
if (!bSuccess)
fNoDataValue = 65535.0;
}
/* -------------------------------------------------------------------- */
/* Is there a fixed value we wish to force the buffer area to? */
/* -------------------------------------------------------------------- */
pszOpt = CSLFetchNameValue(papszOptions, "FIXED_BUF_VAL");
if (pszOpt)
{
dfFixedBufVal = atof(pszOpt);
bFixedBufVal = TRUE;
}
/* -------------------------------------------------------------------- */
/* Get the target value(s). */
/* -------------------------------------------------------------------- */
int *panTargetValues = NULL;
int nTargetValues = 0;
pszOpt = CSLFetchNameValue(papszOptions, "VALUES");
if (pszOpt != NULL)
{
char **papszValuesTokens;
papszValuesTokens = CSLTokenizeStringComplex(pszOpt, ",", FALSE, FALSE);
nTargetValues = CSLCount(papszValuesTokens);
panTargetValues = (int*) CPLCalloc(sizeof(int), nTargetValues);
for (i = 0; i < nTargetValues; i++)
panTargetValues[i] = atoi(papszValuesTokens[i]);
CSLDestroy(papszValuesTokens);
}
/* -------------------------------------------------------------------- */
/* Initialize progress counter. */
/* -------------------------------------------------------------------- */
if (!pfnProgress(0.0, "", pProgressArg))
{
CPLError(CE_Failure, CPLE_UserInterrupt, "User terminated");
CPLFree(panTargetValues);
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* We need a signed type for the working proximity values kept */
/* on disk. If our proximity band is not signed, then create a */
/* temporary file for this purpose. */
/* -------------------------------------------------------------------- */
GDALRasterBandH hWorkProximityBand = hProximityBand;
GDALDatasetH hWorkProximityDS = NULL;
GDALDataType eProxType = GDALGetRasterDataType(hProximityBand);
int *panNearX = NULL, *panNearY = NULL;
float *pafProximity = NULL;
GInt32 *panSrcScanline = NULL;
int iLine;
CPLErr eErr = CE_None;
if (eProxType == GDT_Byte
|| eProxType == GDT_UInt16
|| eProxType == GDT_UInt32)
{
GDALDriverH hDriver = GDALGetDriverByName("GTiff");
if (hDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"GDALComputeProximity needs GTiff driver");
eErr = CE_Failure;
goto end;
}
CPLString osTmpFile = CPLGenerateTempFilename("proximity");
hWorkProximityDS =
GDALCreate(hDriver, osTmpFile,
nXSize, nYSize, 1, GDT_Float32, NULL);
if (hWorkProximityDS == NULL)
{
eErr = CE_Failure;
goto end;
}
hWorkProximityBand = GDALGetRasterBand(hWorkProximityDS, 1);
}
/* -------------------------------------------------------------------- */
/* Allocate buffer for two scanlines of distances as floats */
/* (the current and last line). */
/* -------------------------------------------------------------------- */
pafProximity = (float*) VSIMalloc2(sizeof(float), nXSize);
panNearX = (int*) VSIMalloc2(sizeof(int), nXSize);
panNearY = (int*) VSIMalloc2(sizeof(int), nXSize);
panSrcScanline = (GInt32*) VSIMalloc2(sizeof(GInt32), nXSize);
if (pafProximity == NULL
|| panNearX == NULL
|| panNearY == NULL
|| panSrcScanline == NULL)
{
CPLError(CE_Failure, CPLE_OutOfMemory,
"Out of memory allocating working buffers.");
eErr = CE_Failure;
goto end;
}
/* -------------------------------------------------------------------- */
/* Loop from top to bottom of the image. */
/* -------------------------------------------------------------------- */
for (i = 0; i < nXSize; i++)
panNearX[i] = panNearY[i] = -1;
for (iLine = 0; eErr == CE_None && iLine < nYSize; iLine++)
{
// Read for target values.
eErr = GDALRasterIO(hSrcBand, GF_Read, 0, iLine, nXSize, 1,
panSrcScanline, nXSize, 1, GDT_Int32, 0, 0);
if (eErr != CE_None)
break;
for (i = 0; i < nXSize; i++)
pafProximity[i] = -1.0;
// Left to right
ProcessProximityLine(panSrcScanline, panNearX, panNearY,
TRUE, iLine, nXSize, dfMaxDist,
pafProximity, nTargetValues, panTargetValues);
// Right to Left
ProcessProximityLine(panSrcScanline, panNearX, panNearY,
FALSE, iLine, nXSize, dfMaxDist,
pafProximity, nTargetValues, panTargetValues);
// Write out results.
eErr =
GDALRasterIO(hWorkProximityBand, GF_Write, 0, iLine, nXSize, 1,
pafProximity, nXSize, 1, GDT_Float32, 0, 0);
if (eErr != CE_None)
break;
if (!pfnProgress(0.5 * (iLine + 1) / (double) nYSize,
"", pProgressArg))
{
CPLError(CE_Failure, CPLE_UserInterrupt, "User terminated");
eErr = CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Loop from bottom to top of the image. */
/* -------------------------------------------------------------------- */
for (i = 0; i < nXSize; i++)
panNearX[i] = panNearY[i] = -1;
for (iLine = nYSize - 1; eErr == CE_None && iLine >= 0; iLine--)
{
// Read first pass proximity
eErr =
GDALRasterIO(hWorkProximityBand, GF_Read, 0, iLine, nXSize, 1,
pafProximity, nXSize, 1, GDT_Float32, 0, 0);
if (eErr != CE_None)
break;
// Read pixel values.
eErr = GDALRasterIO(hSrcBand, GF_Read, 0, iLine, nXSize, 1,
panSrcScanline, nXSize, 1, GDT_Int32, 0, 0);
if (eErr != CE_None)
break;
// Right to left
ProcessProximityLine(panSrcScanline, panNearX, panNearY,
FALSE, iLine, nXSize, dfMaxDist,
pafProximity, nTargetValues, panTargetValues);
// Left to right
ProcessProximityLine(panSrcScanline, panNearX, panNearY,
TRUE, iLine, nXSize, dfMaxDist,
pafProximity, nTargetValues, panTargetValues);
// Final post processing of distances.
for (i = 0; i < nXSize; i++)
{
if (pafProximity[i] < 0.0)
pafProximity[i] = fNoDataValue;
else if (pafProximity[i] > 0.0)
{
if (bFixedBufVal)
pafProximity[i] = (float) dfFixedBufVal;
else
pafProximity[i] = (float)(pafProximity[i] * dfDistMult);
}
}
// Write out results.
eErr =
GDALRasterIO(hProximityBand, GF_Write, 0, iLine, nXSize, 1,
pafProximity, nXSize, 1, GDT_Float32, 0, 0);
if (eErr != CE_None)
break;
if (!pfnProgress(0.5 + 0.5 * (nYSize - iLine) / (double) nYSize,
"", pProgressArg))
{
CPLError(CE_Failure, CPLE_UserInterrupt, "User terminated");
eErr = CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
end:
CPLFree(panNearX);
CPLFree(panNearY);
CPLFree(panSrcScanline);
CPLFree(pafProximity);
CPLFree(panTargetValues);
if (hWorkProximityDS != NULL)
{
CPLString osProxFile = GDALGetDescription(hWorkProximityDS);
GDALClose(hWorkProximityDS);
GDALDeleteDataset(GDALGetDriverByName("GTiff"), osProxFile);
}
return eErr;
}
HeatmapGui::HeatmapGui( QWidget* parent, Qt::WindowFlags fl, QMap<QString, QVariant>* temporarySettings )
: QDialog( parent, fl )
, mRows( 500 )
{
setupUi( this );
QgsDebugMsg( QString( "Creating Heatmap Dialog" ) );
blockAllSignals( true );
mKernelShapeCombo->addItem( tr( "Quartic (biweight)" ), Heatmap::Quartic );
mKernelShapeCombo->addItem( tr( "Triangular" ), Heatmap::Triangular );
mKernelShapeCombo->addItem( tr( "Uniform" ), Heatmap::Uniform );
mKernelShapeCombo->addItem( tr( "Triweight" ), Heatmap::Triweight );
mKernelShapeCombo->addItem( tr( "Epanechnikov" ), Heatmap::Epanechnikov );
mOutputValuesComboBox->addItem( tr( "Raw values" ), Heatmap::Raw );
mOutputValuesComboBox->addItem( tr( "Scaled by kernel size" ), Heatmap::Scaled );
mHeatmapSessionSettings = temporarySettings;
// Adding point layers to the inputLayerCombo
QString lastUsedLayer = mHeatmapSessionSettings->value( QString( "lastInputLayer" ) ).toString();
bool usingLastInputLayer = false;
mInputLayerCombo->setFilters( QgsMapLayerProxyModel::PointLayer );
QgsMapLayer* defaultLayer = QgsMapLayerRegistry::instance()->mapLayer( lastUsedLayer );
if ( defaultLayer )
{
mInputLayerCombo->setLayer( defaultLayer );
usingLastInputLayer = true;
}
mRadiusFieldCombo->setFilters( QgsFieldProxyModel::Numeric );
mWeightFieldCombo->setFilters( QgsFieldProxyModel::Numeric );
connect( mInputLayerCombo, SIGNAL( layerChanged( QgsMapLayer* ) ), mRadiusFieldCombo, SLOT( setLayer( QgsMapLayer* ) ) );
connect( mInputLayerCombo, SIGNAL( layerChanged( QgsMapLayer* ) ), mWeightFieldCombo, SLOT( setLayer( QgsMapLayer* ) ) );
mRadiusFieldCombo->setLayer( mInputLayerCombo->currentLayer() );
mWeightFieldCombo->setLayer( mInputLayerCombo->currentLayer() );
// Adding GDAL drivers with CREATE to mFormatCombo
int myTiffIndex = -1;
int myIndex = -1;
GDALAllRegister();
int nDrivers = GDALGetDriverCount();
for ( int i = 0; i < nDrivers; i += 1 )
{
GDALDriverH nthDriver = GDALGetDriver( i );
char **driverMetadata = GDALGetMetadata( nthDriver, nullptr );
// Only formats which allow creation of Float32 data types are valid
if ( CSLFetchBoolean( driverMetadata, GDAL_DCAP_CREATE, false ) &&
QString( GDALGetMetadataItem( nthDriver, GDAL_DMD_CREATIONDATATYPES, nullptr ) ).contains( "Float32" ) )
{
++myIndex;
QString myLongName = GDALGetMetadataItem( nthDriver, GDAL_DMD_LONGNAME, nullptr );
// Add LongName text, shortname variant; GetDescription actually gets the shortname
mFormatCombo->addItem( myLongName, QVariant( GDALGetDescription( nthDriver ) ) );
// Add the drivers and their extensions to a map for filename correction
mExtensionMap.insert( GDALGetDescription( nthDriver ), GDALGetMetadataItem( nthDriver, GDAL_DMD_EXTENSION, nullptr ) );
if ( myLongName == "GeoTIFF" )
{
myTiffIndex = myIndex;
}
}
}
//Restore choice of output format from last run
QSettings s;
int defaultFormatIndex = s.value( "/Heatmap/lastFormat", myTiffIndex ).toInt();
mFormatCombo->setCurrentIndex( defaultFormatIndex );
restoreSettings( usingLastInputLayer );
updateBBox();
updateSize();
mAddToCanvas->setChecked( s.value( "/Heatmap/addToCanvas", true ).toBool() );
blockAllSignals( false );
//finally set right the ok button
enableOrDisableOkButton();
}
/** Apply a vertical shift grid to a source (DEM typically) dataset.
*
* hGridDataset will typically use WGS84 as horizontal datum (but this is
* not a requirement) and its values are the values to add to go from geoid
* elevations to WGS84 ellipsoidal heights.
*
* hGridDataset will be on-the-fly reprojected and resampled to the projection
* and resolution of hSrcDataset, using bilinear resampling by default.
*
* Both hSrcDataset and hGridDataset must be single band datasets, and have
* a valid geotransform and projection.
*
* On success, a reference will be taken on hSrcDataset and hGridDataset.
* Reference counting semantics on the source and grid datasets should be
* honoured. That is, don't just GDALClose() it, unless it was opened with
* GDALOpenShared(), but rather use GDALReleaseDataset() if wanting to
* immediately release the reference(s) and make the returned dataset the
* owner of them.
*
* Valid use cases:
*
* \code
* hSrcDataset = GDALOpen(...)
* hGridDataset = GDALOpen(...)
* hDstDataset = GDALApplyVerticalShiftGrid(hSrcDataset, hGridDataset, ...)
* GDALReleaseDataset(hSrcDataset);
* GDALReleaseDataset(hGridDataset);
* if( hDstDataset )
* {
* // Do things with hDstDataset
* GDALClose(hDstDataset) // will close hSrcDataset and hGridDataset
* }
* \endcode
*
* @param hSrcDataset source (DEM) dataset. Must not be NULL.
* @param hGridDataset vertical grid shift dataset. Must not be NULL.
* @param bInverse if set to FALSE, hGridDataset values will be added to
* hSrcDataset. If set to TRUE, they will be subtracted.
* @param dfSrcUnitToMeter the factor to convert values from hSrcDataset to
* meters (1.0 if source values are in meter).
* @param dfDstUnitToMeter the factor to convert shifted values from meter
* (1.0 if output values must be in meter).
* @param papszOptions list of options, or NULL. Supported options are:
* <ul>
* <li>RESAMPLING=NEAREST/BILINEAR/CUBIC. Defaults to BILINEAR.</li>
* <li>MAX_ERROR=val. Maximum error measured in input pixels that is allowed in
* approximating the transformation (0.0 for exact calculations). Defaults
* to 0.125</li>
* <li>DATATYPE=Byte/UInt16/Int16/Float32/Float64. Output data type. If not
* specified will be the same as the one of hSrcDataset.
* <li>ERROR_ON_MISSING_VERT_SHIFT=YES/NO. Whether a missing/nodata value in
* hGridDataset should cause I/O requests to fail. Default is NO (in which case
* 0 will be used)
* <li>SRC_SRS=srs_def. Override projection on hSrcDataset;
* </ul>
*
* @return a new dataset corresponding to hSrcDataset adjusted with
* hGridDataset, or NULL. If not NULL, it must be closed with GDALClose().
*
* @since GDAL 2.2
*/
GDALDatasetH GDALApplyVerticalShiftGrid( GDALDatasetH hSrcDataset,
GDALDatasetH hGridDataset,
int bInverse,
double dfSrcUnitToMeter,
double dfDstUnitToMeter,
const char* const* papszOptions )
{
VALIDATE_POINTER1( hSrcDataset, "GDALApplyVerticalShiftGrid", nullptr );
VALIDATE_POINTER1( hGridDataset, "GDALApplyVerticalShiftGrid", nullptr );
double adfSrcGT[6];
if( GDALGetGeoTransform(hSrcDataset, adfSrcGT) != CE_None )
{
CPLError(CE_Failure, CPLE_NotSupported,
"Source dataset has no geotransform.");
return nullptr;
}
const char* pszSrcProjection = CSLFetchNameValueDef(papszOptions,
"SRC_SRS",
GDALGetProjectionRef(hSrcDataset));
if( pszSrcProjection == nullptr || pszSrcProjection[0] == '\0' )
{
CPLError(CE_Failure, CPLE_NotSupported,
"Source dataset has no projection.");
return nullptr;
}
if( GDALGetRasterCount(hSrcDataset) != 1 )
{
CPLError(CE_Failure, CPLE_NotSupported,
"Only single band source dataset is supported.");
return nullptr;
}
double adfGridGT[6];
if( GDALGetGeoTransform(hGridDataset, adfGridGT) != CE_None )
{
CPLError(CE_Failure, CPLE_NotSupported,
"Grid dataset has no geotransform.");
return nullptr;
}
const char* pszGridProjection = GDALGetProjectionRef(hGridDataset);
if( pszGridProjection == nullptr || pszGridProjection[0] == '\0' )
{
CPLError(CE_Failure, CPLE_NotSupported,
"Grid dataset has no projection.");
return nullptr;
}
if( GDALGetRasterCount(hGridDataset) != 1 )
{
CPLError(CE_Failure, CPLE_NotSupported,
"Only single band grid dataset is supported.");
return nullptr;
}
GDALDataType eDT = GDALGetRasterDataType(GDALGetRasterBand(hSrcDataset,1));
const char* pszDataType = CSLFetchNameValue(papszOptions, "DATATYPE");
if( pszDataType )
eDT = GDALGetDataTypeByName(pszDataType);
if( eDT == GDT_Unknown )
{
CPLError(CE_Failure, CPLE_NotSupported,
"Invalid DATATYPE=%s", pszDataType);
return nullptr;
}
const int nSrcXSize = GDALGetRasterXSize(hSrcDataset);
const int nSrcYSize = GDALGetRasterYSize(hSrcDataset);
OGRSpatialReference oSRS;
CPLString osSrcProjection(pszSrcProjection);
oSRS.SetFromUserInput(osSrcProjection);
if( oSRS.IsCompound() )
{
OGR_SRSNode* poNode = oSRS.GetRoot()->GetChild(1);
if( poNode != nullptr )
{
char* pszWKT = nullptr;
poNode->exportToWkt(&pszWKT);
osSrcProjection = pszWKT;
CPLFree(pszWKT);
}
}
void* hTransform = GDALCreateGenImgProjTransformer3( pszGridProjection,
adfGridGT,
osSrcProjection,
adfSrcGT );
if( hTransform == nullptr )
return nullptr;
GDALWarpOptions* psWO = GDALCreateWarpOptions();
psWO->hSrcDS = hGridDataset;
psWO->eResampleAlg = GRA_Bilinear;
const char* pszResampling = CSLFetchNameValue(papszOptions, "RESAMPLING");
if( pszResampling )
{
if( EQUAL(pszResampling, "NEAREST") )
psWO->eResampleAlg = GRA_NearestNeighbour;
else if( EQUAL(pszResampling, "BILINEAR") )
psWO->eResampleAlg = GRA_Bilinear;
else if( EQUAL(pszResampling, "CUBIC") )
psWO->eResampleAlg = GRA_Cubic;
}
psWO->eWorkingDataType = GDT_Float32;
int bHasNoData = FALSE;
const double dfSrcNoData = GDALGetRasterNoDataValue(
GDALGetRasterBand(hGridDataset, 1), &bHasNoData );
if( bHasNoData )
{
psWO->padfSrcNoDataReal =
static_cast<double*>(CPLMalloc(sizeof(double)));
psWO->padfSrcNoDataReal[0] = dfSrcNoData;
}
psWO->padfDstNoDataReal = static_cast<double*>(CPLMalloc(sizeof(double)));
const bool bErrorOnMissingShift = CPLFetchBool( papszOptions,
"ERROR_ON_MISSING_VERT_SHIFT",
false );
psWO->padfDstNoDataReal[0] =
(bErrorOnMissingShift) ? -std::numeric_limits<float>::infinity() : 0.0;
psWO->papszWarpOptions = CSLSetNameValue(psWO->papszWarpOptions,
"INIT_DEST",
"NO_DATA");
psWO->pfnTransformer = GDALGenImgProjTransform;
psWO->pTransformerArg = hTransform;
const double dfMaxError = CPLAtof(CSLFetchNameValueDef(papszOptions,
"MAX_ERROR",
"0.125"));
if( dfMaxError > 0.0 )
{
psWO->pTransformerArg =
GDALCreateApproxTransformer( psWO->pfnTransformer,
psWO->pTransformerArg,
dfMaxError );
psWO->pfnTransformer = GDALApproxTransform;
GDALApproxTransformerOwnsSubtransformer(psWO->pTransformerArg, TRUE);
}
psWO->nBandCount = 1;
psWO->panSrcBands = static_cast<int *>(CPLMalloc(sizeof(int)));
psWO->panSrcBands[0] = 1;
psWO->panDstBands = static_cast<int *>(CPLMalloc(sizeof(int)));
psWO->panDstBands[0] = 1;
VRTWarpedDataset* poReprojectedGrid =
new VRTWarpedDataset(nSrcXSize, nSrcYSize);
// This takes a reference on hGridDataset
CPLErr eErr = poReprojectedGrid->Initialize(psWO);
CPLAssert(eErr == CE_None);
CPL_IGNORE_RET_VAL(eErr);
GDALDestroyWarpOptions(psWO);
poReprojectedGrid->SetGeoTransform(adfSrcGT);
poReprojectedGrid->AddBand(GDT_Float32, nullptr);
GDALApplyVSGDataset* poOutDS = new GDALApplyVSGDataset(
reinterpret_cast<GDALDataset*>(hSrcDataset),
poReprojectedGrid,
eDT,
CPL_TO_BOOL(bInverse),
dfSrcUnitToMeter,
dfDstUnitToMeter,
// Undocumented option. For testing only
atoi(CSLFetchNameValueDef(papszOptions, "BLOCKSIZE", "256")) );
poReprojectedGrid->ReleaseRef();
if( !poOutDS->IsInitOK() )
{
delete poOutDS;
return nullptr;
}
poOutDS->SetDescription( GDALGetDescription( hSrcDataset ) );
return reinterpret_cast<GDALDatasetH>(poOutDS);
}
int main( int nArgc, char ** papszArgv )
{
GDALDatasetH hDS = NULL;
GDALDatasetH hODS = NULL;
int bCloseODS = TRUE;
int bUsageError = FALSE;
GDALDatasetH hDstDS;
int nRetCode = 1;
GDALVectorTranslateOptionsForBinary* psOptionsForBinary;
GDALVectorTranslateOptions *psOptions;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(papszArgv[0]))
exit(1);
EarlySetConfigOptions(nArgc, papszArgv);
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 1 )
{
papszArgv = NULL;
nRetCode = -nArgc;
goto exit;
}
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
nRetCode = 0;
goto exit;
}
else if( EQUAL(papszArgv[iArg],"--help") )
{
Usage();
goto exit;
}
else if ( EQUAL(papszArgv[iArg], "--long-usage") )
{
Usage(FALSE);
goto exit;
}
}
psOptionsForBinary = GDALVectorTranslateOptionsForBinaryNew();
psOptions = GDALVectorTranslateOptionsNew(papszArgv + 1, psOptionsForBinary);
if( psOptions == NULL )
{
Usage();
GDALVectorTranslateOptionsForBinaryFree(psOptionsForBinary);
goto exit;
}
if( psOptionsForBinary->pszDataSource == NULL ||
psOptionsForBinary->pszDestDataSource == NULL )
{
if( psOptionsForBinary->pszDestDataSource == NULL )
Usage("no target datasource provided");
else
Usage("no source datasource provided");
GDALVectorTranslateOptionsFree(psOptions);
GDALVectorTranslateOptionsForBinaryFree(psOptionsForBinary);
goto exit;
}
if( strcmp(psOptionsForBinary->pszDestDataSource, "/vsistdout/") == 0 )
psOptionsForBinary->bQuiet = TRUE;
if (!psOptionsForBinary->bQuiet && !psOptionsForBinary->bFormatExplicitlySet &&
psOptionsForBinary->eAccessMode == ACCESS_CREATION)
{
CheckDestDataSourceNameConsistency(psOptionsForBinary->pszDestDataSource,
psOptionsForBinary->pszFormat);
}
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
/* Avoid opening twice the same datasource if it is both the input and output */
/* Known to cause problems with at least FGdb, SQlite and GPKG drivers. See #4270 */
if (psOptionsForBinary->eAccessMode != ACCESS_CREATION &&
strcmp(psOptionsForBinary->pszDestDataSource, psOptionsForBinary->pszDataSource) == 0)
{
hODS = GDALOpenEx( psOptionsForBinary->pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_VECTOR, NULL, psOptionsForBinary->papszOpenOptions, NULL );
GDALDriverH hDriver = NULL;
if( hODS != NULL )
hDriver = GDALGetDatasetDriver(hODS);
/* Restrict to those 3 drivers. For example it is known to break with */
/* the PG driver due to the way it manages transactions... */
if (hDriver && !(EQUAL(GDALGetDescription(hDriver), "FileGDB") ||
EQUAL(GDALGetDescription(hDriver), "SQLite") ||
EQUAL(GDALGetDescription(hDriver), "GPKG")))
{
hDS = GDALOpenEx( psOptionsForBinary->pszDataSource,
GDAL_OF_VECTOR, NULL, psOptionsForBinary->papszOpenOptions, NULL );
}
else
{
hDS = hODS;
bCloseODS = FALSE;
}
}
else
{
hDS = GDALOpenEx( psOptionsForBinary->pszDataSource,
GDAL_OF_VECTOR, NULL, psOptionsForBinary->papszOpenOptions, NULL );
}
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( hDS == NULL )
{
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
fprintf( stderr, "FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
psOptionsForBinary->pszDataSource );
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetDescription() );
}
GDALVectorTranslateOptionsFree(psOptions);
GDALVectorTranslateOptionsForBinaryFree(psOptionsForBinary);
goto exit;
}
if( !(psOptionsForBinary->bQuiet) )
{
GDALVectorTranslateOptionsSetProgress(psOptions, GDALTermProgress, NULL);
}
hDstDS = GDALVectorTranslate(psOptionsForBinary->pszDestDataSource, hODS,
1, &hDS, psOptions, &bUsageError);
if( bUsageError )
Usage();
else
nRetCode = (hDstDS) ? 0 : 1;
GDALVectorTranslateOptionsFree(psOptions);
GDALVectorTranslateOptionsForBinaryFree(psOptionsForBinary);
if(hDS)
GDALClose(hDS);
if(bCloseODS)
GDALClose(hDstDS);
exit:
CSLDestroy( papszArgv );
OGRCleanupAll();
return nRetCode;
}