static
void CheckDestDataSourceNameConsistency(const char* pszDestFilename,
const char* pszDriverName)
{
int i;
char* pszDestExtension = CPLStrdup(CPLGetExtension(pszDestFilename));
if( EQUAL(pszDriverName, "GMT") )
pszDriverName = "OGR_GMT";
CheckExtensionConsistency(pszDestFilename, pszDriverName);
static const char* apszBeginName[][2] = { { "PG:" , "PostgreSQL" },
{ "MySQL:" , "MySQL" },
{ "CouchDB:" , "CouchDB" },
{ "GFT:" , "GFT" },
{ "MSSQL:" , "MSSQLSpatial" },
{ "ODBC:" , "ODBC" },
{ "OCI:" , "OCI" },
{ "SDE:" , "SDE" },
{ "WFS:" , "WFS" },
{ NULL, NULL }
};
for(i=0; apszBeginName[i][0] != NULL; i++)
{
if (EQUALN(pszDestFilename, apszBeginName[i][0], strlen(apszBeginName[i][0])) &&
!EQUAL(pszDriverName, apszBeginName[i][1]))
{
CPLError(CE_Warning, CPLE_AppDefined,
"The target file has a name which is normally recognized by the %s driver,\n"
"but the requested output driver is %s. Is it really what you want ?\n",
apszBeginName[i][1],
pszDriverName);
break;
}
}
CPLFree(pszDestExtension);
}
int main( int argc, char ** argv )
{
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
exit(1);
EarlySetConfigOptions(argc, argv);
/* -------------------------------------------------------------------- */
/* Register standard GDAL drivers, and process generic GDAL */
/* command options. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 2 )
{
Usage("Not enough arguments.");
}
if( EQUAL(argv[1], "--utility_version") || EQUAL(argv[1], "--utility-version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
CSLDestroy( argv );
return 0;
}
else if( EQUAL(argv[1],"--help") )
Usage();
GDALDEMProcessingOptionsForBinary* psOptionsForBinary = GDALDEMProcessingOptionsForBinaryNew();
GDALDEMProcessingOptions *psOptions = GDALDEMProcessingOptionsNew(argv + 1, psOptionsForBinary);
CSLDestroy( argv );
if( psOptions == NULL )
{
Usage();
}
if( !(psOptionsForBinary->bQuiet) )
{
GDALDEMProcessingOptionsSetProgress(psOptions, GDALTermProgress, NULL);
}
if( psOptionsForBinary->pszSrcFilename == NULL )
{
Usage("Missing source.");
}
if ( EQUAL(psOptionsForBinary->pszProcessing, "color-relief") && psOptionsForBinary->pszColorFilename == NULL )
{
Usage("Missing color file.");
}
if( psOptionsForBinary->pszDstFilename == NULL )
{
Usage("Missing destination.");
}
if (!psOptionsForBinary->bQuiet && !psOptionsForBinary->bFormatExplicitlySet)
CheckExtensionConsistency(psOptionsForBinary->pszDstFilename, psOptionsForBinary->pszFormat);
// Open Dataset and get raster band
GDALDatasetH hSrcDataset = GDALOpen( psOptionsForBinary->pszSrcFilename, GA_ReadOnly );
if( hSrcDataset == NULL )
{
fprintf( stderr,
"GDALOpen failed - %d\n%s\n",
CPLGetLastErrorNo(), CPLGetLastErrorMsg() );
GDALDestroyDriverManager();
exit( 1 );
}
int bUsageError = FALSE;
GDALDatasetH hOutDS = GDALDEMProcessing(psOptionsForBinary->pszDstFilename, hSrcDataset,
psOptionsForBinary->pszProcessing,
psOptionsForBinary->pszColorFilename,
psOptions, &bUsageError);
if(bUsageError == TRUE)
Usage();
int nRetCode = (hOutDS) ? 0 : 1;
GDALClose(hSrcDataset);
GDALClose(hOutDS);
GDALDEMProcessingOptionsFree(psOptions);
GDALDEMProcessingOptionsForBinaryFree(psOptionsForBinary);
GDALDestroyDriverManager();
return nRetCode;
}
int main( int argc, char ** argv )
{
GDALDriverH hDriver;
const char *pszSource=NULL, *pszDest=NULL, *pszFormat = "GTiff";
int bFormatExplicitelySet = FALSE;
char **papszLayers = NULL;
const char *pszBurnAttribute = NULL;
double dfIncreaseBurnValue = 0.0;
double dfMultiplyBurnValue = 1.0;
const char *pszWHERE = NULL, *pszSQL = NULL;
GDALDataType eOutputType = GDT_Float64;
char **papszCreateOptions = NULL;
GUInt32 nXSize = 0, nYSize = 0;
double dfXMin = 0.0, dfXMax = 0.0, dfYMin = 0.0, dfYMax = 0.0;
int bIsXExtentSet = FALSE, bIsYExtentSet = FALSE;
GDALGridAlgorithm eAlgorithm = GGA_InverseDistanceToAPower;
void *pOptions = NULL;
char *pszOutputSRS = NULL;
int bQuiet = FALSE;
GDALProgressFunc pfnProgress = GDALTermProgress;
int i;
OGRGeometry *poSpatialFilter = NULL;
int bClipSrc = FALSE;
OGRGeometry *poClipSrc = NULL;
const char *pszClipSrcDS = NULL;
const char *pszClipSrcSQL = NULL;
const char *pszClipSrcLayer = NULL;
const char *pszClipSrcWhere = NULL;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
exit(1);
GDALAllRegister();
OGRRegisterAll();
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],"--help") )
Usage();
else if( EQUAL(argv[i],"-of") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszFormat = argv[++i];
bFormatExplicitelySet = TRUE;
}
else if( EQUAL(argv[i],"-q") || EQUAL(argv[i],"-quiet") )
{
bQuiet = TRUE;
pfnProgress = GDALDummyProgress;
}
else if( EQUAL(argv[i],"-ot") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
int iType;
for( iType = 1; iType < GDT_TypeCount; iType++ )
{
if( GDALGetDataTypeName((GDALDataType)iType) != NULL
&& EQUAL(GDALGetDataTypeName((GDALDataType)iType),
argv[i+1]) )
{
eOutputType = (GDALDataType) iType;
}
}
if( eOutputType == GDT_Unknown )
{
Usage(CPLSPrintf("Unknown output pixel type: %s.",
argv[i + 1] ));
}
i++;
}
else if( EQUAL(argv[i],"-txe") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
dfXMin = atof(argv[++i]);
dfXMax = atof(argv[++i]);
bIsXExtentSet = TRUE;
}
else if( EQUAL(argv[i],"-tye") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
dfYMin = atof(argv[++i]);
dfYMax = atof(argv[++i]);
bIsYExtentSet = TRUE;
}
else if( EQUAL(argv[i],"-outsize") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
nXSize = atoi(argv[++i]);
nYSize = atoi(argv[++i]);
}
else if( EQUAL(argv[i],"-co") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszCreateOptions = CSLAddString( papszCreateOptions, argv[++i] );
}
else if( EQUAL(argv[i],"-zfield") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszBurnAttribute = argv[++i];
}
else if( EQUAL(argv[i],"-z_increase") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
dfIncreaseBurnValue = atof(argv[++i]);
}
else if( EQUAL(argv[i],"-z_multiply") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
dfMultiplyBurnValue = atof(argv[++i]);
}
else if( EQUAL(argv[i],"-where") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszWHERE = argv[++i];
}
else if( EQUAL(argv[i],"-l") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszLayers = CSLAddString( papszLayers, argv[++i] );
}
else if( EQUAL(argv[i],"-sql") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszSQL = argv[++i];
}
else if( EQUAL(argv[i],"-spat") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(4);
OGRLinearRing oRing;
oRing.addPoint( atof(argv[i+1]), atof(argv[i+2]) );
oRing.addPoint( atof(argv[i+1]), atof(argv[i+4]) );
oRing.addPoint( atof(argv[i+3]), atof(argv[i+4]) );
oRing.addPoint( atof(argv[i+3]), atof(argv[i+2]) );
oRing.addPoint( atof(argv[i+1]), atof(argv[i+2]) );
poSpatialFilter = new OGRPolygon();
((OGRPolygon *) poSpatialFilter)->addRing( &oRing );
i += 4;
}
else if ( EQUAL(argv[i],"-clipsrc") )
{
if (i + 1 >= argc)
Usage(CPLSPrintf("%s option requires 1 or 4 arguments", argv[i]));
bClipSrc = TRUE;
errno = 0;
const double unused = strtod( argv[i + 1], NULL ); // XXX: is it a number or not?
if ( errno != 0
&& argv[i + 2] != NULL
&& argv[i + 3] != NULL
&& argv[i + 4] != NULL)
{
OGRLinearRing oRing;
oRing.addPoint( atof(argv[i + 1]), atof(argv[i + 2]) );
oRing.addPoint( atof(argv[i + 1]), atof(argv[i + 4]) );
oRing.addPoint( atof(argv[i + 3]), atof(argv[i + 4]) );
oRing.addPoint( atof(argv[i + 3]), atof(argv[i + 2]) );
oRing.addPoint( atof(argv[i + 1]), atof(argv[i + 2]) );
poClipSrc = new OGRPolygon();
((OGRPolygon *) poClipSrc)->addRing( &oRing );
i += 4;
(void)unused;
}
else if (EQUALN(argv[i + 1], "POLYGON", 7)
|| EQUALN(argv[i + 1], "MULTIPOLYGON", 12))
{
OGRGeometryFactory::createFromWkt(&argv[i + 1], NULL, &poClipSrc);
if ( poClipSrc == NULL )
{
Usage("Invalid geometry. "
"Must be a valid POLYGON or MULTIPOLYGON WKT.");
}
i++;
}
else if (EQUAL(argv[i + 1], "spat_extent") )
{
i++;
}
else
{
pszClipSrcDS = argv[i + 1];
i++;
}
}
else if ( EQUAL(argv[i], "-clipsrcsql") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszClipSrcSQL = argv[i + 1];
i++;
}
else if ( EQUAL(argv[i], "-clipsrclayer") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszClipSrcLayer = argv[i + 1];
i++;
}
else if ( EQUAL(argv[i], "-clipsrcwhere") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszClipSrcWhere = argv[i + 1];
i++;
}
else if( EQUAL(argv[i],"-a_srs") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
OGRSpatialReference oOutputSRS;
if( oOutputSRS.SetFromUserInput( argv[i+1] ) != OGRERR_NONE )
{
fprintf( stderr, "Failed to process SRS definition: %s\n",
argv[i+1] );
GDALDestroyDriverManager();
exit( 1 );
}
oOutputSRS.exportToWkt( &pszOutputSRS );
i++;
}
else if( EQUAL(argv[i],"-a") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
if ( ParseAlgorithmAndOptions( argv[++i], &eAlgorithm, &pOptions )
!= CE_None )
{
fprintf( stderr,
"Failed to process algorithm name and parameters.\n" );
exit( 1 );
}
}
else if( argv[i][0] == '-' )
{
Usage(CPLSPrintf("Unknown option name '%s'", argv[i]));
}
else if( pszSource == NULL )
{
pszSource = argv[i];
}
else if( pszDest == NULL )
{
pszDest = argv[i];
}
else
{
Usage("Too many command options.");
}
}
if( pszSource == NULL )
{
Usage("Source datasource is not specified.");
}
if( pszDest == NULL )
{
Usage("Target dataset is not specified.");
}
if( pszSQL == NULL && papszLayers == NULL )
{
Usage("Neither -sql nor -l are specified.");
}
if ( bClipSrc && pszClipSrcDS != NULL )
{
poClipSrc = LoadGeometry( pszClipSrcDS, pszClipSrcSQL,
pszClipSrcLayer, pszClipSrcWhere );
if ( poClipSrc == NULL )
{
Usage("Cannot load source clip geometry.");
}
}
else if ( bClipSrc && poClipSrc == NULL && !poSpatialFilter )
{
Usage("-clipsrc must be used with -spat option or \n"
"a bounding box, WKT string or datasource must be "
"specified.");
}
if ( poSpatialFilter )
{
if ( poClipSrc )
{
OGRGeometry *poTemp = poSpatialFilter->Intersection( poClipSrc );
if ( poTemp )
{
OGRGeometryFactory::destroyGeometry( poSpatialFilter );
poSpatialFilter = poTemp;
}
OGRGeometryFactory::destroyGeometry( poClipSrc );
poClipSrc = NULL;
}
}
else
{
if ( poClipSrc )
{
poSpatialFilter = poClipSrc;
poClipSrc = NULL;
}
}
/* -------------------------------------------------------------------- */
/* Find the output driver. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDriverByName( pszFormat );
if( hDriver == NULL )
{
int iDr;
fprintf( stderr,
"FAILURE: Output driver `%s' not recognised.\n", pszFormat );
fprintf( stderr,
"The following format drivers are configured and support output:\n" );
for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ )
{
GDALDriverH hDriver = GDALGetDriver(iDr);
if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) != NULL
|| GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATECOPY,
NULL ) != NULL )
{
fprintf( stderr, " %s: %s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
}
}
printf( "\n" );
Usage();
}
/* -------------------------------------------------------------------- */
/* Open input datasource. */
/* -------------------------------------------------------------------- */
OGRDataSourceH hSrcDS;
hSrcDS = OGROpen( pszSource, FALSE, NULL );
if( hSrcDS == NULL )
{
fprintf( stderr, "Unable to open input datasource \"%s\".\n",
pszSource );
fprintf( stderr, "%s\n", CPLGetLastErrorMsg() );
exit( 3 );
}
/* -------------------------------------------------------------------- */
/* Create target raster file. */
/* -------------------------------------------------------------------- */
GDALDatasetH hDstDS;
int nLayerCount = CSLCount(papszLayers);
int nBands = nLayerCount;
if ( pszSQL )
nBands++;
// FIXME
if ( nXSize == 0 )
nXSize = 256;
if ( nYSize == 0 )
nYSize = 256;
if (!bQuiet && !bFormatExplicitelySet)
CheckExtensionConsistency(pszDest, pszFormat);
hDstDS = GDALCreate( hDriver, pszDest, nXSize, nYSize, nBands,
eOutputType, papszCreateOptions );
if ( hDstDS == NULL )
{
fprintf( stderr, "Unable to create target dataset \"%s\".\n",
pszDest );
fprintf( stderr, "%s\n", CPLGetLastErrorMsg() );
exit( 3 );
}
/* -------------------------------------------------------------------- */
/* If algorithm was not specified assigh default one. */
/* -------------------------------------------------------------------- */
if ( !pOptions )
ParseAlgorithmAndOptions( szAlgNameInvDist, &eAlgorithm, &pOptions );
/* -------------------------------------------------------------------- */
/* Process SQL request. */
/* -------------------------------------------------------------------- */
if( pszSQL != NULL )
{
OGRLayerH hLayer;
hLayer = OGR_DS_ExecuteSQL( hSrcDS, pszSQL,
(OGRGeometryH)poSpatialFilter, NULL );
if( hLayer != NULL )
{
// Custom layer will be rasterized in the first band.
ProcessLayer( hLayer, hDstDS, poSpatialFilter, nXSize, nYSize, 1,
bIsXExtentSet, bIsYExtentSet,
dfXMin, dfXMax, dfYMin, dfYMax, pszBurnAttribute,
dfIncreaseBurnValue, dfMultiplyBurnValue, eOutputType, eAlgorithm, pOptions,
bQuiet, pfnProgress );
}
}
/* -------------------------------------------------------------------- */
/* Process each layer. */
/* -------------------------------------------------------------------- */
for( i = 0; i < nLayerCount; i++ )
{
OGRLayerH hLayer = OGR_DS_GetLayerByName( hSrcDS, papszLayers[i]);
if( hLayer == NULL )
{
fprintf( stderr, "Unable to find layer \"%s\", skipping.\n",
papszLayers[i] );
continue;
}
if( pszWHERE )
{
if( OGR_L_SetAttributeFilter( hLayer, pszWHERE ) != OGRERR_NONE )
break;
}
if ( poSpatialFilter != NULL )
OGR_L_SetSpatialFilter( hLayer, (OGRGeometryH)poSpatialFilter );
// Fetch the first meaningful SRS definition
if ( !pszOutputSRS )
{
OGRSpatialReferenceH hSRS = OGR_L_GetSpatialRef( hLayer );
if ( hSRS )
OSRExportToWkt( hSRS, &pszOutputSRS );
}
ProcessLayer( hLayer, hDstDS, poSpatialFilter, nXSize, nYSize,
i + 1 + nBands - nLayerCount,
bIsXExtentSet, bIsYExtentSet,
dfXMin, dfXMax, dfYMin, dfYMax, pszBurnAttribute,
dfIncreaseBurnValue, dfMultiplyBurnValue, eOutputType, eAlgorithm, pOptions,
bQuiet, pfnProgress );
}
/* -------------------------------------------------------------------- */
/* Apply geotransformation matrix. */
/* -------------------------------------------------------------------- */
double adfGeoTransform[6];
adfGeoTransform[0] = dfXMin;
adfGeoTransform[1] = (dfXMax - dfXMin) / nXSize;
adfGeoTransform[2] = 0.0;
adfGeoTransform[3] = dfYMin;
adfGeoTransform[4] = 0.0;
adfGeoTransform[5] = (dfYMax - dfYMin) / nYSize;
GDALSetGeoTransform( hDstDS, adfGeoTransform );
/* -------------------------------------------------------------------- */
/* Apply SRS definition if set. */
/* -------------------------------------------------------------------- */
if ( pszOutputSRS )
{
GDALSetProjection( hDstDS, pszOutputSRS );
CPLFree( pszOutputSRS );
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
OGR_DS_Destroy( hSrcDS );
GDALClose( hDstDS );
OGRGeometryFactory::destroyGeometry( poSpatialFilter );
CPLFree( pOptions );
CSLDestroy( papszCreateOptions );
CSLDestroy( argv );
CSLDestroy( papszLayers );
OGRCleanupAll();
GDALDestroyDriverManager();
return 0;
}
int main(int argc, char** argv)
{
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
exit(1);
EarlySetConfigOptions(argc, argv);
/* -------------------------------------------------------------------- */
/* Generic arg processing. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
for( int i = 0; 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"));
CSLDestroy( argv );
return 0;
}
else if( EQUAL(argv[i],"--help") )
{
Usage();
}
}
GDALRasterizeOptionsForBinary* psOptionsForBinary = GDALRasterizeOptionsForBinaryNew();
GDALRasterizeOptions *psOptions = GDALRasterizeOptionsNew(argv + 1, psOptionsForBinary);
CSLDestroy( argv );
if( psOptions == NULL )
{
Usage();
}
if( !(psOptionsForBinary->bQuiet) )
{
GDALRasterizeOptionsSetProgress(psOptions, GDALTermProgress, NULL);
}
if( psOptionsForBinary->pszSource == NULL )
Usage("No input file specified.");
if( psOptionsForBinary->pszDest == NULL )
Usage("No output file specified.");
/* -------------------------------------------------------------------- */
/* Open input file. */
/* -------------------------------------------------------------------- */
GDALDatasetH hInDS = GDALOpenEx( psOptionsForBinary->pszSource, GDAL_OF_VECTOR | GDAL_OF_VERBOSE_ERROR,
NULL, NULL, NULL );
if( hInDS == NULL )
exit( 1 );
/* -------------------------------------------------------------------- */
/* Open output file if it exists. */
/* -------------------------------------------------------------------- */
GDALDatasetH hDstDS = NULL;
if( !(psOptionsForBinary->bCreateOutput) )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
hDstDS = GDALOpenEx( psOptionsForBinary->pszDest, GDAL_OF_RASTER | GDAL_OF_VERBOSE_ERROR | GDAL_OF_UPDATE,
NULL, NULL, NULL );
CPLPopErrorHandler();
}
if (hDstDS == NULL && !psOptionsForBinary->bQuiet && !psOptionsForBinary->bFormatExplicitlySet)
CheckExtensionConsistency(psOptionsForBinary->pszDest, psOptionsForBinary->pszFormat);
int bUsageError = FALSE;
GDALDatasetH hRetDS = GDALRasterize(psOptionsForBinary->pszDest,
hDstDS,
hInDS,
psOptions, &bUsageError);
if(bUsageError == TRUE)
Usage();
int nRetCode = (hRetDS) ? 0 : 1;
GDALClose(hInDS);
GDALClose(hRetDS);
GDALRasterizeOptionsFree(psOptions);
GDALRasterizeOptionsForBinaryFree(psOptionsForBinary);
GDALDestroyDriverManager();
return nRetCode;
}
int main( int argc, char ** argv )
{
/* Check that we are running against at least GDAL 1.4 (probably older in fact !) */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1400)
{
fprintf(stderr, "At least, GDAL >= 1.4.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
exit(1);
}
/* -------------------------------------------------------------------- */
/* Generic arg processing. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
GDALSetCacheMax( 100000000 );
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
int i;
const char *pszOutFile = NULL;
const char *pszInFile = NULL;
int nMaxNonBlack = 2;
int nNearDist = 15;
int bNearWhite = FALSE;
int bSetAlpha = FALSE;
int bSetMask = FALSE;
const char* pszDriverName = "HFA";
int bFormatExplicitelySet = FALSE;
char** papszCreationOptions = NULL;
int bQuiet = FALSE;
Colors oColors;
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], "-o") && i < argc-1 )
pszOutFile = argv[++i];
else if( EQUAL(argv[i], "-of") && i < argc-1 )
{
pszDriverName = argv[++i];
bFormatExplicitelySet = TRUE;
}
else if( EQUAL(argv[i], "-white") ) {
bNearWhite = TRUE;
}
/***** -color c1,c2,c3...cn *****/
else if( EQUAL(argv[i], "-color") && i < argc-1 ) {
Color oColor;
/***** tokenize the arg on , *****/
char **papszTokens;
papszTokens = CSLTokenizeString2( argv[++i], ",", 0 );
/***** loop over the tokens *****/
int iToken;
for( iToken = 0; papszTokens && papszTokens[iToken]; iToken++ )
{
/***** ensure the token is an int and add it to the color *****/
if ( IsInt( papszTokens[iToken] ) )
oColor.push_back( atoi( papszTokens[iToken] ) );
else {
CPLError(CE_Failure, CPLE_AppDefined,
"Colors must be valid integers." );
CSLDestroy( papszTokens );
exit(1);
}
}
CSLDestroy( papszTokens );
/***** check if the number of bands is consistant *****/
if ( oColors.size() > 0 &&
oColors.front().size() != oColor.size() )
{
CPLError(CE_Failure, CPLE_AppDefined,
"ERROR: all -color args must have the same number of values.\n" );
exit(1);
}
/***** add the color to the colors *****/
oColors.push_back( oColor );
}
else if( EQUAL(argv[i], "-nb") && i < argc-1 )
nMaxNonBlack = atoi(argv[++i]);
else if( EQUAL(argv[i], "-near") && i < argc-1 )
nNearDist = atoi(argv[++i]);
else if( EQUAL(argv[i], "-setalpha") )
bSetAlpha = TRUE;
else if( EQUAL(argv[i], "-setmask") )
bSetMask = TRUE;
else if( EQUAL(argv[i], "-q") || EQUAL(argv[i], "-quiet") )
bQuiet = TRUE;
else if( EQUAL(argv[i], "-co") && i < argc-1 )
papszCreationOptions = CSLAddString(papszCreationOptions, argv[++i]);
else if( argv[i][0] == '-' )
Usage();
else if( pszInFile == NULL )
pszInFile = argv[i];
else
Usage();
}
if( pszInFile == NULL )
Usage();
if( pszOutFile == NULL )
pszOutFile = pszInFile;
/* -------------------------------------------------------------------- */
/* Open input file. */
/* -------------------------------------------------------------------- */
GDALDatasetH hInDS, hOutDS = NULL;
int nXSize, nYSize, nBands;
if( pszOutFile == pszInFile )
hInDS = hOutDS = GDALOpen( pszInFile, GA_Update );
else
hInDS = GDALOpen( pszInFile, GA_ReadOnly );
if( hInDS == NULL )
exit( 1 );
nXSize = GDALGetRasterXSize( hInDS );
nYSize = GDALGetRasterYSize( hInDS );
nBands = GDALGetRasterCount( hInDS );
int nDstBands = nBands;
if( hOutDS != NULL && papszCreationOptions != NULL)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Warning: creation options are ignored when writing to an existing file.");
}
/* -------------------------------------------------------------------- */
/* Do we need to create output file? */
/* -------------------------------------------------------------------- */
if( hOutDS == NULL )
{
GDALDriverH hDriver = GDALGetDriverByName( pszDriverName );
if (hDriver == NULL)
exit(1);
if (!bQuiet && !bFormatExplicitelySet)
CheckExtensionConsistency(pszOutFile, pszDriverName);
if (bSetAlpha)
{
/***** fixme there should be a way to preserve alpha band data not in the collar *****/
if (nBands == 4)
nBands --;
else
nDstBands ++;
}
if (bSetMask)
{
if (nBands == 4)
nDstBands = nBands = 3;
}
hOutDS = GDALCreate( hDriver, pszOutFile,
nXSize, nYSize, nDstBands, GDT_Byte,
papszCreationOptions );
if( hOutDS == NULL )
exit( 1 );
double adfGeoTransform[6];
if( GDALGetGeoTransform( hInDS, adfGeoTransform ) == CE_None )
{
GDALSetGeoTransform( hOutDS, adfGeoTransform );
GDALSetProjection( hOutDS, GDALGetProjectionRef( hInDS ) );
}
}
else
{
if (bSetAlpha)
{
if (nBands != 4 &&
(nBands < 2 ||
GDALGetRasterColorInterpretation(GDALGetRasterBand(hOutDS, nBands)) != GCI_AlphaBand))
{
CPLError(CE_Failure, CPLE_AppDefined,
"Last band is not an alpha band.");
exit(1);
}
nBands --;
}
if (bSetMask)
{
if (nBands == 4)
nDstBands = nBands = 3;
}
}
/***** set a color if there are no colors set? *****/
if ( oColors.size() == 0) {
Color oColor;
/***** loop over the bands to get the right number of values *****/
int iBand;
for (iBand = 0; iBand < nBands ; iBand++) {
/***** black or white? *****/
if (bNearWhite)
oColor.push_back(255);
else
oColor.push_back(0);
}
/***** add the color to the colors *****/
oColors.push_back(oColor);
}
/***** does the number of bands match the number of color values? *****/
if ( (int)oColors.front().size() != nBands ) {
CPLError( CE_Failure, CPLE_AppDefined,
"-color args must have the same number of values as the non alpha input band count.\n" );
exit(1);
}
/***** check the input and output datasets are the same size *****/
if (GDALGetRasterXSize(hOutDS) != nXSize ||
GDALGetRasterYSize(hOutDS) != nYSize)
{
CPLError(CE_Failure, CPLE_AppDefined,
"The dimensions of the output dataset don't match "
"the dimensions of the input dataset.");
exit(1);
}
int iBand;
for( iBand = 0; iBand < nBands; iBand++ )
{
GDALRasterBandH hBand = GDALGetRasterBand(hInDS, iBand+1);
if (GDALGetRasterDataType(hBand) != GDT_Byte)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Band %d is not of type GDT_Byte. It can lead to unexpected results.", iBand+1);
}
if (GDALGetRasterColorTable(hBand) != NULL)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Band %d has a color table, which is ignored by nearblack. "
"It can lead to unexpected results.", iBand+1);
}
}
GDALRasterBandH hMaskBand = NULL;
if (bSetMask) {
/***** if there isn't already a mask band on the output file create one *****/
if ( GMF_PER_DATASET != GDALGetMaskFlags( GDALGetRasterBand(hOutDS, 1) ) )
{
if ( CE_None != GDALCreateDatasetMaskBand(hOutDS, GMF_PER_DATASET) ) {
CPLError(CE_Failure, CPLE_AppDefined,
"Failed to create mask band on output DS");
bSetMask = FALSE;
}
}
if (bSetMask) {
hMaskBand = GDALGetMaskBand(GDALGetRasterBand(hOutDS, 1));
}
}
/* -------------------------------------------------------------------- */
/* Allocate a line buffer. */
/* -------------------------------------------------------------------- */
GByte *pabyLine;
GByte *pabyMask=NULL;
int *panLastLineCounts;
pabyLine = (GByte *) CPLMalloc(nXSize * nDstBands);
if (bSetMask)
pabyMask = (GByte *) CPLMalloc(nXSize);
panLastLineCounts = (int *) CPLCalloc(sizeof(int),nXSize);
/* -------------------------------------------------------------------- */
/* Processing data one line at a time. */
/* -------------------------------------------------------------------- */
int iLine;
for( iLine = 0; iLine < nYSize; iLine++ )
{
CPLErr eErr;
eErr = GDALDatasetRasterIO( hInDS, GF_Read, 0, iLine, nXSize, 1,
pabyLine, nXSize, 1, GDT_Byte,
nBands, NULL, nDstBands, nXSize * nDstBands, 1 );
if( eErr != CE_None )
break;
if (bSetAlpha)
{
int iCol;
for(iCol = 0; iCol < nXSize; iCol ++)
{
pabyLine[iCol * nDstBands + nDstBands - 1] = 255;
}
}
if (bSetMask)
{
int iCol;
for(iCol = 0; iCol < nXSize; iCol ++)
{
pabyMask[iCol] = 255;
}
}
ProcessLine( pabyLine, pabyMask, 0, nXSize-1, nBands, nDstBands,
nNearDist, nMaxNonBlack, bNearWhite, &oColors,
panLastLineCounts,
TRUE, // bDoHorizontalCheck
TRUE, // bDoVerticalCheck
FALSE // bBottomUp
);
ProcessLine( pabyLine, pabyMask, nXSize-1, 0, nBands, nDstBands,
nNearDist, nMaxNonBlack, bNearWhite, &oColors,
panLastLineCounts,
TRUE, // bDoHorizontalCheck
FALSE, // bDoVerticalCheck
FALSE // bBottomUp
);
eErr = GDALDatasetRasterIO( hOutDS, GF_Write, 0, iLine, nXSize, 1,
pabyLine, nXSize, 1, GDT_Byte,
nDstBands, NULL, nDstBands, nXSize * nDstBands, 1 );
if( eErr != CE_None )
break;
/***** write out the mask band line *****/
if (bSetMask) {
eErr = GDALRasterIO ( hMaskBand, GF_Write, 0, iLine, nXSize, 1,
pabyMask, nXSize, 1, GDT_Byte,
0, 0 );
if( eErr != CE_None ) {
CPLError(CE_Warning, CPLE_AppDefined,
"ERROR writeing out line to mask band.");
break;
}
}
if (!bQuiet)
GDALTermProgress( 0.5 * ((iLine+1) / (double) nYSize), NULL, NULL );
}
/* -------------------------------------------------------------------- */
/* Now process from the bottom back up .*/
/* -------------------------------------------------------------------- */
memset( panLastLineCounts, 0, sizeof(int) * nXSize);
for( iLine = nYSize-1; iLine >= 0; iLine-- )
{
CPLErr eErr;
eErr = GDALDatasetRasterIO( hOutDS, GF_Read, 0, iLine, nXSize, 1,
pabyLine, nXSize, 1, GDT_Byte,
nDstBands, NULL, nDstBands, nXSize * nDstBands, 1 );
if( eErr != CE_None )
break;
/***** read the mask band line back in *****/
if (bSetMask) {
eErr = GDALRasterIO ( hMaskBand, GF_Read, 0, iLine, nXSize, 1,
pabyMask, nXSize, 1, GDT_Byte,
0, 0 );
if( eErr != CE_None )
break;
}
ProcessLine( pabyLine, pabyMask, 0, nXSize-1, nBands, nDstBands,
nNearDist, nMaxNonBlack, bNearWhite, &oColors,
panLastLineCounts,
TRUE, // bDoHorizontalCheck
TRUE, // bDoVerticalCheck
TRUE // bBottomUp
);
ProcessLine( pabyLine, pabyMask, nXSize-1, 0, nBands, nDstBands,
nNearDist, nMaxNonBlack, bNearWhite, &oColors,
panLastLineCounts,
TRUE, // bDoHorizontalCheck
FALSE, // bDoVerticalCheck
TRUE // bBottomUp
);
eErr = GDALDatasetRasterIO( hOutDS, GF_Write, 0, iLine, nXSize, 1,
pabyLine, nXSize, 1, GDT_Byte,
nDstBands, NULL, nDstBands, nXSize * nDstBands, 1 );
if( eErr != CE_None )
break;
/***** write out the mask band line *****/
if (bSetMask) {
eErr = GDALRasterIO ( hMaskBand, GF_Write, 0, iLine, nXSize, 1,
pabyMask, nXSize, 1, GDT_Byte,
0, 0 );
if( eErr != CE_None )
break;
}
if (!bQuiet)
GDALTermProgress( 0.5 + 0.5 * (nYSize-iLine) / (double) nYSize,
NULL, NULL );
}
CPLFree(pabyLine);
if (bSetMask)
CPLFree(pabyMask);
CPLFree( panLastLineCounts );
GDALClose( hOutDS );
if( hInDS != hOutDS )
GDALClose( hInDS );
GDALDumpOpenDatasets( stderr );
CSLDestroy( argv );
CSLDestroy( papszCreationOptions );
GDALDestroyDriverManager();
return 0;
}
int main( int argc, char ** argv )
{
int i, b3D = FALSE;
int bInverse = FALSE;
const char *pszSrcFilename = NULL;
const char *pszDstFilename = NULL;
char **papszLayers = NULL;
const char *pszSQL = NULL;
const char *pszBurnAttribute = NULL;
const char *pszWHERE = NULL;
std::vector<int> anBandList;
std::vector<double> adfBurnValues;
char **papszRasterizeOptions = NULL;
double dfXRes = 0, dfYRes = 0;
int bCreateOutput = FALSE;
const char* pszFormat = "GTiff";
int bFormatExplicitelySet = FALSE;
char **papszCreateOptions = NULL;
GDALDriverH hDriver = NULL;
GDALDataType eOutputType = GDT_Float64;
std::vector<double> adfInitVals;
int bNoDataSet = FALSE;
double dfNoData = 0;
OGREnvelope sEnvelop;
int bGotBounds = FALSE;
int nXSize = 0, nYSize = 0;
int bQuiet = FALSE;
GDALProgressFunc pfnProgress = GDALTermProgress;
OGRSpatialReferenceH hSRS = NULL;
int bTargetAlignedPixels = FALSE;
/* Check that we are running against at least GDAL 1.4 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1400)
{
fprintf(stderr, "At least, GDAL >= 1.4.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
OGRRegisterAll();
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],"-q") || EQUAL(argv[i],"-quiet") )
{
bQuiet = TRUE;
pfnProgress = GDALDummyProgress;
}
else if( EQUAL(argv[i],"-a") && i < argc-1 )
{
pszBurnAttribute = argv[++i];
}
else if( EQUAL(argv[i],"-b") && i < argc-1 )
{
if (strchr(argv[i+1], ' '))
{
char** papszTokens = CSLTokenizeString( argv[i+1] );
char** papszIter = papszTokens;
while(papszIter && *papszIter)
{
anBandList.push_back(atoi(*papszIter));
papszIter ++;
}
CSLDestroy(papszTokens);
i += 1;
}
else
{
while(i < argc-1 && ArgIsNumeric(argv[i+1]))
{
anBandList.push_back(atoi(argv[i+1]));
i += 1;
}
}
}
else if( EQUAL(argv[i],"-3d") )
{
b3D = TRUE;
papszRasterizeOptions =
CSLSetNameValue( papszRasterizeOptions, "BURN_VALUE_FROM", "Z");
}
else if( EQUAL(argv[i],"-i") )
{
bInverse = TRUE;
}
else if( EQUAL(argv[i],"-at") )
{
papszRasterizeOptions =
CSLSetNameValue( papszRasterizeOptions, "ALL_TOUCHED", "TRUE" );
}
else if( EQUAL(argv[i],"-burn") && i < argc-1 )
{
if (strchr(argv[i+1], ' '))
{
char** papszTokens = CSLTokenizeString( argv[i+1] );
char** papszIter = papszTokens;
while(papszIter && *papszIter)
{
adfBurnValues.push_back(atof(*papszIter));
papszIter ++;
}
CSLDestroy(papszTokens);
i += 1;
}
else
{
while(i < argc-1 && ArgIsNumeric(argv[i+1]))
{
adfBurnValues.push_back(atof(argv[i+1]));
i += 1;
}
}
}
else if( EQUAL(argv[i],"-where") && i < argc-1 )
{
pszWHERE = argv[++i];
}
else if( EQUAL(argv[i],"-l") && i < argc-1 )
{
papszLayers = CSLAddString( papszLayers, argv[++i] );
}
else if( EQUAL(argv[i],"-sql") && i < argc-1 )
{
pszSQL = argv[++i];
}
else if( EQUAL(argv[i],"-of") && i < argc-1 )
{
pszFormat = argv[++i];
bFormatExplicitelySet = TRUE;
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-init") && i < argc - 1 )
{
if (strchr(argv[i+1], ' '))
{
char** papszTokens = CSLTokenizeString( argv[i+1] );
char** papszIter = papszTokens;
while(papszIter && *papszIter)
{
adfInitVals.push_back(atof(*papszIter));
papszIter ++;
}
CSLDestroy(papszTokens);
i += 1;
}
else
{
while(i < argc-1 && ArgIsNumeric(argv[i+1]))
{
adfInitVals.push_back(atof(argv[i+1]));
i += 1;
}
}
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-a_nodata") && i < argc - 1 )
{
dfNoData = atof(argv[i+1]);
bNoDataSet = TRUE;
i += 1;
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-a_srs") && i < argc-1 )
{
hSRS = OSRNewSpatialReference( NULL );
if( OSRSetFromUserInput(hSRS, argv[i+1]) != OGRERR_NONE )
{
fprintf( stderr, "Failed to process SRS definition: %s\n",
argv[i+1] );
exit( 1 );
}
i++;
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-te") && i < argc - 4 )
{
sEnvelop.MinX = atof(argv[++i]);
sEnvelop.MinY = atof(argv[++i]);
sEnvelop.MaxX = atof(argv[++i]);
sEnvelop.MaxY = atof(argv[++i]);
bGotBounds = TRUE;
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-a_ullr") && i < argc - 4 )
{
sEnvelop.MinX = atof(argv[++i]);
sEnvelop.MaxY = atof(argv[++i]);
sEnvelop.MaxX = atof(argv[++i]);
sEnvelop.MinY = atof(argv[++i]);
bGotBounds = TRUE;
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-co") && i < argc-1 )
{
papszCreateOptions = CSLAddString( papszCreateOptions, argv[++i] );
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-ot") && i < argc-1 )
{
int iType;
for( iType = 1; iType < GDT_TypeCount; iType++ )
{
if( GDALGetDataTypeName((GDALDataType)iType) != NULL
&& EQUAL(GDALGetDataTypeName((GDALDataType)iType),
argv[i+1]) )
{
eOutputType = (GDALDataType) iType;
}
}
if( eOutputType == GDT_Unknown )
{
printf( "Unknown output pixel type: %s\n", argv[i+1] );
Usage();
}
i++;
bCreateOutput = TRUE;
}
else if( (EQUAL(argv[i],"-ts") || EQUAL(argv[i],"-outsize")) && i < argc-2 )
{
nXSize = atoi(argv[++i]);
nYSize = atoi(argv[++i]);
if (nXSize <= 0 || nYSize <= 0)
{
printf( "Wrong value for -outsize parameters\n");
Usage();
}
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-tr") && i < argc-2 )
{
dfXRes = atof(argv[++i]);
dfYRes = fabs(atof(argv[++i]));
if( dfXRes == 0 || dfYRes == 0 )
{
printf( "Wrong value for -tr parameters\n");
Usage();
}
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-tap") )
{
bTargetAlignedPixels = TRUE;
bCreateOutput = TRUE;
}
else if( pszSrcFilename == NULL )
{
pszSrcFilename = argv[i];
}
else if( pszDstFilename == NULL )
{
pszDstFilename = argv[i];
}
else
Usage();
}
if( pszSrcFilename == NULL || pszDstFilename == NULL )
{
fprintf( stderr, "Missing source or destination.\n\n" );
Usage();
}
if( adfBurnValues.size() == 0 && pszBurnAttribute == NULL && !b3D )
{
fprintf( stderr, "At least one of -3d, -burn or -a required.\n\n" );
Usage();
}
if( bCreateOutput )
{
if( dfXRes == 0 && dfYRes == 0 && nXSize == 0 && nYSize == 0 )
{
fprintf( stderr, "'-tr xres yes' or '-ts xsize ysize' is required.\n\n" );
Usage();
}
if (bTargetAlignedPixels && dfXRes == 0 && dfYRes == 0)
{
fprintf( stderr, "-tap option cannot be used without using -tr\n");
Usage();
}
if( anBandList.size() != 0 )
{
fprintf( stderr, "-b option cannot be used when creating a GDAL dataset.\n\n" );
Usage();
}
int nBandCount = 1;
if (adfBurnValues.size() != 0)
nBandCount = adfBurnValues.size();
if ((int)adfInitVals.size() > nBandCount)
nBandCount = adfInitVals.size();
if (adfInitVals.size() == 1)
{
for(i=1;i<=nBandCount - 1;i++)
adfInitVals.push_back( adfInitVals[0] );
}
int i;
for(i=1;i<=nBandCount;i++)
anBandList.push_back( i );
}
else
{
if( anBandList.size() == 0 )
anBandList.push_back( 1 );
}
/* -------------------------------------------------------------------- */
/* Open source vector dataset. */
/* -------------------------------------------------------------------- */
OGRDataSourceH hSrcDS;
hSrcDS = OGROpen( pszSrcFilename, FALSE, NULL );
if( hSrcDS == NULL )
{
fprintf( stderr, "Failed to open feature source: %s\n",
pszSrcFilename);
exit( 1 );
}
if( pszSQL == NULL && papszLayers == NULL )
{
if( OGR_DS_GetLayerCount(hSrcDS) == 1 )
{
papszLayers = CSLAddString(NULL, OGR_L_GetName(OGR_DS_GetLayer(hSrcDS, 0)));
}
else
{
fprintf( stderr, "At least one of -l or -sql required.\n\n" );
Usage();
}
}
/* -------------------------------------------------------------------- */
/* Open target raster file. Eventually we will add optional */
/* creation. */
/* -------------------------------------------------------------------- */
GDALDatasetH hDstDS = NULL;
if (bCreateOutput)
{
/* -------------------------------------------------------------------- */
/* Find the output driver. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDriverByName( pszFormat );
if( hDriver == NULL
|| GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) == NULL )
{
int iDr;
printf( "Output driver `%s' not recognised or does not support\n",
pszFormat );
printf( "direct output file creation. The following format drivers are configured\n"
"and support direct output:\n" );
for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ )
{
GDALDriverH hDriver = GDALGetDriver(iDr);
if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL) != NULL )
{
printf( " %s: %s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
}
}
printf( "\n" );
exit( 1 );
}
if (!bQuiet && !bFormatExplicitelySet)
CheckExtensionConsistency(pszDstFilename, pszFormat);
}
else
{
hDstDS = GDALOpen( pszDstFilename, GA_Update );
if( hDstDS == NULL )
exit( 2 );
}
/* -------------------------------------------------------------------- */
/* Process SQL request. */
/* -------------------------------------------------------------------- */
if( pszSQL != NULL )
{
OGRLayerH hLayer;
hLayer = OGR_DS_ExecuteSQL( hSrcDS, pszSQL, NULL, NULL );
if( hLayer != NULL )
{
if (bCreateOutput)
{
std::vector<OGRLayerH> ahLayers;
ahLayers.push_back(hLayer);
hDstDS = CreateOutputDataset(ahLayers, hSRS,
bGotBounds, sEnvelop,
hDriver, pszDstFilename,
nXSize, nYSize, dfXRes, dfYRes,
bTargetAlignedPixels,
anBandList.size(), eOutputType,
papszCreateOptions, adfInitVals,
bNoDataSet, dfNoData);
}
ProcessLayer( hLayer, hSRS != NULL, hDstDS, anBandList,
adfBurnValues, b3D, bInverse, pszBurnAttribute,
papszRasterizeOptions, pfnProgress, NULL );
OGR_DS_ReleaseResultSet( hSrcDS, hLayer );
}
}
/* -------------------------------------------------------------------- */
/* Create output file if necessary. */
/* -------------------------------------------------------------------- */
int nLayerCount = CSLCount(papszLayers);
if (bCreateOutput && hDstDS == NULL)
{
std::vector<OGRLayerH> ahLayers;
for( i = 0; i < nLayerCount; i++ )
{
OGRLayerH hLayer = OGR_DS_GetLayerByName( hSrcDS, papszLayers[i] );
if( hLayer == NULL )
{
continue;
}
ahLayers.push_back(hLayer);
}
hDstDS = CreateOutputDataset(ahLayers, hSRS,
bGotBounds, sEnvelop,
hDriver, pszDstFilename,
nXSize, nYSize, dfXRes, dfYRes,
bTargetAlignedPixels,
anBandList.size(), eOutputType,
papszCreateOptions, adfInitVals,
bNoDataSet, dfNoData);
}
/* -------------------------------------------------------------------- */
/* Process each layer. */
/* -------------------------------------------------------------------- */
for( i = 0; i < nLayerCount; i++ )
{
OGRLayerH hLayer = OGR_DS_GetLayerByName( hSrcDS, papszLayers[i] );
if( hLayer == NULL )
{
fprintf( stderr, "Unable to find layer %s, skipping.\n",
papszLayers[i] );
continue;
}
if( pszWHERE )
{
if( OGR_L_SetAttributeFilter( hLayer, pszWHERE ) != OGRERR_NONE )
break;
}
void *pScaledProgress;
pScaledProgress =
GDALCreateScaledProgress( 0.0, 1.0 * (i + 1) / nLayerCount,
pfnProgress, NULL );
ProcessLayer( hLayer, hSRS != NULL, hDstDS, anBandList,
adfBurnValues, b3D, bInverse, pszBurnAttribute,
papszRasterizeOptions, GDALScaledProgress, pScaledProgress );
GDALDestroyScaledProgress( pScaledProgress );
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
OGR_DS_Destroy( hSrcDS );
GDALClose( hDstDS );
OSRDestroySpatialReference(hSRS);
CSLDestroy( argv );
CSLDestroy( papszRasterizeOptions );
CSLDestroy( papszLayers );
CSLDestroy( papszCreateOptions );
GDALDestroyDriverManager();
OGRCleanupAll();
return 0;
}
int main( int argc, char ** argv )
{
GDALDatasetH *pahSrcDS = NULL;
int nSrcCount = 0;
int i;
/* Check that we are running against at least GDAL 1.6 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1600)
{
fprintf(stderr, "At least, GDAL >= 1.6.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
GDALExit(1);
}
EarlySetConfigOptions(argc, argv);
/* -------------------------------------------------------------------- */
/* Register standard GDAL drivers, and process generic GDAL */
/* command options. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
GDALExit( -argc );
for( int i = 0; argv != NULL && argv[i] != NULL; 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"));
CSLDestroy( argv );
return 0;
}
else if( EQUAL(argv[i],"--help") )
{
Usage(NULL);
}
}
/* -------------------------------------------------------------------- */
/* Set optimal setting for best performance with huge input VRT. */
/* The rationale for 450 is that typical Linux process allow */
/* only 1024 file descriptors per process and we need to keep some */
/* spare for shared libraries, etc. so let's go down to 900. */
/* And some datasets may need 2 file descriptors, so divide by 2 */
/* for security. */
/* -------------------------------------------------------------------- */
if( CPLGetConfigOption("GDAL_MAX_DATASET_POOL_SIZE", NULL) == NULL )
{
CPLSetConfigOption("GDAL_MAX_DATASET_POOL_SIZE", "450");
}
GDALWarpAppOptionsForBinary* psOptionsForBinary = GDALWarpAppOptionsForBinaryNew();
GDALWarpAppOptions *psOptions = GDALWarpAppOptionsNew(argv + 1, psOptionsForBinary);
CSLDestroy( argv );
if( psOptions == NULL )
{
Usage(NULL);
}
if( psOptionsForBinary->pszDstFilename == NULL )
{
Usage("No target filename specified.");
}
if ( CSLCount(psOptionsForBinary->papszSrcFiles) == 1 &&
strcmp(psOptionsForBinary->papszSrcFiles[0], psOptionsForBinary->pszDstFilename) == 0 &&
psOptionsForBinary->bOverwrite)
{
CPLError(CE_Failure, CPLE_IllegalArg, "Source and destination datasets must be different.\n");
GDALExit(1);
}
/* -------------------------------------------------------------------- */
/* Open Source files. */
/* -------------------------------------------------------------------- */
for(i = 0; psOptionsForBinary->papszSrcFiles[i] != NULL; i++)
{
nSrcCount++;
pahSrcDS = (GDALDatasetH *) CPLRealloc(pahSrcDS, sizeof(GDALDatasetH) * nSrcCount);
pahSrcDS[nSrcCount-1] = GDALOpenEx( psOptionsForBinary->papszSrcFiles[i], GDAL_OF_RASTER | GDAL_OF_VERBOSE_ERROR, NULL,
(const char* const* )psOptionsForBinary->papszOpenOptions, NULL );
if( pahSrcDS[nSrcCount-1] == NULL )
GDALExit(2);
}
/* -------------------------------------------------------------------- */
/* Does the output dataset already exist? */
/* -------------------------------------------------------------------- */
/* FIXME ? source filename=target filename and -overwrite is definitely */
/* an error. But I can't imagine of a valid case (without -overwrite), */
/* where it would make sense. In doubt, let's keep that dubious possibility... */
int bOutStreaming = FALSE;
if( strcmp(psOptionsForBinary->pszDstFilename, "/vsistdout/") == 0 )
{
psOptionsForBinary->bQuiet = TRUE;
bOutStreaming = TRUE;
}
#ifdef S_ISFIFO
else
{
VSIStatBufL sStat;
if( VSIStatExL(psOptionsForBinary->pszDstFilename, &sStat, VSI_STAT_EXISTS_FLAG | VSI_STAT_NATURE_FLAG) == 0 &&
S_ISFIFO(sStat.st_mode) )
{
bOutStreaming = TRUE;
}
}
#endif
GDALDatasetH hDstDS = NULL;
if( bOutStreaming )
{
GDALWarpAppOptionsSetWarpOption(psOptions, "STREAMABLE_OUTPUT", "YES");
}
else
{
CPLPushErrorHandler( CPLQuietErrorHandler );
hDstDS = GDALOpenEx( psOptionsForBinary->pszDstFilename, GDAL_OF_RASTER | GDAL_OF_VERBOSE_ERROR | GDAL_OF_UPDATE,
NULL, psOptionsForBinary->papszDestOpenOptions, NULL );
CPLPopErrorHandler();
}
if( hDstDS != NULL && psOptionsForBinary->bOverwrite )
{
GDALClose(hDstDS);
hDstDS = NULL;
}
if( hDstDS != NULL && psOptionsForBinary->bCreateOutput )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Output dataset %s exists,\n"
"but some commandline options were provided indicating a new dataset\n"
"should be created. Please delete existing dataset and run again.\n",
psOptionsForBinary->pszDstFilename );
GDALExit(1);
}
/* Avoid overwriting an existing destination file that cannot be opened in */
/* update mode with a new GTiff file */
if ( !bOutStreaming && hDstDS == NULL && !psOptionsForBinary->bOverwrite )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
hDstDS = GDALOpen( psOptionsForBinary->pszDstFilename, GA_ReadOnly );
CPLPopErrorHandler();
if (hDstDS)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Output dataset %s exists, but cannot be opened in update mode\n",
psOptionsForBinary->pszDstFilename );
GDALClose(hDstDS);
GDALExit(1);
}
}
if( !(psOptionsForBinary->bQuiet) )
{
GDALWarpAppOptionsSetProgress(psOptions, GDALTermProgress, NULL);
}
if (hDstDS == NULL && !psOptionsForBinary->bQuiet && !psOptionsForBinary->bFormatExplicitlySet)
CheckExtensionConsistency(psOptionsForBinary->pszDstFilename, psOptionsForBinary->pszFormat);
int bUsageError = FALSE;
GDALDatasetH hOutDS = GDALWarp(psOptionsForBinary->pszDstFilename, hDstDS,
nSrcCount, pahSrcDS, psOptions, &bUsageError);
if( bUsageError )
Usage();
int nRetCode = (hOutDS) ? 0 : 1;
GDALWarpAppOptionsFree(psOptions);
GDALWarpAppOptionsForBinaryFree(psOptionsForBinary);
for(i = 0; i < nSrcCount; i++)
{
GDALClose(pahSrcDS[i]);
}
CPLFree(pahSrcDS);
GDALClose( hOutDS ? hOutDS : hDstDS );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
#ifdef OGR_ENABLED
OGRCleanupAll();
#endif
return nRetCode;
}
int main( int argc, char ** argv )
{
GDALDatasetH hDataset, hOutDS;
int i;
const char *pszSource=NULL, *pszDest=NULL, *pszFormat = "GTiff";
int bFormatExplicitlySet = FALSE;
GDALDriverH hDriver;
GDALDataType eOutputType = GDT_Unknown;
char **papszCreateOptions = NULL;
GDALProgressFunc pfnProgress = GDALTermProgress;
int nLUTBins = 256;
const char *pszMethod = "minmax";
// double dfStdDevMult = 0.0;
double *padfScaleMin = NULL;
double *padfScaleMax = NULL;
int **papanLUTs = NULL;
int iBand;
const char *pszConfigFile = NULL;
int bQuiet = FALSE;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
exit(1);
/* -------------------------------------------------------------------- */
/* Register standard GDAL drivers, and process generic GDAL */
/* command options. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Handle command line 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],"-of") && i < argc-1 )
{
pszFormat = argv[++i];
bFormatExplicitlySet = TRUE;
}
else if( EQUAL(argv[i],"-ot") && i < argc-1 )
{
int iType;
for( iType = 1; iType < GDT_TypeCount; iType++ )
{
if( GDALGetDataTypeName((GDALDataType)iType) != NULL
&& EQUAL(GDALGetDataTypeName((GDALDataType)iType),
argv[i+1]) )
{
eOutputType = (GDALDataType) iType;
}
}
if( eOutputType == GDT_Unknown )
{
printf( "Unknown output pixel type: %s\n", argv[i+1] );
Usage();
}
i++;
}
else if( STARTS_WITH_CI(argv[i], "-s_nodata") )
{
// TODO
i += 1;
}
else if( EQUAL(argv[i],"-co") && i < argc-1 )
{
papszCreateOptions = CSLAddString( papszCreateOptions, argv[++i] );
}
else if( STARTS_WITH_CI(argv[i], "-src_scale") && i < argc-2)
{
// TODO
i += 2;
}
else if( STARTS_WITH_CI(argv[i], "-dst_scale") && i < argc-2 )
{
// TODO
i += 2;
}
else if( EQUAL(argv[i],"-config") && i < argc-1 )
{
pszConfigFile = argv[++i];
}
else if( EQUAL(argv[i],"-equalize") )
{
pszMethod = "equalize";
}
else if( EQUAL(argv[i],"-quiet") )
{
pfnProgress = GDALDummyProgress;
bQuiet = TRUE;
}
else if( argv[i][0] == '-' )
{
printf( "Option %s incomplete, or not recognised.\n\n",
argv[i] );
Usage();
}
else if( pszSource == NULL )
{
pszSource = argv[i];
}
else if( pszDest == NULL )
{
pszDest = argv[i];
}
else
{
printf( "Too many command options.\n\n" );
Usage();
}
}
if( pszSource == NULL )
{
Usage();
}
/* -------------------------------------------------------------------- */
/* Attempt to open source file. */
/* -------------------------------------------------------------------- */
hDataset = GDALOpenShared( pszSource, GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"GDALOpen failed - %d\n%s\n",
CPLGetLastErrorNo(), CPLGetLastErrorMsg() );
GDALDestroyDriverManager();
exit( 1 );
}
int nBandCount = GDALGetRasterCount(hDataset);
/* -------------------------------------------------------------------- */
/* Find the output driver. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDriverByName( pszFormat );
if( hDriver == NULL )
{
int iDr;
printf( "Output driver `%s' not recognised.\n", pszFormat );
printf( "The following format drivers are configured and support output:\n" );
for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ )
{
hDriver = GDALGetDriver(iDr);
if( GDALGetMetadataItem( hDriver, GDAL_DCAP_RASTER, NULL) != NULL &&
(GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) != NULL
|| GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATECOPY, NULL ) != NULL) )
{
printf( " %s: %s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
}
}
printf( "\n" );
Usage();
}
if (!bQuiet && pszDest != NULL && !bFormatExplicitlySet)
CheckExtensionConsistency(pszDest, pszFormat);
/* -------------------------------------------------------------------- */
/* If histogram equalization is requested, do it now. */
/* -------------------------------------------------------------------- */
if( EQUAL(pszMethod,"equalize") )
{
ComputeEqualizationLUTs( hDataset, nLUTBins,
&padfScaleMin, &padfScaleMax,
&papanLUTs, pfnProgress );
}
/* -------------------------------------------------------------------- */
/* If we have a config file, assume it is for input and read */
/* it. */
/* -------------------------------------------------------------------- */
else if( pszConfigFile != NULL )
{
char **papszLines = CSLLoad( pszConfigFile );
if( CSLCount(papszLines) == 0 )
exit( 1 );
if( CSLCount(papszLines) != nBandCount )
{
fprintf( stderr, "Did not get %d lines in config file as expected.\n", nBandCount );
exit( 1 );
}
padfScaleMin = (double *) CPLCalloc(nBandCount,sizeof(double));
padfScaleMax = (double *) CPLCalloc(nBandCount,sizeof(double));
for( iBand = 0; iBand < nBandCount; iBand++ )
{
int iLUT;
char **papszTokens = CSLTokenizeString( papszLines[iBand] );
if( CSLCount(papszTokens) < 3
|| atoi(papszTokens[0]) != iBand+1 )
{
fprintf( stderr, "Line %d seems to be corrupt.\n", iBand+1 );
exit( 1 );
}
// Process scale min/max
padfScaleMin[iBand] = CPLAtof(papszTokens[1]);
padfScaleMax[iBand] = CPLAtof(papszTokens[2]);
if( CSLCount(papszTokens) == 3 )
continue;
// process lut
if( papanLUTs == NULL )
{
nLUTBins = CSLCount(papszTokens) - 3;
papanLUTs = (int **) CPLCalloc(sizeof(int*),nBandCount);
}
papanLUTs[iBand] = (int *) CPLCalloc(nLUTBins,sizeof(int));
for( iLUT = 0; iLUT < nLUTBins; iLUT++ )
papanLUTs[iBand][iLUT] = atoi(papszTokens[iLUT+3]);
CSLDestroy( papszTokens );
}
}
/* -------------------------------------------------------------------- */
/* If there is no destination, just report the scaling values */
/* and luts. */
/* -------------------------------------------------------------------- */
if( pszDest == NULL )
{
FILE *fpConfig = stdout;
if( pszConfigFile )
fpConfig = fopen( pszConfigFile, "w" );
for( iBand = 0; iBand < nBandCount; iBand++ )
{
fprintf( fpConfig, "%d:Band ", iBand+1 );
if( padfScaleMin != NULL )
fprintf( fpConfig, "%g:ScaleMin %g:ScaleMax ",
padfScaleMin[iBand], padfScaleMax[iBand] );
if( papanLUTs )
{
int iLUT;
for( iLUT = 0; iLUT < nLUTBins; iLUT++ )
fprintf( fpConfig, "%d ", papanLUTs[iBand][iLUT] );
}
fprintf( fpConfig, "\n" );
}
if( pszConfigFile )
fclose( fpConfig );
exit( 0 );
}
if (padfScaleMin == NULL || padfScaleMax == NULL)
{
fprintf( stderr, "-equalize or -config filename command line options must be specified.\n");
exit(1);
}
/* ==================================================================== */
/* Create a virtual dataset. */
/* ==================================================================== */
VRTDataset *poVDS;
EnhanceCBInfo *pasEInfo = (EnhanceCBInfo *)
CPLCalloc(nBandCount, sizeof(EnhanceCBInfo));
/* -------------------------------------------------------------------- */
/* Make a virtual clone. */
/* -------------------------------------------------------------------- */
poVDS = new VRTDataset( GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset) );
if( GDALGetGCPCount(hDataset) == 0 )
{
const char *pszProjection;
double adfGeoTransform[6];
pszProjection = GDALGetProjectionRef( hDataset );
if( pszProjection != NULL && strlen(pszProjection) > 0 )
poVDS->SetProjection( pszProjection );
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
poVDS->SetGeoTransform( adfGeoTransform );
}
else
{
poVDS->SetGCPs( GDALGetGCPCount(hDataset),
GDALGetGCPs(hDataset),
GDALGetGCPProjection( hDataset ) );
}
poVDS->SetMetadata( ((GDALDataset*)hDataset)->GetMetadata() );
for( iBand = 0; iBand < nBandCount; iBand++ )
{
VRTSourcedRasterBand *poVRTBand;
GDALRasterBand *poSrcBand;
GDALDataType eBandType;
poSrcBand = ((GDALDataset *) hDataset)->GetRasterBand(iBand+1);
/* -------------------------------------------------------------------- */
/* Select output data type to match source. */
/* -------------------------------------------------------------------- */
if( eOutputType == GDT_Unknown )
eBandType = GDT_Byte;
else
eBandType = eOutputType;
/* -------------------------------------------------------------------- */
/* Create this band. */
/* -------------------------------------------------------------------- */
poVDS->AddBand( eBandType, NULL );
poVRTBand = (VRTSourcedRasterBand *) poVDS->GetRasterBand( iBand+1 );
/* -------------------------------------------------------------------- */
/* Create a function based source with info on how to apply the */
/* enhancement. */
/* -------------------------------------------------------------------- */
pasEInfo[iBand].poSrcBand = poSrcBand;
pasEInfo[iBand].eWrkType = eBandType;
pasEInfo[iBand].dfScaleMin = padfScaleMin[iBand];
pasEInfo[iBand].dfScaleMax = padfScaleMax[iBand];
pasEInfo[iBand].nLUTBins = nLUTBins;
if( papanLUTs )
pasEInfo[iBand].panLUT = papanLUTs[iBand];
poVRTBand->AddFuncSource( EnhancerCallback, pasEInfo + iBand );
/* -------------------------------------------------------------------- */
/* copy over some other information of interest. */
/* -------------------------------------------------------------------- */
poVRTBand->CopyCommonInfoFrom( poSrcBand );
}
/* -------------------------------------------------------------------- */
/* Write to the output file using CopyCreate(). */
/* -------------------------------------------------------------------- */
hOutDS = GDALCreateCopy( hDriver, pszDest, (GDALDatasetH) poVDS,
FALSE, papszCreateOptions,
pfnProgress, NULL );
if( hOutDS != NULL )
GDALClose( hOutDS );
GDALClose( (GDALDatasetH) poVDS );
GDALClose( hDataset );
/* -------------------------------------------------------------------- */
/* Cleanup and exit. */
/* -------------------------------------------------------------------- */
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CSLDestroy( argv );
CSLDestroy( papszCreateOptions );
exit( 0 );
}
