static int OGRWFSCheckSRIDArg( swq_expr_node *op, int iSubArgIndex )
{
if( op->papoSubExpr[iSubArgIndex]->field_type == SWQ_INTEGER )
{
OGRSpatialReference oSRS;
if( oSRS.importFromEPSGA((int)op->papoSubExpr[iSubArgIndex]->int_value) != OGRERR_NONE )
{
CPLError(CE_Failure, CPLE_AppDefined, "Wrong value for argument %d of %s",
iSubArgIndex + 1, op->string_value);
return FALSE;
}
}
else if( op->papoSubExpr[iSubArgIndex]->field_type == SWQ_STRING )
{
OGRSpatialReference oSRS;
if( oSRS.SetFromUserInput(op->papoSubExpr[iSubArgIndex]->string_value) != OGRERR_NONE )
{
CPLError(CE_Failure, CPLE_AppDefined, "Wrong value for argument %d of %s",
iSubArgIndex + 1, op->string_value);
return FALSE;
}
}
else
{
CPLError(CE_Failure, CPLE_AppDefined, "Wrong field type for argument %d of %s",
iSubArgIndex + 1, op->string_value);
return FALSE;
}
return TRUE;
}
static CPLString ProjToWKT(const CPLString &proj) {
char* wkt = NULL;
OGRSpatialReference sr;
CPLString srs;
if (sr.SetFromUserInput(proj.c_str()) != OGRERR_NONE) return srs;
sr.exportToWkt(&wkt);
srs = wkt;
OGRFree(wkt);
return srs;
}
CPLString ProjToWKT(const CPLString &proj) {
char* wkt = nullptr;
OGRSpatialReference sr;
CPLString srs;
/* We could of course recognize OSGEO:41001 to SetFromUserInput(), but this hackish SRS */
/* is almost only used in the context of WMS */
if (strcmp(proj.c_str(),"OSGEO:41001") == 0)
{
if (sr.SetFromUserInput("EPSG:3857") != OGRERR_NONE) return srs;
}
else if (EQUAL(proj.c_str(),"EPSG:NONE"))
{
return srs;
}
else
{
if (sr.SetFromUserInput(proj.c_str()) != OGRERR_NONE) return srs;
}
sr.exportToWkt(&wkt);
srs = wkt;
CPLFree(wkt);
return srs;
}
bool hasSourceSRS(const std::string& sourceURN) {
if (m_transformation == nullptr) {
return false;
}
OGRSpatialReference refSys;
OGRErr err = refSys.SetFromUserInput(sourceURN.c_str());
if (err != OGRERR_NONE) {
return false;
}
return refSys.IsSame(m_transformation->GetSourceCS());
}
void setSourceSRS(const std::string& sourceURN) {
if (m_transformation != nullptr) {
OCTDestroyCoordinateTransformation(m_transformation);
m_transformation = nullptr;
}
OGRSpatialReference sourceSRS;
OGRErr err = sourceSRS.SetFromUserInput(sourceURN.c_str());
if (err != OGRERR_NONE) {
CITYGML_LOG_ERROR(m_logger, "Could not create OGRSpatialReference for source SRS " << sourceURN << ". OGR error code: " << err << ".");
return;
}
m_transformation = OGRCreateCoordinateTransformation(&sourceSRS, &m_destSRS);
if (m_transformation == nullptr) {
CITYGML_LOG_ERROR(m_logger, "Could not create transformation from source SRS " << sourceURN << " to destination SRS " << m_destSRSURN << ".");
return;
}
m_sourceURN = sourceURN;
}
CPLErr VRTDataset::XMLInit( CPLXMLNode *psTree, const char *pszVRTPath )
{
if( pszVRTPath != NULL )
this->pszVRTPath = CPLStrdup(pszVRTPath);
/* -------------------------------------------------------------------- */
/* Check for an SRS node. */
/* -------------------------------------------------------------------- */
if( strlen(CPLGetXMLValue(psTree, "SRS", "")) > 0 )
{
OGRSpatialReference oSRS;
CPLFree( pszProjection );
pszProjection = NULL;
if( oSRS.SetFromUserInput( CPLGetXMLValue(psTree, "SRS", "") )
== OGRERR_NONE )
oSRS.exportToWkt( &pszProjection );
}
/* -------------------------------------------------------------------- */
/* Check for a GeoTransform node. */
/* -------------------------------------------------------------------- */
if( strlen(CPLGetXMLValue(psTree, "GeoTransform", "")) > 0 )
{
const char *pszGT = CPLGetXMLValue(psTree, "GeoTransform", "");
char **papszTokens;
papszTokens = CSLTokenizeStringComplex( pszGT, ",", FALSE, FALSE );
if( CSLCount(papszTokens) != 6 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"GeoTransform node does not have expected six values.");
}
else
{
for( int iTA = 0; iTA < 6; iTA++ )
adfGeoTransform[iTA] = atof(papszTokens[iTA]);
bGeoTransformSet = TRUE;
}
CSLDestroy( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Check for GCPs. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psGCPList = CPLGetXMLNode( psTree, "GCPList" );
if( psGCPList != NULL )
{
CPLXMLNode *psXMLGCP;
OGRSpatialReference oSRS;
const char *pszRawProj = CPLGetXMLValue(psGCPList, "Projection", "");
CPLFree( pszGCPProjection );
if( strlen(pszRawProj) > 0
&& oSRS.SetFromUserInput( pszRawProj ) == OGRERR_NONE )
oSRS.exportToWkt( &pszGCPProjection );
else
pszGCPProjection = CPLStrdup("");
// Count GCPs.
int nGCPMax = 0;
for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;
psXMLGCP = psXMLGCP->psNext )
nGCPMax++;
pasGCPList = (GDAL_GCP *) CPLCalloc(sizeof(GDAL_GCP),nGCPMax);
for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;
psXMLGCP = psXMLGCP->psNext )
{
GDAL_GCP *psGCP = pasGCPList + nGCPCount;
if( !EQUAL(psXMLGCP->pszValue,"GCP") ||
psXMLGCP->eType != CXT_Element )
continue;
GDALInitGCPs( 1, psGCP );
CPLFree( psGCP->pszId );
psGCP->pszId = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Id",""));
CPLFree( psGCP->pszInfo );
psGCP->pszInfo = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Info",""));
psGCP->dfGCPPixel = atof(CPLGetXMLValue(psXMLGCP,"Pixel","0.0"));
psGCP->dfGCPLine = atof(CPLGetXMLValue(psXMLGCP,"Line","0.0"));
psGCP->dfGCPX = atof(CPLGetXMLValue(psXMLGCP,"X","0.0"));
psGCP->dfGCPY = atof(CPLGetXMLValue(psXMLGCP,"Y","0.0"));
psGCP->dfGCPZ = atof(CPLGetXMLValue(psXMLGCP,"Z","0.0"));
nGCPCount++;
}
}
/* -------------------------------------------------------------------- */
/* Apply any dataset level metadata. */
/* -------------------------------------------------------------------- */
oMDMD.XMLInit( psTree, TRUE );
/* -------------------------------------------------------------------- */
/* Create dataset mask band. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psChild;
/* Parse dataset mask band first */
CPLXMLNode* psMaskBandNode = CPLGetXMLNode(psTree, "MaskBand");
if (psMaskBandNode)
psChild = psMaskBandNode->psChild;
else
psChild = NULL;
for( ; psChild != NULL; psChild=psChild->psNext )
{
if( psChild->eType == CXT_Element
&& EQUAL(psChild->pszValue,"VRTRasterBand") )
{
VRTRasterBand *poBand = NULL;
const char *pszSubclass = CPLGetXMLValue( psChild, "subclass",
"VRTSourcedRasterBand" );
if( EQUAL(pszSubclass,"VRTSourcedRasterBand") )
poBand = new VRTSourcedRasterBand( this, 0 );
else if( EQUAL(pszSubclass, "VRTDerivedRasterBand") )
poBand = new VRTDerivedRasterBand( this, 0 );
else if( EQUAL(pszSubclass, "VRTRawRasterBand") )
poBand = new VRTRawRasterBand( this, 0 );
else if( EQUAL(pszSubclass, "VRTWarpedRasterBand") )
poBand = new VRTWarpedRasterBand( this, 0 );
else
CPLError( CE_Failure, CPLE_AppDefined,
"VRTRasterBand of unrecognised subclass '%s'.",
pszSubclass );
if( poBand != NULL
&& poBand->XMLInit( psChild, pszVRTPath ) == CE_None )
{
SetMaskBand(poBand);
break;
}
else
{
if( poBand )
delete poBand;
return CE_Failure;
}
}
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
int nBands = 0;
for( psChild=psTree->psChild; psChild != NULL; psChild=psChild->psNext )
{
if( psChild->eType == CXT_Element
&& EQUAL(psChild->pszValue,"VRTRasterBand") )
{
VRTRasterBand *poBand = NULL;
const char *pszSubclass = CPLGetXMLValue( psChild, "subclass",
"VRTSourcedRasterBand" );
if( EQUAL(pszSubclass,"VRTSourcedRasterBand") )
poBand = new VRTSourcedRasterBand( this, nBands+1 );
else if( EQUAL(pszSubclass, "VRTDerivedRasterBand") )
poBand = new VRTDerivedRasterBand( this, nBands+1 );
else if( EQUAL(pszSubclass, "VRTRawRasterBand") )
poBand = new VRTRawRasterBand( this, nBands+1 );
else if( EQUAL(pszSubclass, "VRTWarpedRasterBand") )
poBand = new VRTWarpedRasterBand( this, nBands+1 );
else
CPLError( CE_Failure, CPLE_AppDefined,
"VRTRasterBand of unrecognised subclass '%s'.",
pszSubclass );
if( poBand != NULL
&& poBand->XMLInit( psChild, pszVRTPath ) == CE_None )
{
SetBand( ++nBands, poBand );
}
else
{
if( poBand )
delete poBand;
return CE_Failure;
}
}
}
return CE_None;
}
int main( int nArgc, char ** papszArgv )
{
OGRSpatialReference oSRS;
int i;
int bReportXML = FALSE;
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 2 )
Usage();
for( i = 1; i < nArgc; i++ )
{
if( EQUAL(papszArgv[i],"-xml") )
bReportXML = TRUE;
else if( EQUAL(papszArgv[i],"-t") && i < nArgc - 4 )
{
OGRSpatialReference oSourceSRS, oTargetSRS;
OGRCoordinateTransformation *poCT;
double x, y, z_orig, z;
int nArgsUsed = 4;
if( oSourceSRS.SetFromUserInput(papszArgv[i+1]) != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"SetFromUserInput(%s) failed.",
papszArgv[i+1] );
continue;
}
if( oTargetSRS.SetFromUserInput(papszArgv[i+2]) != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"SetFromUserInput(%s) failed.",
papszArgv[i+2] );
continue;
}
poCT = OGRCreateCoordinateTransformation( &oSourceSRS,
&oTargetSRS );
x = CPLAtof( papszArgv[i+3] );
y = CPLAtof( papszArgv[i+4] );
if( i < nArgc - 5
&& (CPLAtof(papszArgv[i+5]) > 0.0 || papszArgv[i+5][0] == '0') )
{
z_orig = z = CPLAtof(papszArgv[i+5]);
nArgsUsed++;
}
else
z_orig = z = 0;
if( poCT == NULL || !poCT->Transform( 1, &x, &y, &z ) )
printf( "Transformation failed.\n" );
else
printf( "(%f,%f,%f) -> (%f,%f,%f)\n",
CPLAtof( papszArgv[i+3] ),
CPLAtof( papszArgv[i+4] ),
z_orig,
x, y, z );
i += nArgsUsed;
}
else
{
/* coverity[tainted_data] */
if( oSRS.SetFromUserInput(papszArgv[i]) != OGRERR_NONE )
CPLError( CE_Failure, CPLE_AppDefined,
"Error occurred translating %s.\n",
papszArgv[i] );
else
{
char *pszWKT = NULL;
if( oSRS.Validate() != OGRERR_NONE )
printf( "Validate Fails.\n" );
else
printf( "Validate Succeeds.\n" );
oSRS.exportToPrettyWkt( &pszWKT, FALSE );
printf( "WKT[%s] =\n%s\n",
papszArgv[i], pszWKT );
CPLFree( pszWKT );
printf( "\n" );
oSRS.exportToPrettyWkt( &pszWKT, TRUE );
printf( "Simplified WKT[%s] =\n%s\n",
papszArgv[i], pszWKT );
CPLFree( pszWKT );
printf( "\n" );
OGRSpatialReference *poSRS2;
poSRS2 = oSRS.Clone();
poSRS2->StripCTParms();
poSRS2->exportToWkt( &pszWKT );
printf( "Old Style WKT[%s] = %s\n",
papszArgv[i], pszWKT );
CPLFree( pszWKT );
OGRSpatialReference::DestroySpatialReference( poSRS2 );
poSRS2 = oSRS.Clone();
poSRS2->morphToESRI();
poSRS2->exportToPrettyWkt( &pszWKT, FALSE );
printf( "ESRI'ified WKT[%s] = \n%s\n",
papszArgv[i], pszWKT );
CPLFree( pszWKT );
OGRSpatialReference::DestroySpatialReference( poSRS2 );
oSRS.exportToProj4( &pszWKT );
printf( "PROJ.4 rendering of [%s] = %s\n",
papszArgv[i], pszWKT );
CPLFree( pszWKT );
if( bReportXML )
{
char *pszRawXML;
if( oSRS.exportToXML(&pszRawXML) == OGRERR_NONE )
{
printf( "XML[%s] =\n%s\n",
papszArgv[i], pszRawXML );
CPLFree( pszRawXML );
}
else
{
printf( "XML translation failed\n" );
}
}
printf( "\n" );
}
}
}
CSLDestroy( papszArgv );
OSRCleanup();
CPLFinderClean();
CPLCleanupTLS();
return 0;
}
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;
}
OGRLayer* OGRVRTDataSource::InstanciateWarpedLayer(
CPLXMLNode *psLTree,
const char *pszVRTDirectory,
int bUpdate,
int nRecLevel)
{
if( !EQUAL(psLTree->pszValue,"OGRVRTWarpedLayer") )
return NULL;
CPLXMLNode *psSubNode;
OGRLayer* poSrcLayer = NULL;
for( psSubNode=psLTree->psChild;
psSubNode != NULL;
psSubNode=psSubNode->psNext )
{
if( psSubNode->eType != CXT_Element )
continue;
poSrcLayer = InstanciateLayer(psSubNode, pszVRTDirectory,
bUpdate, nRecLevel + 1);
if( poSrcLayer != NULL )
break;
}
if( poSrcLayer == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot instanciate source layer" );
return NULL;
}
const char* pszTargetSRS = CPLGetXMLValue(psLTree, "TargetSRS", NULL);
if( pszTargetSRS == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Missing TargetSRS element within OGRVRTWarpedLayer" );
delete poSrcLayer;
return NULL;
}
const char* pszGeomFieldName = CPLGetXMLValue(psLTree, "WarpedGeomFieldName", NULL);
int iGeomField = 0;
if( pszGeomFieldName != NULL )
{
iGeomField = poSrcLayer->GetLayerDefn()->GetGeomFieldIndex(pszGeomFieldName);
if( iGeomField < 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot find source geometry field '%s'", pszGeomFieldName );
delete poSrcLayer;
return NULL;
}
}
OGRSpatialReference* poSrcSRS;
OGRSpatialReference* poTargetSRS;
const char* pszSourceSRS = CPLGetXMLValue(psLTree, "SrcSRS", NULL);
if( pszSourceSRS == NULL )
{
poSrcSRS = poSrcLayer->GetLayerDefn()->GetGeomFieldDefn(iGeomField)->GetSpatialRef();
if( poSrcSRS != NULL)
poSrcSRS = poSrcSRS->Clone();
}
else
{
poSrcSRS = new OGRSpatialReference();
if( poSrcSRS->SetFromUserInput(pszSourceSRS) != OGRERR_NONE )
{
delete poSrcSRS;
poSrcSRS = NULL;
}
}
if( poSrcSRS == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to import source SRS" );
delete poSrcLayer;
return NULL;
}
poTargetSRS = new OGRSpatialReference();
if( poTargetSRS->SetFromUserInput(pszTargetSRS) != OGRERR_NONE )
{
delete poTargetSRS;
poTargetSRS = NULL;
}
if( poTargetSRS == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to import target SRS" );
delete poSrcSRS;
delete poSrcLayer;
return NULL;
}
if( pszSourceSRS == NULL && poSrcSRS->IsSame(poTargetSRS) )
{
delete poSrcSRS;
delete poTargetSRS;
return poSrcLayer;
}
OGRCoordinateTransformation* poCT =
OGRCreateCoordinateTransformation( poSrcSRS, poTargetSRS );
OGRCoordinateTransformation* poReversedCT = (poCT != NULL) ?
OGRCreateCoordinateTransformation( poTargetSRS, poSrcSRS ) : NULL;
delete poSrcSRS;
delete poTargetSRS;
if( poCT == NULL )
{
delete poSrcLayer;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Build the OGRWarpedLayer. */
/* -------------------------------------------------------------------- */
OGRWarpedLayer* poLayer = new OGRWarpedLayer(poSrcLayer, iGeomField,
TRUE, poCT, poReversedCT);
/* -------------------------------------------------------------------- */
/* Set Extent if provided */
/* -------------------------------------------------------------------- */
const char* pszExtentXMin = CPLGetXMLValue( psLTree, "ExtentXMin", NULL );
const char* pszExtentYMin = CPLGetXMLValue( psLTree, "ExtentYMin", NULL );
const char* pszExtentXMax = CPLGetXMLValue( psLTree, "ExtentXMax", NULL );
const char* pszExtentYMax = CPLGetXMLValue( psLTree, "ExtentYMax", NULL );
if( pszExtentXMin != NULL && pszExtentYMin != NULL &&
pszExtentXMax != NULL && pszExtentYMax != NULL )
{
poLayer->SetExtent( CPLAtof(pszExtentXMin),
CPLAtof(pszExtentYMin),
CPLAtof(pszExtentXMax),
CPLAtof(pszExtentYMax) );
}
return poLayer;
}
OGRLayer* OGRVRTDataSource::InstanciateUnionLayer(
CPLXMLNode *psLTree,
const char *pszVRTDirectory,
int bUpdate,
int nRecLevel)
{
CPLXMLNode *psSubNode;
if( !EQUAL(psLTree->pszValue,"OGRVRTUnionLayer") )
return NULL;
/* -------------------------------------------------------------------- */
/* Get layer name. */
/* -------------------------------------------------------------------- */
const char *pszLayerName = CPLGetXMLValue( psLTree, "name", NULL );
if( pszLayerName == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Missing name attribute on OGRVRTUnionLayer" );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Do we have a fixed geometry type? If not derive from the */
/* source layer. */
/* -------------------------------------------------------------------- */
const char* pszGType = CPLGetXMLValue( psLTree, "GeometryType", NULL );
int bGlobalGeomTypeSet = FALSE;
OGRwkbGeometryType eGlobalGeomType = wkbUnknown;
if( pszGType != NULL )
{
int bError;
bGlobalGeomTypeSet = TRUE;
eGlobalGeomType = OGRVRTGetGeometryType(pszGType, &bError);
if( bError )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GeometryType %s not recognised.",
pszGType );
return NULL;
}
}
/* -------------------------------------------------------------------- */
/* Apply a spatial reference system if provided */
/* -------------------------------------------------------------------- */
const char* pszLayerSRS = CPLGetXMLValue( psLTree, "LayerSRS", NULL );
OGRSpatialReference* poGlobalSRS = NULL;
int bGlobalSRSSet = FALSE;
if( pszLayerSRS != NULL )
{
bGlobalSRSSet = TRUE;
if( !EQUAL(pszLayerSRS,"NULL") )
{
OGRSpatialReference oSRS;
if( oSRS.SetFromUserInput( pszLayerSRS ) != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to import LayerSRS `%s'.", pszLayerSRS );
return FALSE;
}
poGlobalSRS = oSRS.Clone();
}
}
/* -------------------------------------------------------------------- */
/* Find field declarations. */
/* -------------------------------------------------------------------- */
OGRFieldDefn** papoFields = NULL;
int nFields = 0;
OGRUnionLayerGeomFieldDefn** papoGeomFields = NULL;
int nGeomFields = 0;
for( psSubNode=psLTree->psChild;
psSubNode != NULL;
psSubNode=psSubNode->psNext )
{
if( psSubNode->eType != CXT_Element )
continue;
if( psSubNode->eType == CXT_Element && EQUAL(psSubNode->pszValue,"Field") )
{
/* -------------------------------------------------------------------- */
/* Field name. */
/* -------------------------------------------------------------------- */
const char *pszName = CPLGetXMLValue( psSubNode, "name", NULL );
if( pszName == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to identify Field name." );
break;
}
OGRFieldDefn oFieldDefn( pszName, OFTString );
/* -------------------------------------------------------------------- */
/* Type */
/* -------------------------------------------------------------------- */
const char *pszArg = CPLGetXMLValue( psSubNode, "type", NULL );
if( pszArg != NULL )
{
int iType;
for( iType = 0; iType <= (int) OFTMaxType; iType++ )
{
if( EQUAL(pszArg,OGRFieldDefn::GetFieldTypeName(
(OGRFieldType)iType)) )
{
oFieldDefn.SetType( (OGRFieldType) iType );
break;
}
}
if( iType > (int) OFTMaxType )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to identify Field type '%s'.",
pszArg );
break;
}
}
/* -------------------------------------------------------------------- */
/* Width and precision. */
/* -------------------------------------------------------------------- */
int nWidth = atoi(CPLGetXMLValue( psSubNode, "width", "0" ));
if (nWidth < 0)
{
CPLError( CE_Failure, CPLE_IllegalArg,
"Invalid width for field %s.",
pszName );
break;
}
oFieldDefn.SetWidth(nWidth);
int nPrecision = atoi(CPLGetXMLValue( psSubNode, "precision", "0" ));
if (nPrecision < 0 || nPrecision > 1024)
{
CPLError( CE_Failure, CPLE_IllegalArg,
"Invalid precision for field %s.",
pszName );
break;
}
oFieldDefn.SetPrecision(nPrecision);
papoFields = (OGRFieldDefn**) CPLRealloc(papoFields,
sizeof(OGRFieldDefn*) * (nFields + 1));
papoFields[nFields] = new OGRFieldDefn(&oFieldDefn);
nFields ++;
}
else if( psSubNode->eType == CXT_Element &&
EQUAL(psSubNode->pszValue,"GeometryField") )
{
const char *pszName = CPLGetXMLValue( psSubNode, "name", NULL );
if( pszName == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to identify GeometryField name." );
break;
}
pszGType = CPLGetXMLValue( psSubNode, "GeometryType", NULL );
if( pszGType == NULL && nGeomFields == 0 )
pszGType = CPLGetXMLValue( psLTree, "GeometryType", NULL );
OGRwkbGeometryType eGeomType = wkbUnknown;
int bGeomTypeSet = FALSE;
if( pszGType != NULL )
{
int bError;
eGeomType = OGRVRTGetGeometryType(pszGType, &bError);
bGeomTypeSet = TRUE;
if( bError || eGeomType == wkbNone )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GeometryType %s not recognised.",
pszGType );
break;
}
}
const char* pszSRS = CPLGetXMLValue( psSubNode, "SRS", NULL );
if( pszSRS == NULL && nGeomFields == 0 )
pszSRS = CPLGetXMLValue( psLTree, "LayerSRS", NULL );
OGRSpatialReference* poSRS = NULL;
int bSRSSet = FALSE;
if( pszSRS != NULL )
{
bSRSSet = TRUE;
if( !EQUAL(pszSRS,"NULL") )
{
OGRSpatialReference oSRS;
if( oSRS.SetFromUserInput( pszSRS ) != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to import SRS `%s'.", pszSRS );
break;
}
poSRS = oSRS.Clone();
}
}
OGRUnionLayerGeomFieldDefn* poFieldDefn =
new OGRUnionLayerGeomFieldDefn(pszName, eGeomType);
if( poSRS != NULL )
{
poFieldDefn->SetSpatialRef(poSRS);
poSRS->Dereference();
}
poFieldDefn->bGeomTypeSet = bGeomTypeSet;
poFieldDefn->bSRSSet = bSRSSet;
const char* pszExtentXMin = CPLGetXMLValue( psSubNode, "ExtentXMin", NULL );
const char* pszExtentYMin = CPLGetXMLValue( psSubNode, "ExtentYMin", NULL );
const char* pszExtentXMax = CPLGetXMLValue( psSubNode, "ExtentXMax", NULL );
const char* pszExtentYMax = CPLGetXMLValue( psSubNode, "ExtentYMax", NULL );
if( pszExtentXMin != NULL && pszExtentYMin != NULL &&
pszExtentXMax != NULL && pszExtentYMax != NULL )
{
poFieldDefn->sStaticEnvelope.MinX = CPLAtof(pszExtentXMin);
poFieldDefn->sStaticEnvelope.MinY = CPLAtof(pszExtentYMin);
poFieldDefn->sStaticEnvelope.MaxX = CPLAtof(pszExtentXMax);
poFieldDefn->sStaticEnvelope.MaxY = CPLAtof(pszExtentYMax);
}
papoGeomFields = (OGRUnionLayerGeomFieldDefn**) CPLRealloc(papoGeomFields,
sizeof(OGRUnionLayerGeomFieldDefn*) * (nGeomFields + 1));
papoGeomFields[nGeomFields] = poFieldDefn;
nGeomFields ++;
}
}
/* -------------------------------------------------------------------- */
/* Set Extent if provided */
/* -------------------------------------------------------------------- */
const char* pszExtentXMin = CPLGetXMLValue( psLTree, "ExtentXMin", NULL );
const char* pszExtentYMin = CPLGetXMLValue( psLTree, "ExtentYMin", NULL );
const char* pszExtentXMax = CPLGetXMLValue( psLTree, "ExtentXMax", NULL );
const char* pszExtentYMax = CPLGetXMLValue( psLTree, "ExtentYMax", NULL );
if( eGlobalGeomType != wkbNone && nGeomFields == 0 &&
(bGlobalGeomTypeSet || bGlobalSRSSet ||
(pszExtentXMin != NULL && pszExtentYMin != NULL &&
pszExtentXMax != NULL && pszExtentYMax != NULL)) )
{
OGRUnionLayerGeomFieldDefn* poFieldDefn =
new OGRUnionLayerGeomFieldDefn("", eGlobalGeomType);
if( poGlobalSRS != NULL )
{
poFieldDefn->SetSpatialRef(poGlobalSRS);
poGlobalSRS->Dereference();
poGlobalSRS = NULL;
}
poFieldDefn->bGeomTypeSet = bGlobalGeomTypeSet;
poFieldDefn->bSRSSet = bGlobalSRSSet;
if( pszExtentXMin != NULL && pszExtentYMin != NULL &&
pszExtentXMax != NULL && pszExtentYMax != NULL )
{
poFieldDefn->sStaticEnvelope.MinX = CPLAtof(pszExtentXMin);
poFieldDefn->sStaticEnvelope.MinY = CPLAtof(pszExtentYMin);
poFieldDefn->sStaticEnvelope.MaxX = CPLAtof(pszExtentXMax);
poFieldDefn->sStaticEnvelope.MaxY = CPLAtof(pszExtentYMax);
}
papoGeomFields = (OGRUnionLayerGeomFieldDefn**) CPLRealloc(papoGeomFields,
sizeof(OGRUnionLayerGeomFieldDefn*) * (nGeomFields + 1));
papoGeomFields[nGeomFields] = poFieldDefn;
nGeomFields ++;
}
else
{
delete poGlobalSRS;
poGlobalSRS = NULL;
}
/* -------------------------------------------------------------------- */
/* Find source layers */
/* -------------------------------------------------------------------- */
int nSrcLayers = 0;
OGRLayer** papoSrcLayers = NULL;
for( psSubNode=psLTree->psChild;
psSubNode != NULL;
psSubNode=psSubNode->psNext )
{
if( psSubNode->eType != CXT_Element )
continue;
OGRLayer* poSrcLayer = InstanciateLayer(psSubNode, pszVRTDirectory,
bUpdate, nRecLevel + 1);
if( poSrcLayer != NULL )
{
papoSrcLayers = (OGRLayer**)
CPLRealloc(papoSrcLayers, sizeof(OGRLayer*) * (nSrcLayers + 1));
papoSrcLayers[nSrcLayers] = poSrcLayer;
nSrcLayers ++;
}
}
if( nSrcLayers == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot find source layers" );
int iField;
for(iField = 0; iField < nFields; iField++)
delete papoFields[iField];
CPLFree(papoFields);
for(iField = 0; iField < nGeomFields; iField++)
delete papoGeomFields[iField];
CPLFree(papoGeomFields);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Build the OGRUnionLayer. */
/* -------------------------------------------------------------------- */
OGRUnionLayer* poLayer = new OGRUnionLayer( pszLayerName,
nSrcLayers,
papoSrcLayers,
TRUE );
/* -------------------------------------------------------------------- */
/* Set the source layer field name attribute. */
/* -------------------------------------------------------------------- */
const char* pszSourceLayerFieldName =
CPLGetXMLValue( psLTree, "SourceLayerFieldName", NULL );
poLayer->SetSourceLayerFieldName(pszSourceLayerFieldName);
/* -------------------------------------------------------------------- */
/* Set the PreserveSrcFID attribute. */
/* -------------------------------------------------------------------- */
int bPreserveSrcFID = FALSE;
const char* pszPreserveFID = CPLGetXMLValue( psLTree, "PreserveSrcFID", NULL );
if( pszPreserveFID != NULL )
bPreserveSrcFID = CSLTestBoolean(pszPreserveFID);
poLayer->SetPreserveSrcFID(bPreserveSrcFID);
/* -------------------------------------------------------------------- */
/* Set fields */
/* -------------------------------------------------------------------- */
FieldUnionStrategy eFieldStrategy = FIELD_UNION_ALL_LAYERS;
const char* pszFieldStrategy = CPLGetXMLValue( psLTree, "FieldStrategy", NULL );
if( pszFieldStrategy != NULL )
{
if( EQUAL(pszFieldStrategy, "FirstLayer") )
eFieldStrategy = FIELD_FROM_FIRST_LAYER;
else if( EQUAL(pszFieldStrategy, "Union") )
eFieldStrategy = FIELD_UNION_ALL_LAYERS;
else if( EQUAL(pszFieldStrategy, "Intersection") )
eFieldStrategy = FIELD_INTERSECTION_ALL_LAYERS;
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unhandled value for FieldStrategy `%s'.", pszFieldStrategy );
}
}
if( nFields != 0 || nGeomFields > 1 )
{
if( pszFieldStrategy != NULL )
CPLError( CE_Warning, CPLE_AppDefined,
"Ignoring FieldStrategy value, because explicit Field or GeometryField is provided") ;
eFieldStrategy = FIELD_SPECIFIED;
}
poLayer->SetFields(eFieldStrategy, nFields, papoFields,
(nGeomFields == 0 && eGlobalGeomType == wkbNone) ? -1 : nGeomFields,
papoGeomFields);
int iField;
for(iField = 0; iField < nFields; iField++)
delete papoFields[iField];
CPLFree(papoFields);
for(iField = 0; iField < nGeomFields; iField++)
delete papoGeomFields[iField];
CPLFree(papoGeomFields);
/* -------------------------------------------------------------------- */
/* Set FeatureCount if provided */
/* -------------------------------------------------------------------- */
const char* pszFeatureCount = CPLGetXMLValue( psLTree, "FeatureCount", NULL );
if( pszFeatureCount != NULL )
{
poLayer->SetFeatureCount(atoi(pszFeatureCount));
}
return poLayer;
}
OGRNASLayer *OGRNASDataSource::TranslateNASSchema( GMLFeatureClass *poClass )
{
OGRwkbGeometryType eGType = wkbNone;
if( poClass->GetGeometryPropertyCount() != 0 )
{
eGType = static_cast<OGRwkbGeometryType>(
poClass->GetGeometryProperty(0)->GetType() );
if( poClass->GetFeatureCount() == 0 )
eGType = wkbUnknown;
}
/* -------------------------------------------------------------------- */
/* Translate SRS. */
/* -------------------------------------------------------------------- */
const char* pszSRSName = poClass->GetSRSName();
OGRSpatialReference* poSRS = NULL;
if (pszSRSName)
{
const char *pszHandle = strrchr( pszSRSName, ':' );
if( pszHandle != NULL )
{
pszHandle += 1;
poSRS = new OGRSpatialReference();
for( int i = 0; apszURNNames[i*2+0] != NULL; i++ )
{
const char *pszTarget = apszURNNames[i*2+0];
const int nTLen = static_cast<int>(strlen(pszTarget));
// Are we just looking for a prefix match?
if( pszTarget[nTLen-1] == '*' )
{
if( EQUALN(pszTarget,pszHandle,nTLen-1) )
pszSRSName = apszURNNames[i*2+1];
}
else
{
if( EQUAL(pszTarget,pszHandle) )
pszSRSName = apszURNNames[i*2+1];
}
}
if (poSRS->SetFromUserInput(pszSRSName) != OGRERR_NONE)
{
CPLDebug( "NAS", "Failed to translate srsName='%s'",
pszSRSName );
delete poSRS;
poSRS = NULL;
}
}
}
/* -------------------------------------------------------------------- */
/* Create an empty layer. */
/* -------------------------------------------------------------------- */
OGRNASLayer *poLayer =
new OGRNASLayer( poClass->GetName(), poSRS, eGType, this );
delete poSRS;
/* -------------------------------------------------------------------- */
/* Added attributes (properties). */
/* -------------------------------------------------------------------- */
for( int iField = 0; iField < poClass->GetPropertyCount(); iField++ )
{
GMLPropertyDefn *poProperty = poClass->GetProperty( iField );
OGRFieldType eFType;
if( poProperty->GetType() == GMLPT_Untyped )
eFType = OFTString;
else if( poProperty->GetType() == GMLPT_String )
eFType = OFTString;
else if( poProperty->GetType() == GMLPT_Integer )
eFType = OFTInteger;
else if( poProperty->GetType() == GMLPT_Real )
eFType = OFTReal;
else if( poProperty->GetType() == GMLPT_StringList )
eFType = OFTStringList;
else if( poProperty->GetType() == GMLPT_IntegerList )
eFType = OFTIntegerList;
else if( poProperty->GetType() == GMLPT_RealList )
eFType = OFTRealList;
else
eFType = OFTString;
OGRFieldDefn oField( poProperty->GetName(), eFType );
if ( STARTS_WITH_CI(oField.GetNameRef(), "ogr:") )
oField.SetName(poProperty->GetName()+4);
if( poProperty->GetWidth() > 0 )
oField.SetWidth( poProperty->GetWidth() );
poLayer->GetLayerDefn()->AddFieldDefn( &oField );
}
return poLayer;
}
int GDALJP2Metadata::ParseGMLCoverageDesc()
{
/* -------------------------------------------------------------------- */
/* Do we have an XML doc that is apparently a coverage */
/* description? */
/* -------------------------------------------------------------------- */
const char *pszCoverage = CSLFetchNameValue( papszGMLMetadata,
"gml.root-instance" );
if( pszCoverage == NULL )
return FALSE;
CPLDebug( "GDALJP2Metadata", "Found GML Box:\n%s", pszCoverage );
/* -------------------------------------------------------------------- */
/* Try parsing the XML. Wipe any namespace prefixes. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psXML = CPLParseXMLString( pszCoverage );
if( psXML == NULL )
return FALSE;
CPLStripXMLNamespace( psXML, NULL, TRUE );
/* -------------------------------------------------------------------- */
/* Isolate RectifiedGrid. Eventually we will need to support */
/* other georeferencing objects. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRG = CPLSearchXMLNode( psXML, "=RectifiedGrid" );
CPLXMLNode *psOriginPoint = NULL;
const char *pszOffset1=NULL, *pszOffset2=NULL;
if( psRG != NULL )
{
psOriginPoint = CPLGetXMLNode( psRG, "origin.Point" );
CPLXMLNode *psOffset1 = CPLGetXMLNode( psRG, "offsetVector" );
if( psOffset1 != NULL )
{
pszOffset1 = CPLGetXMLValue( psOffset1, "", NULL );
pszOffset2 = CPLGetXMLValue( psOffset1->psNext, "=offsetVector",
NULL );
}
}
/* -------------------------------------------------------------------- */
/* If we are missing any of the origin or 2 offsets then give up. */
/* -------------------------------------------------------------------- */
if( psOriginPoint == NULL || pszOffset1 == NULL || pszOffset2 == NULL )
{
CPLDestroyXMLNode( psXML );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Extract origin location. */
/* -------------------------------------------------------------------- */
OGRPoint *poOriginGeometry = NULL;
const char *pszSRSName = NULL;
if( psOriginPoint != NULL )
{
poOriginGeometry = (OGRPoint *)
OGR_G_CreateFromGMLTree( psOriginPoint );
if( poOriginGeometry != NULL
&& wkbFlatten(poOriginGeometry->getGeometryType()) != wkbPoint )
{
delete poOriginGeometry;
poOriginGeometry = NULL;
}
// SRS?
pszSRSName = CPLGetXMLValue( psOriginPoint, "srsName", NULL );
}
/* -------------------------------------------------------------------- */
/* Extract offset(s) */
/* -------------------------------------------------------------------- */
char **papszOffset1Tokens = NULL;
char **papszOffset2Tokens = NULL;
int bSuccess = FALSE;
papszOffset1Tokens =
CSLTokenizeStringComplex( pszOffset1, " ,", FALSE, FALSE );
papszOffset2Tokens =
CSLTokenizeStringComplex( pszOffset2, " ,", FALSE, FALSE );
if( CSLCount(papszOffset1Tokens) >= 2
&& CSLCount(papszOffset2Tokens) >= 2
&& poOriginGeometry != NULL )
{
adfGeoTransform[0] = poOriginGeometry->getX();
adfGeoTransform[1] = atof(papszOffset1Tokens[0]);
adfGeoTransform[2] = atof(papszOffset2Tokens[0]);
adfGeoTransform[3] = poOriginGeometry->getY();
adfGeoTransform[4] = atof(papszOffset1Tokens[1]);
adfGeoTransform[5] = atof(papszOffset2Tokens[1]);
// offset from center of pixel.
adfGeoTransform[0] -= adfGeoTransform[1]*0.5;
adfGeoTransform[0] -= adfGeoTransform[2]*0.5;
adfGeoTransform[3] -= adfGeoTransform[4]*0.5;
adfGeoTransform[3] -= adfGeoTransform[5]*0.5;
bSuccess = TRUE;
bHaveGeoTransform = TRUE;
}
CSLDestroy( papszOffset1Tokens );
CSLDestroy( papszOffset2Tokens );
if( poOriginGeometry != NULL )
delete poOriginGeometry;
/* -------------------------------------------------------------------- */
/* If we still don't have an srsName, check for it on the */
/* boundedBy Envelope. Some products */
/* (ie. EuropeRasterTile23.jpx) use this as the only srsName */
/* delivery vehicle. */
/* -------------------------------------------------------------------- */
if( pszSRSName == NULL )
{
pszSRSName =
CPLGetXMLValue( psXML,
"=FeatureCollection.boundedBy.Envelope.srsName",
NULL );
}
/* -------------------------------------------------------------------- */
/* If we have gotten a geotransform, then try to interprete the */
/* srsName. */
/* -------------------------------------------------------------------- */
int bNeedAxisFlip = FALSE;
if( bSuccess && pszSRSName != NULL
&& (pszProjection == NULL || strlen(pszProjection) == 0) )
{
OGRSpatialReference oSRS;
if( EQUALN(pszSRSName,"epsg:",5) )
{
if( oSRS.SetFromUserInput( pszSRSName ) == OGRERR_NONE )
oSRS.exportToWkt( &pszProjection );
}
else if( EQUALN(pszSRSName,"urn:",4)
&& strstr(pszSRSName,":def:") != NULL
&& oSRS.importFromURN(pszSRSName) == OGRERR_NONE )
{
const char *pszCode = strrchr(pszSRSName,':') + 1;
oSRS.exportToWkt( &pszProjection );
// Per #2131
if( atoi(pszCode) >= 4000 && atoi(pszCode) <= 4999 )
{
CPLDebug( "GMLJP2", "Request axis flip for SRS=%s",
pszSRSName );
bNeedAxisFlip = TRUE;
}
}
else if( !GMLSRSLookup( pszSRSName ) )
{
CPLDebug( "GDALJP2Metadata",
"Unable to evaluate SRSName=%s",
pszSRSName );
}
}
if( pszProjection )
CPLDebug( "GDALJP2Metadata",
"Got projection from GML box: %s",
pszProjection );
CPLDestroyXMLNode( psXML );
psXML = NULL;
/* -------------------------------------------------------------------- */
/* Do we need to flip the axes? */
/* -------------------------------------------------------------------- */
if( bNeedAxisFlip
&& CSLTestBoolean( CPLGetConfigOption( "GDAL_IGNORE_AXIS_ORIENTATION",
"FALSE" ) ) )
{
bNeedAxisFlip = FALSE;
CPLDebug( "GMLJP2", "Supressed axis flipping based on GDAL_IGNORE_AXIS_ORIENTATION." );
}
if( bNeedAxisFlip )
{
double dfTemp;
CPLDebug( "GMLJP2",
"Flipping axis orientation in GMLJP2 coverage description." );
dfTemp = adfGeoTransform[0];
adfGeoTransform[0] = adfGeoTransform[3];
adfGeoTransform[3] = dfTemp;
dfTemp = adfGeoTransform[1];
adfGeoTransform[1] = adfGeoTransform[4];
adfGeoTransform[4] = dfTemp;
dfTemp = adfGeoTransform[2];
adfGeoTransform[2] = adfGeoTransform[5];
adfGeoTransform[5] = dfTemp;
}
return pszProjection != NULL && bSuccess;
}
int FindSRS( const char *pszInput, OGRSpatialReference &oSRS, int bDebug )
{
int bGotSRS = FALSE;
VSILFILE *fp = NULL;
GDALDataset *poGDALDS = NULL;
OGRDataSource *poOGRDS = NULL;
OGRLayer *poLayer = NULL;
char *pszProjection = NULL;
CPLErrorHandler oErrorHandler = NULL;
int bIsFile = FALSE;
OGRErr eErr = CE_None;
/* temporarily supress error messages we may get from xOpen() */
if ( ! bDebug )
oErrorHandler = CPLSetErrorHandler ( CPLQuietErrorHandler );
/* Test if argument is a file */
fp = VSIFOpenL( pszInput, "r" );
if ( fp ) {
bIsFile = TRUE;
VSIFCloseL( fp );
CPLDebug( "gdalsrsinfo", "argument is a file" );
}
/* try to open with GDAL */
CPLDebug( "gdalsrsinfo", "trying to open with GDAL" );
poGDALDS = (GDALDataset *) GDALOpen( pszInput, GA_ReadOnly );
if ( poGDALDS != NULL && poGDALDS->GetProjectionRef( ) != NULL ) {
pszProjection = (char *) poGDALDS->GetProjectionRef( );
if( oSRS.importFromWkt( &pszProjection ) == CE_None ) {
CPLDebug( "gdalsrsinfo", "got SRS from GDAL" );
bGotSRS = TRUE;
}
GDALClose( (GDALDatasetH) poGDALDS );
if ( ! bGotSRS )
CPLDebug( "gdalsrsinfo", "did not open with GDAL" );
}
#ifdef OGR_ENABLED
/* if unsuccessful, try to open with OGR */
if ( ! bGotSRS ) {
CPLDebug( "gdalsrsinfo", "trying to open with OGR" );
poOGRDS = OGRSFDriverRegistrar::Open( pszInput, FALSE, NULL );
if( poOGRDS != NULL ) {
poLayer = poOGRDS->GetLayer( 0 );
if ( poLayer != NULL ) {
OGRSpatialReference *poSRS = poLayer->GetSpatialRef( );
if ( poSRS != NULL ) {
CPLDebug( "gdalsrsinfo", "got SRS from OGR" );
bGotSRS = TRUE;
OGRSpatialReference* poSRSClone = poSRS->Clone();
oSRS = *poSRSClone;
OGRSpatialReference::DestroySpatialReference( poSRSClone );
}
}
OGRDataSource::DestroyDataSource( poOGRDS );
poOGRDS = NULL;
}
if ( ! bGotSRS )
CPLDebug( "gdalsrsinfo", "did not open with OGR" );
}
#endif // OGR_ENABLED
/* Try ESRI file */
if ( ! bGotSRS && bIsFile && (strstr(pszInput,".prj") != NULL) ) {
CPLDebug( "gdalsrsinfo",
"trying to get SRS from ESRI .prj file [%s]", pszInput );
char **pszTemp;
if ( strstr(pszInput,"ESRI::") != NULL )
pszTemp = CSLLoad( pszInput+6 );
else
pszTemp = CSLLoad( pszInput );
if( pszTemp ) {
eErr = oSRS.importFromESRI( pszTemp );
CSLDestroy( pszTemp );
}
else
eErr = OGRERR_UNSUPPORTED_SRS;
if( eErr != OGRERR_NONE ) {
CPLDebug( "gdalsrsinfo", "did not get SRS from ESRI .prj file" );
}
else {
CPLDebug( "gdalsrsinfo", "got SRS from ESRI .prj file" );
bGotSRS = TRUE;
}
}
/* Last resort, try OSRSetFromUserInput() */
if ( ! bGotSRS ) {
CPLDebug( "gdalsrsinfo",
"trying to get SRS from user input [%s]", pszInput );
eErr = oSRS.SetFromUserInput( pszInput );
if( eErr != OGRERR_NONE ) {
CPLDebug( "gdalsrsinfo", "did not get SRS from user input" );
}
else {
CPLDebug( "gdalsrsinfo", "got SRS from user input" );
bGotSRS = TRUE;
}
}
/* restore error messages */
if ( ! bDebug )
CPLSetErrorHandler ( oErrorHandler );
return bGotSRS;
}
int main( int argc, char ** argv )
{
int i;
int bGotSRS = FALSE;
int bPretty = FALSE;
int bOutputAll = FALSE;
int bValidate = FALSE;
const char *pszInput = NULL;
const char *pszOutputType = "all";
char *pszOutput = NULL;
OGRSpatialReference oSRS;
VSILFILE *fp = NULL;
GDALDataset *poGDALDS = NULL;
OGRDataSource *poOGRDS = NULL;
OGRLayer *poLayer = NULL;
char *pszProjection = NULL;
int bDebug = FALSE;
CPLErrorHandler oErrorHandler = NULL;
int bIsFile = FALSE;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
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;
}
}
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
CPLDebug( "gdalsrsinfo", "got arg #%d : [%s]", i, argv[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], "-h") )
Usage();
else if( EQUAL(argv[i], "-o") && i < argc - 1)
pszOutputType = argv[++i];
else if( EQUAL(argv[i], "-p") )
bPretty = TRUE;
else if( EQUAL(argv[i], "-V") )
bValidate = TRUE;
else if( argv[i][0] == '-' )
{
CSLDestroy( argv );
Usage();
}
else
pszInput = argv[i];
}
if ( pszInput == NULL ) {
CSLDestroy( argv );
Usage();
}
/* Register drivers */
GDALAllRegister();
OGRRegisterAll();
/* Search for SRS */
/* temporarily supress error messages we may get from xOpen() */
bDebug = CSLTestBoolean(CPLGetConfigOption("CPL_DEBUG", "OFF"));
if ( ! bDebug )
oErrorHandler = CPLSetErrorHandler ( CPLQuietErrorHandler );
/* If argument is a file, try to open it with GDALOpen() and get the projection */
fp = VSIFOpenL( pszInput, "r" );
if ( fp ) {
bIsFile = TRUE;
VSIFCloseL( fp );
/* try to open with GDAL */
CPLDebug( "gdalsrsinfo", "trying to open with GDAL" );
poGDALDS = (GDALDataset *) GDALOpen( pszInput, GA_ReadOnly );
if ( poGDALDS != NULL && poGDALDS->GetProjectionRef( ) != NULL ) {
pszProjection = (char *) poGDALDS->GetProjectionRef( );
if( oSRS.importFromWkt( &pszProjection ) == CE_None ) {
CPLDebug( "gdalsrsinfo", "got SRS from GDAL" );
bGotSRS = TRUE;
}
GDALClose( (GDALDatasetH) poGDALDS );
}
if ( ! bGotSRS )
CPLDebug( "gdalsrsinfo", "did not open with GDAL" );
/* if unsuccessful, try to open with OGR */
if ( ! bGotSRS ) {
CPLDebug( "gdalsrsinfo", "trying to open with OGR" );
poOGRDS = OGRSFDriverRegistrar::Open( pszInput, FALSE, NULL );
if( poOGRDS != NULL ) {
poLayer = poOGRDS->GetLayer( 0 );
if ( poLayer != NULL ) {
OGRSpatialReference *poSRS = poLayer->GetSpatialRef( );
if ( poSRS != NULL ) {
CPLDebug( "gdalsrsinfo", "got SRS from OGR" );
bGotSRS = TRUE;
OGRSpatialReference* poSRSClone = poSRS->Clone();
oSRS = *poSRSClone;
OGRSpatialReference::DestroySpatialReference( poSRSClone );
}
}
OGRDataSource::DestroyDataSource( poOGRDS );
poOGRDS = NULL;
}
if ( ! bGotSRS )
CPLDebug( "gdalsrsinfo", "did not open with OGR" );
/* OGR_DS_Destroy( hOGRDS ); */
}
}
/* If didn't get the projection from the file, try OSRSetFromUserInput() */
/* File might not be a dataset, but contain projection info (e.g. .prf files) */
if ( ! bGotSRS ) {
CPLDebug( "gdalsrsinfo",
"trying to get SRS from user input [%s]", pszInput );
if( oSRS.SetFromUserInput( pszInput ) != OGRERR_NONE ) {
CPLDebug( "gdalsrsinfo", "did not get SRS from user input" );
}
else {
CPLDebug( "gdalsrsinfo", "got SRS from user input" );
bGotSRS = TRUE;
}
}
/* restore error messages */
if ( ! bDebug )
CPLSetErrorHandler ( oErrorHandler );
CPLDebug( "gdalsrsinfo",
"bGotSRS: %d bValidate: %d pszOutputType: %s bPretty: %d",
bGotSRS, bValidate, pszOutputType, bPretty );
/* Make sure we got a SRS */
if ( ! bGotSRS ) {
CPLError( CE_Failure, CPLE_AppDefined,
"ERROR - failed to load SRS definition from %s",
pszInput );
}
else {
/* Validate - not well tested!*/
if ( bValidate ) {
OGRErr eErr = oSRS.Validate( );
if ( eErr != OGRERR_NONE ) {
printf( "\nValidate Fails" );
if ( eErr == OGRERR_CORRUPT_DATA )
printf( " - SRS is not well formed");
else if ( eErr == OGRERR_UNSUPPORTED_SRS )
printf(" - contains non-standard PROJECTION[] values");
printf("\n");
}
else
printf( "\nValidate Succeeds\n" );
}
/* Output */
if ( EQUAL("all", pszOutputType ) ) {
bOutputAll = TRUE;
bPretty = TRUE;
}
printf("\n");
if ( bOutputAll || EQUAL("proj4", pszOutputType ) ) {
if ( bOutputAll ) printf("PROJ.4 : ");
oSRS.exportToProj4( &pszOutput );
printf("\'%s\'\n\n",pszOutput);
CPLFree( pszOutput );
}
if ( bOutputAll || EQUAL("wkt", pszOutputType ) ) {
if ( bOutputAll ) printf("OGC WKT :\n");
if ( bPretty )
oSRS.exportToPrettyWkt( &pszOutput, FALSE );
else
oSRS.exportToWkt( &pszOutput );
printf("%s\n\n",pszOutput);
CPLFree( pszOutput );
}
if ( bOutputAll || EQUAL("wkt_simple", pszOutputType ) ) {
if ( bOutputAll ) printf("OGC WKT (simple) :\n");
oSRS.exportToPrettyWkt( &pszOutput, TRUE );
printf("%s\n\n",pszOutput);
CPLFree( pszOutput );
}
if ( EQUAL("wkt_old", pszOutputType ) ) {
if ( bOutputAll ) printf("OGC WKT (old) :\n");
oSRS.StripCTParms( );
if ( bPretty )
oSRS.exportToPrettyWkt( &pszOutput, FALSE );
else
oSRS.exportToWkt( &pszOutput );
printf("%s\n\n",pszOutput);
CPLFree( pszOutput );
}
if ( bOutputAll || EQUAL("wkt_esri", pszOutputType ) ) {
if ( bOutputAll ) printf("ESRI WKT :\n");
OGRSpatialReference *poSRS = oSRS.Clone();
poSRS->morphToESRI( );
if ( bPretty )
poSRS->exportToPrettyWkt( &pszOutput, FALSE );
else
poSRS->exportToWkt( &pszOutput );
printf("%s\n\n",pszOutput);
CPLFree( pszOutput );
OGRSpatialReference::DestroySpatialReference( poSRS );
}
/* mapinfo and xml are not output with "all" */
if ( EQUAL("mapinfo", pszOutputType ) ) {
if ( bOutputAll ) printf("MAPINFO : ");
oSRS.exportToMICoordSys( &pszOutput );
printf("\'%s\'\n\n",pszOutput);
CPLFree( pszOutput );
}
if ( EQUAL("xml", pszOutputType ) ) {
if ( bOutputAll ) printf("XML :\n");
oSRS.exportToXML( &pszOutput, NULL );
printf("%s\n\n",pszOutput);
CPLFree( pszOutput );
}
}
/* cleanup anything left */
GDALDestroyDriverManager();
OGRCleanupAll();
CSLDestroy( argv );
return 0;
}
static int ProxyMain(int argc, char **argv)
{
GDALDatasetH hDataset, hOutDS;
int i;
int nRasterXSize, nRasterYSize;
const char *pszSource = NULL, *pszDest = NULL, *pszFormat = "GTiff";
GDALDriverH hDriver;
int *panBandList = NULL; /* negative value of panBandList[i] means mask band of ABS(panBandList[i]) */
int nBandCount = 0, bDefBands = TRUE;
double adfGeoTransform[6];
GDALDataType eOutputType = GDT_Unknown;
int nOXSize = 0, nOYSize = 0;
char *pszOXSize = NULL, *pszOYSize = NULL;
char **papszCreateOptions = NULL;
int anSrcWin[4], bStrict = FALSE;
const char *pszProjection;
int bScale = FALSE, bHaveScaleSrc = FALSE, bUnscale = FALSE;
double dfScaleSrcMin = 0.0, dfScaleSrcMax = 255.0;
double dfScaleDstMin = 0.0, dfScaleDstMax = 255.0;
double dfULX, dfULY, dfLRX, dfLRY;
char **papszMetadataOptions = NULL;
char *pszOutputSRS = NULL;
int bQuiet = FALSE, bGotBounds = FALSE;
GDALProgressFunc pfnProgress = GDALTermProgress;
int nGCPCount = 0;
GDAL_GCP *pasGCPs = NULL;
int iSrcFileArg = -1, iDstFileArg = -1;
int bCopySubDatasets = FALSE;
double adfULLR[4] = { 0, 0, 0, 0 };
int bSetNoData = FALSE;
int bUnsetNoData = FALSE;
double dfNoDataReal = 0.0;
int nRGBExpand = 0;
int bParsedMaskArgument = FALSE;
int eMaskMode = MASK_AUTO;
int nMaskBand = 0; /* negative value means mask band of ABS(nMaskBand) */
int bStats = FALSE, bApproxStats = FALSE;
anSrcWin[0] = 0;
anSrcWin[1] = 0;
anSrcWin[2] = 0;
anSrcWin[3] = 0;
dfULX = dfULY = dfLRX = dfLRY = 0.0;
/* Check strict compilation and runtime library version as we use C++ API */
if (!GDAL_CHECK_VERSION(argv[0]))
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;
}
}
/* -------------------------------------------------------------------- */
/* 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];
else if (EQUAL(argv[i], "-q") || EQUAL(argv[i], "-quiet"))
{
bQuiet = TRUE;
pfnProgress = GDALDummyProgress;
}
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();
GDALDestroyDriverManager();
exit(2);
}
i++;
}
else if (EQUAL(argv[i], "-b") && i < argc - 1)
{
const char *pszBand = argv[i + 1];
int bMask = FALSE;
if (EQUAL(pszBand, "mask"))
pszBand = "mask,1";
if (EQUALN(pszBand, "mask,", 5))
{
bMask = TRUE;
pszBand += 5;
/* If we use tha source mask band as a regular band */
/* don't create a target mask band by default */
if (!bParsedMaskArgument)
eMaskMode = MASK_DISABLED;
}
int nBand = atoi(pszBand);
if (nBand < 1)
{
printf("Unrecognizable band number (%s).\n", argv[i + 1]);
Usage();
GDALDestroyDriverManager();
exit(2);
}
i++;
nBandCount++;
panBandList = (int*)
CPLRealloc(panBandList, sizeof(int) * nBandCount);
panBandList[nBandCount - 1] = nBand;
if (bMask)
panBandList[nBandCount - 1] *= -1;
if (panBandList[nBandCount - 1] != nBandCount)
bDefBands = FALSE;
}
else if (EQUAL(argv[i], "-mask") && i < argc - 1)
{
bParsedMaskArgument = TRUE;
const char *pszBand = argv[i + 1];
if (EQUAL(pszBand, "none"))
{
eMaskMode = MASK_DISABLED;
}
else if (EQUAL(pszBand, "auto"))
{
eMaskMode = MASK_AUTO;
}
else
{
int bMask = FALSE;
if (EQUAL(pszBand, "mask"))
pszBand = "mask,1";
if (EQUALN(pszBand, "mask,", 5))
{
bMask = TRUE;
pszBand += 5;
}
int nBand = atoi(pszBand);
if (nBand < 1)
{
printf("Unrecognizable band number (%s).\n", argv[i + 1]);
Usage();
GDALDestroyDriverManager();
exit(2);
}
eMaskMode = MASK_USER;
nMaskBand = nBand;
if (bMask)
nMaskBand *= -1;
}
i++;
}
else if (EQUAL(argv[i], "-not_strict"))
bStrict = FALSE;
else if (EQUAL(argv[i], "-strict"))
bStrict = TRUE;
else if (EQUAL(argv[i], "-sds"))
bCopySubDatasets = TRUE;
else if (EQUAL(argv[i], "-gcp") && i < argc - 4)
{
char *endptr = NULL;
/* -gcp pixel line easting northing [elev] */
nGCPCount++;
pasGCPs = (GDAL_GCP*)
CPLRealloc(pasGCPs, sizeof(GDAL_GCP) * nGCPCount);
GDALInitGCPs(1, pasGCPs + nGCPCount - 1);
pasGCPs[nGCPCount - 1].dfGCPPixel = CPLAtofM(argv[++i]);
pasGCPs[nGCPCount - 1].dfGCPLine = CPLAtofM(argv[++i]);
pasGCPs[nGCPCount - 1].dfGCPX = CPLAtofM(argv[++i]);
pasGCPs[nGCPCount - 1].dfGCPY = CPLAtofM(argv[++i]);
if (argv[i + 1] != NULL
&& (CPLStrtod(argv[i + 1], &endptr) != 0.0 || argv[i + 1][0] == '0'))
{
/* Check that last argument is really a number and not a filename */
/* looking like a number (see ticket #863) */
if (endptr && *endptr == 0)
pasGCPs[nGCPCount - 1].dfGCPZ = CPLAtofM(argv[++i]);
}
/* should set id and info? */
}
else if (EQUAL(argv[i], "-a_nodata") && i < argc - 1)
{
if (EQUAL(argv[i + 1], "none"))
{
bUnsetNoData = TRUE;
}
else
{
bSetNoData = TRUE;
dfNoDataReal = CPLAtofM(argv[i + 1]);
}
i += 1;
}
else if (EQUAL(argv[i], "-a_ullr") && i < argc - 4)
{
adfULLR[0] = CPLAtofM(argv[i + 1]);
adfULLR[1] = CPLAtofM(argv[i + 2]);
adfULLR[2] = CPLAtofM(argv[i + 3]);
adfULLR[3] = CPLAtofM(argv[i + 4]);
bGotBounds = TRUE;
i += 4;
}
else if (EQUAL(argv[i], "-co") && i < argc - 1)
{
papszCreateOptions = CSLAddString(papszCreateOptions, argv[++i]);
}
else if (EQUAL(argv[i], "-scale"))
{
bScale = TRUE;
if (i < argc - 2 && ArgIsNumeric(argv[i + 1]))
{
bHaveScaleSrc = TRUE;
dfScaleSrcMin = CPLAtofM(argv[i + 1]);
dfScaleSrcMax = CPLAtofM(argv[i + 2]);
i += 2;
}
if (i < argc - 2 && bHaveScaleSrc && ArgIsNumeric(argv[i + 1]))
{
dfScaleDstMin = CPLAtofM(argv[i + 1]);
dfScaleDstMax = CPLAtofM(argv[i + 2]);
i += 2;
}
else
{
dfScaleDstMin = 0.0;
dfScaleDstMax = 255.999;
}
}
else if (EQUAL(argv[i], "-unscale"))
{
bUnscale = TRUE;
}
else if (EQUAL(argv[i], "-mo") && i < argc - 1)
{
papszMetadataOptions = CSLAddString(papszMetadataOptions,
argv[++i]);
}
else if (EQUAL(argv[i], "-outsize") && i < argc - 2)
{
pszOXSize = argv[++i];
pszOYSize = argv[++i];
}
else if (EQUAL(argv[i], "-srcwin") && i < argc - 4)
{
anSrcWin[0] = atoi(argv[++i]);
anSrcWin[1] = atoi(argv[++i]);
anSrcWin[2] = atoi(argv[++i]);
anSrcWin[3] = atoi(argv[++i]);
}
else if (EQUAL(argv[i], "-projwin") && i < argc - 4)
{
dfULX = CPLAtofM(argv[++i]);
dfULY = CPLAtofM(argv[++i]);
dfLRX = CPLAtofM(argv[++i]);
dfLRY = CPLAtofM(argv[++i]);
}
else if (EQUAL(argv[i], "-a_srs") && i < argc - 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], "-expand") && i < argc - 1)
{
if (EQUAL(argv[i + 1], "gray"))
nRGBExpand = 1;
else if (EQUAL(argv[i + 1], "rgb"))
nRGBExpand = 3;
else if (EQUAL(argv[i + 1], "rgba"))
nRGBExpand = 4;
else
{
printf("Value %s unsupported. Only gray, rgb or rgba are supported.\n\n",
argv[i]);
Usage();
GDALDestroyDriverManager();
exit(2);
}
i++;
}
else if (EQUAL(argv[i], "-stats"))
{
bStats = TRUE;
bApproxStats = FALSE;
}
else if (EQUAL(argv[i], "-approx_stats"))
{
bStats = TRUE;
bApproxStats = TRUE;
}
else if (argv[i][0] == '-')
{
printf("Option %s incomplete, or not recognised.\n\n",
argv[i]);
Usage();
GDALDestroyDriverManager();
exit(2);
}
else if (pszSource == NULL)
{
iSrcFileArg = i;
pszSource = argv[i];
}
else if (pszDest == NULL)
{
pszDest = argv[i];
iDstFileArg = i;
}
else
{
printf("Too many command options.\n\n");
Usage();
GDALDestroyDriverManager();
exit(2);
}
}
if (pszDest == NULL)
{
Usage();
GDALDestroyDriverManager();
exit(10);
}
if (strcmp(pszSource, pszDest) == 0)
{
fprintf(stderr, "Source and destination datasets must be different.\n");
GDALDestroyDriverManager();
exit(1);
}
if (strcmp(pszDest, "/vsistdout/") == 0)
{
bQuiet = TRUE;
pfnProgress = GDALDummyProgress;
}
/* -------------------------------------------------------------------- */
/* 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);
}
/* -------------------------------------------------------------------- */
/* Handle subdatasets. */
/* -------------------------------------------------------------------- */
if (!bCopySubDatasets
&& CSLCount(GDALGetMetadata(hDataset, "SUBDATASETS")) > 0
&& GDALGetRasterCount(hDataset) == 0)
{
fprintf(stderr,
"Input file contains subdatasets. Please, select one of them for reading.\n");
GDALClose(hDataset);
GDALDestroyDriverManager();
exit(1);
}
if (CSLCount(GDALGetMetadata(hDataset, "SUBDATASETS")) > 0
&& bCopySubDatasets)
{
char **papszSubdatasets = GDALGetMetadata(hDataset, "SUBDATASETS");
char *pszSubDest = (char*) CPLMalloc(strlen(pszDest) + 32);
int i;
int bOldSubCall = bSubCall;
char **papszDupArgv = CSLDuplicate(argv);
int nRet = 0;
CPLFree(papszDupArgv[iDstFileArg]);
papszDupArgv[iDstFileArg] = pszSubDest;
bSubCall = TRUE;
for (i = 0; papszSubdatasets[i] != NULL; i += 2)
{
CPLFree(papszDupArgv[iSrcFileArg]);
papszDupArgv[iSrcFileArg] = CPLStrdup(strstr(papszSubdatasets[i], "=") + 1);
sprintf(pszSubDest, "%s%d", pszDest, i / 2 + 1);
nRet = ProxyMain(argc, papszDupArgv);
if (nRet != 0)
break;
}
CSLDestroy(papszDupArgv);
bSubCall = bOldSubCall;
CSLDestroy(argv);
GDALClose(hDataset);
if (!bSubCall)
{
GDALDumpOpenDatasets(stderr);
GDALDestroyDriverManager();
}
return nRet;
}
/* -------------------------------------------------------------------- */
/* Collect some information from the source file. */
/* -------------------------------------------------------------------- */
nRasterXSize = GDALGetRasterXSize(hDataset);
nRasterYSize = GDALGetRasterYSize(hDataset);
if (!bQuiet)
printf("Input file size is %d, %d\n", nRasterXSize, nRasterYSize);
if (anSrcWin[2] == 0 && anSrcWin[3] == 0)
{
anSrcWin[2] = nRasterXSize;
anSrcWin[3] = nRasterYSize;
}
/* -------------------------------------------------------------------- */
/* Build band list to translate */
/* -------------------------------------------------------------------- */
if (nBandCount == 0)
{
nBandCount = GDALGetRasterCount(hDataset);
if (nBandCount == 0)
{
fprintf(stderr, "Input file has no bands, and so cannot be translated.\n");
GDALDestroyDriverManager();
exit(1);
}
panBandList = (int*) CPLMalloc(sizeof(int) * nBandCount);
for (i = 0; i < nBandCount; i++)
panBandList[i] = i + 1;
}
else
{
for (i = 0; i < nBandCount; i++)
{
if (ABS(panBandList[i]) > GDALGetRasterCount(hDataset))
{
fprintf(stderr,
"Band %d requested, but only bands 1 to %d available.\n",
ABS(panBandList[i]), GDALGetRasterCount(hDataset));
GDALDestroyDriverManager();
exit(2);
}
}
if (nBandCount != GDALGetRasterCount(hDataset))
bDefBands = FALSE;
}
/* -------------------------------------------------------------------- */
/* Compute the source window from the projected source window */
/* if the projected coordinates were provided. Note that the */
/* projected coordinates are in ulx, uly, lrx, lry format, */
/* while the anSrcWin is xoff, yoff, xsize, ysize with the */
/* xoff,yoff being the ulx, uly in pixel/line. */
/* -------------------------------------------------------------------- */
if (dfULX != 0.0 || dfULY != 0.0
|| dfLRX != 0.0 || dfLRY != 0.0)
{
double adfGeoTransform[6];
GDALGetGeoTransform(hDataset, adfGeoTransform);
if (adfGeoTransform[2] != 0.0 || adfGeoTransform[4] != 0.0)
{
fprintf(stderr,
"The -projwin option was used, but the geotransform is\n"
"rotated. This configuration is not supported.\n");
GDALClose(hDataset);
CPLFree(panBandList);
GDALDestroyDriverManager();
exit(1);
}
anSrcWin[0] = (int)
((dfULX - adfGeoTransform[0]) / adfGeoTransform[1] + 0.001);
anSrcWin[1] = (int)
((dfULY - adfGeoTransform[3]) / adfGeoTransform[5] + 0.001);
anSrcWin[2] = (int) ((dfLRX - dfULX) / adfGeoTransform[1] + 0.5);
anSrcWin[3] = (int) ((dfLRY - dfULY) / adfGeoTransform[5] + 0.5);
if (!bQuiet)
fprintf(stdout,
"Computed -srcwin %d %d %d %d from projected window.\n",
anSrcWin[0],
anSrcWin[1],
anSrcWin[2],
anSrcWin[3]);
if (anSrcWin[0] < 0 || anSrcWin[1] < 0
|| anSrcWin[0] + anSrcWin[2] > GDALGetRasterXSize(hDataset)
|| anSrcWin[1] + anSrcWin[3] > GDALGetRasterYSize(hDataset))
{
fprintf(stderr,
"Computed -srcwin falls outside raster size of %dx%d.\n",
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset));
exit(1);
}
}
/* -------------------------------------------------------------------- */
/* Verify source window. */
/* -------------------------------------------------------------------- */
if (anSrcWin[0] < 0 || anSrcWin[1] < 0
|| anSrcWin[2] <= 0 || anSrcWin[3] <= 0
|| anSrcWin[0] + anSrcWin[2] > GDALGetRasterXSize(hDataset)
|| anSrcWin[1] + anSrcWin[3] > GDALGetRasterYSize(hDataset))
{
fprintf(stderr,
"-srcwin %d %d %d %d falls outside raster size of %dx%d\n"
"or is otherwise illegal.\n",
anSrcWin[0],
anSrcWin[1],
anSrcWin[2],
anSrcWin[3],
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset));
exit(1);
}
/* -------------------------------------------------------------------- */
/* 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++)
{
GDALDriverH hDriver = GDALGetDriver(iDr);
if (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();
GDALClose(hDataset);
CPLFree(panBandList);
GDALDestroyDriverManager();
CSLDestroy(argv);
CSLDestroy(papszCreateOptions);
exit(1);
}
/* -------------------------------------------------------------------- */
/* The short form is to CreateCopy(). We use this if the input */
/* matches the whole dataset. Eventually we should rewrite */
/* this entire program to use virtual datasets to construct a */
/* virtual input source to copy from. */
/* -------------------------------------------------------------------- */
int bSpatialArrangementPreserved = (
anSrcWin[0] == 0 && anSrcWin[1] == 0
&& anSrcWin[2] == GDALGetRasterXSize(hDataset)
&& anSrcWin[3] == GDALGetRasterYSize(hDataset)
&& pszOXSize == NULL && pszOYSize == NULL);
if (eOutputType == GDT_Unknown
&& !bScale && !bUnscale
&& CSLCount(papszMetadataOptions) == 0 && bDefBands
&& eMaskMode == MASK_AUTO
&& bSpatialArrangementPreserved
&& nGCPCount == 0 && !bGotBounds
&& pszOutputSRS == NULL && !bSetNoData && !bUnsetNoData
&& nRGBExpand == 0 && !bStats)
{
hOutDS = GDALCreateCopy(hDriver, pszDest, hDataset,
bStrict, papszCreateOptions,
pfnProgress, NULL);
if (hOutDS != NULL)
GDALClose(hOutDS);
GDALClose(hDataset);
CPLFree(panBandList);
if (!bSubCall)
{
GDALDumpOpenDatasets(stderr);
GDALDestroyDriverManager();
}
CSLDestroy(argv);
CSLDestroy(papszCreateOptions);
return hOutDS == NULL;
}
/* -------------------------------------------------------------------- */
/* Establish some parameters. */
/* -------------------------------------------------------------------- */
if (pszOXSize == NULL)
{
nOXSize = anSrcWin[2];
nOYSize = anSrcWin[3];
}
else
{
nOXSize = (int) ((pszOXSize[strlen(pszOXSize) - 1] == '%'
? CPLAtofM(pszOXSize) / 100 * anSrcWin[2] : atoi(pszOXSize)));
nOYSize = (int) ((pszOYSize[strlen(pszOYSize) - 1] == '%'
? CPLAtofM(pszOYSize) / 100 * anSrcWin[3] : atoi(pszOYSize)));
}
/* ==================================================================== */
/* Create a virtual dataset. */
/* ==================================================================== */
VRTDataset *poVDS;
/* -------------------------------------------------------------------- */
/* Make a virtual clone. */
/* -------------------------------------------------------------------- */
poVDS = (VRTDataset*) VRTCreate(nOXSize, nOYSize);
if (nGCPCount == 0)
{
if (pszOutputSRS != NULL)
{
poVDS->SetProjection(pszOutputSRS);
}
else
{
pszProjection = GDALGetProjectionRef(hDataset);
if (pszProjection != NULL && strlen(pszProjection) > 0)
poVDS->SetProjection(pszProjection);
}
}
if (bGotBounds)
{
adfGeoTransform[0] = adfULLR[0];
adfGeoTransform[1] = (adfULLR[2] - adfULLR[0]) / nOXSize;
adfGeoTransform[2] = 0.0;
adfGeoTransform[3] = adfULLR[1];
adfGeoTransform[4] = 0.0;
adfGeoTransform[5] = (adfULLR[3] - adfULLR[1]) / nOYSize;
poVDS->SetGeoTransform(adfGeoTransform);
}
else if (GDALGetGeoTransform(hDataset, adfGeoTransform) == CE_None
&& nGCPCount == 0)
{
adfGeoTransform[0] += anSrcWin[0] * adfGeoTransform[1]
+ anSrcWin[1] * adfGeoTransform[2];
adfGeoTransform[3] += anSrcWin[0] * adfGeoTransform[4]
+ anSrcWin[1] * adfGeoTransform[5];
adfGeoTransform[1] *= anSrcWin[2] / (double) nOXSize;
adfGeoTransform[2] *= anSrcWin[3] / (double) nOYSize;
adfGeoTransform[4] *= anSrcWin[2] / (double) nOXSize;
adfGeoTransform[5] *= anSrcWin[3] / (double) nOYSize;
poVDS->SetGeoTransform(adfGeoTransform);
}
if (nGCPCount != 0)
{
const char *pszGCPProjection = pszOutputSRS;
if (pszGCPProjection == NULL)
pszGCPProjection = GDALGetGCPProjection(hDataset);
if (pszGCPProjection == NULL)
pszGCPProjection = "";
poVDS->SetGCPs(nGCPCount, pasGCPs, pszGCPProjection);
GDALDeinitGCPs(nGCPCount, pasGCPs);
CPLFree(pasGCPs);
}
else if (GDALGetGCPCount(hDataset) > 0)
{
GDAL_GCP *pasGCPs;
int nGCPs = GDALGetGCPCount(hDataset);
pasGCPs = GDALDuplicateGCPs(nGCPs, GDALGetGCPs(hDataset));
for (i = 0; i < nGCPs; i++)
{
pasGCPs[i].dfGCPPixel -= anSrcWin[0];
pasGCPs[i].dfGCPLine -= anSrcWin[1];
pasGCPs[i].dfGCPPixel *= (nOXSize / (double) anSrcWin[2]);
pasGCPs[i].dfGCPLine *= (nOYSize / (double) anSrcWin[3]);
}
poVDS->SetGCPs(nGCPs, pasGCPs,
GDALGetGCPProjection(hDataset));
GDALDeinitGCPs(nGCPs, pasGCPs);
CPLFree(pasGCPs);
}
/* -------------------------------------------------------------------- */
/* Transfer generally applicable metadata. */
/* -------------------------------------------------------------------- */
poVDS->SetMetadata(((GDALDataset*)hDataset)->GetMetadata());
AttachMetadata((GDALDatasetH) poVDS, papszMetadataOptions);
const char *pszInterleave = GDALGetMetadataItem(hDataset, "INTERLEAVE", "IMAGE_STRUCTURE");
if (pszInterleave)
poVDS->SetMetadataItem("INTERLEAVE", pszInterleave, "IMAGE_STRUCTURE");
/* -------------------------------------------------------------------- */
/* Transfer metadata that remains valid if the spatial */
/* arrangement of the data is unaltered. */
/* -------------------------------------------------------------------- */
if (bSpatialArrangementPreserved)
{
char **papszMD;
papszMD = ((GDALDataset*)hDataset)->GetMetadata("RPC");
if (papszMD != NULL)
poVDS->SetMetadata(papszMD, "RPC");
papszMD = ((GDALDataset*)hDataset)->GetMetadata("GEOLOCATION");
if (papszMD != NULL)
poVDS->SetMetadata(papszMD, "GEOLOCATION");
}
int nSrcBandCount = nBandCount;
if (nRGBExpand != 0)
{
GDALRasterBand *poSrcBand;
poSrcBand = ((GDALDataset*)
hDataset)->GetRasterBand(ABS(panBandList[0]));
if (panBandList[0] < 0)
poSrcBand = poSrcBand->GetMaskBand();
GDALColorTable *poColorTable = poSrcBand->GetColorTable();
if (poColorTable == NULL)
{
fprintf(stderr, "Error : band %d has no color table\n", ABS(panBandList[0]));
GDALClose(hDataset);
CPLFree(panBandList);
GDALDestroyDriverManager();
CSLDestroy(argv);
CSLDestroy(papszCreateOptions);
exit(1);
}
/* Check that the color table only contains gray levels */
/* when using -expand gray */
if (nRGBExpand == 1)
{
int nColorCount = poColorTable->GetColorEntryCount();
int nColor;
for (nColor = 0; nColor < nColorCount; nColor++)
{
const GDALColorEntry *poEntry = poColorTable->GetColorEntry(nColor);
if (poEntry->c1 != poEntry->c2 || poEntry->c1 != poEntry->c2)
{
fprintf(stderr, "Warning : color table contains non gray levels colors\n");
break;
}
}
}
if (nBandCount == 1)
nBandCount = nRGBExpand;
else if (nBandCount == 2 && (nRGBExpand == 3 || nRGBExpand == 4))
nBandCount = nRGBExpand;
else
{
fprintf(stderr, "Error : invalid use of -expand option.\n");
exit(1);
}
}
int bFilterOutStatsMetadata =
(bScale || bUnscale || !bSpatialArrangementPreserved || nRGBExpand != 0);
/* ==================================================================== */
/* Process all bands. */
/* ==================================================================== */
for (i = 0; i < nBandCount; i++)
{
VRTSourcedRasterBand *poVRTBand;
GDALRasterBand *poSrcBand;
GDALDataType eBandType;
int nComponent = 0;
int nSrcBand;
if (nRGBExpand != 0)
{
if (nSrcBandCount == 2 && nRGBExpand == 4 && i == 3)
nSrcBand = panBandList[1];
else
{
nSrcBand = panBandList[0];
nComponent = i + 1;
}
}
else
nSrcBand = panBandList[i];
poSrcBand = ((GDALDataset*) hDataset)->GetRasterBand(ABS(nSrcBand));
/* -------------------------------------------------------------------- */
/* Select output data type to match source. */
/* -------------------------------------------------------------------- */
if (eOutputType == GDT_Unknown)
eBandType = poSrcBand->GetRasterDataType();
else
eBandType = eOutputType;
/* -------------------------------------------------------------------- */
/* Create this band. */
/* -------------------------------------------------------------------- */
poVDS->AddBand(eBandType, NULL);
poVRTBand = (VRTSourcedRasterBand*) poVDS->GetRasterBand(i + 1);
if (nSrcBand < 0)
{
poVRTBand->AddMaskBandSource(poSrcBand);
continue;
}
/* -------------------------------------------------------------------- */
/* Do we need to collect scaling information? */
/* -------------------------------------------------------------------- */
double dfScale = 1.0, dfOffset = 0.0;
if (bScale && !bHaveScaleSrc)
{
double adfCMinMax[2];
GDALComputeRasterMinMax(poSrcBand, TRUE, adfCMinMax);
dfScaleSrcMin = adfCMinMax[0];
dfScaleSrcMax = adfCMinMax[1];
}
if (bScale)
{
if (dfScaleSrcMax == dfScaleSrcMin)
dfScaleSrcMax += 0.1;
if (dfScaleDstMax == dfScaleDstMin)
dfScaleDstMax += 0.1;
dfScale = (dfScaleDstMax - dfScaleDstMin)
/ (dfScaleSrcMax - dfScaleSrcMin);
dfOffset = -1 * dfScaleSrcMin * dfScale + dfScaleDstMin;
}
if (bUnscale)
{
dfScale = poSrcBand->GetScale();
dfOffset = poSrcBand->GetOffset();
}
/* -------------------------------------------------------------------- */
/* Create a simple or complex data source depending on the */
/* translation type required. */
/* -------------------------------------------------------------------- */
if (bUnscale || bScale || (nRGBExpand != 0 && i < nRGBExpand))
{
poVRTBand->AddComplexSource(poSrcBand,
anSrcWin[0], anSrcWin[1],
anSrcWin[2], anSrcWin[3],
0, 0, nOXSize, nOYSize,
dfOffset, dfScale,
VRT_NODATA_UNSET,
nComponent);
}
else
poVRTBand->AddSimpleSource(poSrcBand,
anSrcWin[0], anSrcWin[1],
anSrcWin[2], anSrcWin[3],
0, 0, nOXSize, nOYSize);
/* -------------------------------------------------------------------- */
/* In case of color table translate, we only set the color */
/* interpretation other info copied by CopyBandInfo are */
/* not relevant in RGB expansion. */
/* -------------------------------------------------------------------- */
if (nRGBExpand == 1)
{
poVRTBand->SetColorInterpretation(GCI_GrayIndex);
}
else if (nRGBExpand != 0 && i < nRGBExpand)
{
poVRTBand->SetColorInterpretation((GDALColorInterp) (GCI_RedBand + i));
}
/* -------------------------------------------------------------------- */
/* copy over some other information of interest. */
/* -------------------------------------------------------------------- */
else
{
CopyBandInfo(poSrcBand, poVRTBand,
!bStats && !bFilterOutStatsMetadata,
!bUnscale,
!bSetNoData && !bUnsetNoData);
}
/* -------------------------------------------------------------------- */
/* Set a forcable nodata value? */
/* -------------------------------------------------------------------- */
if (bSetNoData)
{
double dfVal = dfNoDataReal;
int bClamped = FALSE, bRounded = FALSE;
#define CLAMP(val, type, minval, maxval) \
do { if (val < minval) { bClamped = TRUE; val = minval; \
} \
else if (val > maxval) { bClamped = TRUE; val = maxval; } \
else if (val != (type)val) { bRounded = TRUE; val = (type)(val + 0.5); } \
} \
while (0)
switch (eBandType)
{
case GDT_Byte:
CLAMP(dfVal, GByte, 0.0, 255.0);
break;
case GDT_Int16:
CLAMP(dfVal, GInt16, -32768.0, 32767.0);
break;
case GDT_UInt16:
CLAMP(dfVal, GUInt16, 0.0, 65535.0);
break;
case GDT_Int32:
CLAMP(dfVal, GInt32, -2147483648.0, 2147483647.0);
break;
case GDT_UInt32:
CLAMP(dfVal, GUInt32, 0.0, 4294967295.0);
break;
default:
break;
}
if (bClamped)
{
printf("for band %d, nodata value has been clamped "
"to %.0f, the original value being out of range.\n",
i + 1, dfVal);
}
else if (bRounded)
{
printf("for band %d, nodata value has been rounded "
"to %.0f, %s being an integer datatype.\n",
i + 1, dfVal,
GDALGetDataTypeName(eBandType));
}
poVRTBand->SetNoDataValue(dfVal);
}
if (eMaskMode == MASK_AUTO &&
(GDALGetMaskFlags(GDALGetRasterBand(hDataset, 1)) & GMF_PER_DATASET) == 0 &&
(poSrcBand->GetMaskFlags() & (GMF_ALL_VALID | GMF_NODATA)) == 0)
{
if (poVRTBand->CreateMaskBand(poSrcBand->GetMaskFlags()) == CE_None)
{
VRTSourcedRasterBand *hMaskVRTBand =
(VRTSourcedRasterBand*)poVRTBand->GetMaskBand();
hMaskVRTBand->AddMaskBandSource(poSrcBand,
anSrcWin[0], anSrcWin[1],
anSrcWin[2], anSrcWin[3],
0, 0, nOXSize, nOYSize);
}
}
}
if (eMaskMode == MASK_USER)
{
GDALRasterBand *poSrcBand =
(GDALRasterBand*)GDALGetRasterBand(hDataset, ABS(nMaskBand));
if (poSrcBand && poVDS->CreateMaskBand(GMF_PER_DATASET) == CE_None)
{
VRTSourcedRasterBand *hMaskVRTBand = (VRTSourcedRasterBand*)
GDALGetMaskBand(GDALGetRasterBand((GDALDatasetH)poVDS, 1));
if (nMaskBand > 0)
hMaskVRTBand->AddSimpleSource(poSrcBand,
anSrcWin[0], anSrcWin[1],
anSrcWin[2], anSrcWin[3],
0, 0, nOXSize, nOYSize);
else
hMaskVRTBand->AddMaskBandSource(poSrcBand,
anSrcWin[0], anSrcWin[1],
anSrcWin[2], anSrcWin[3],
0, 0, nOXSize, nOYSize);
}
}
else if (eMaskMode == MASK_AUTO && nSrcBandCount > 0 &&
GDALGetMaskFlags(GDALGetRasterBand(hDataset, 1)) == GMF_PER_DATASET)
{
if (poVDS->CreateMaskBand(GMF_PER_DATASET) == CE_None)
{
VRTSourcedRasterBand *hMaskVRTBand = (VRTSourcedRasterBand*)
GDALGetMaskBand(GDALGetRasterBand((GDALDatasetH)poVDS, 1));
hMaskVRTBand->AddMaskBandSource((GDALRasterBand*)GDALGetRasterBand(hDataset, 1),
anSrcWin[0], anSrcWin[1],
anSrcWin[2], anSrcWin[3],
0, 0, nOXSize, nOYSize);
}
}
/* -------------------------------------------------------------------- */
/* Compute stats if required. */
/* -------------------------------------------------------------------- */
if (bStats)
{
for (i = 0; i < poVDS->GetRasterCount(); i++)
{
double dfMin, dfMax, dfMean, dfStdDev;
poVDS->GetRasterBand(i + 1)->ComputeStatistics(bApproxStats,
&dfMin, &dfMax, &dfMean, &dfStdDev, GDALDummyProgress, NULL);
}
}
/* -------------------------------------------------------------------- */
/* Write to the output file using CopyCreate(). */
/* -------------------------------------------------------------------- */
hOutDS = GDALCreateCopy(hDriver, pszDest, (GDALDatasetH) poVDS,
bStrict, papszCreateOptions,
pfnProgress, NULL);
if (hOutDS != NULL)
{
int bHasGotErr = FALSE;
CPLErrorReset();
GDALFlushCache(hOutDS);
if (CPLGetLastErrorType() != CE_None)
bHasGotErr = TRUE;
GDALClose(hOutDS);
if (bHasGotErr)
hOutDS = NULL;
}
GDALClose((GDALDatasetH) poVDS);
GDALClose(hDataset);
CPLFree(panBandList);
CPLFree(pszOutputSRS);
if (!bSubCall)
{
GDALDumpOpenDatasets(stderr);
GDALDestroyDriverManager();
}
CSLDestroy(argv);
CSLDestroy(papszCreateOptions);
return hOutDS == NULL;
}
CPLErr GDALPamDataset::XMLInit( CPLXMLNode *psTree, const char *pszVRTPath )
{
/* -------------------------------------------------------------------- */
/* Check for an SRS node. */
/* -------------------------------------------------------------------- */
if( strlen(CPLGetXMLValue(psTree, "SRS", "")) > 0 )
{
OGRSpatialReference oSRS;
CPLFree( psPam->pszProjection );
psPam->pszProjection = NULL;
if( oSRS.SetFromUserInput( CPLGetXMLValue(psTree, "SRS", "") )
== OGRERR_NONE )
oSRS.exportToWkt( &(psPam->pszProjection) );
}
/* -------------------------------------------------------------------- */
/* Check for a GeoTransform node. */
/* -------------------------------------------------------------------- */
if( strlen(CPLGetXMLValue(psTree, "GeoTransform", "")) > 0 )
{
const char *pszGT = CPLGetXMLValue(psTree, "GeoTransform", "");
char **papszTokens;
papszTokens = CSLTokenizeStringComplex( pszGT, ",", FALSE, FALSE );
if( CSLCount(papszTokens) != 6 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"GeoTransform node does not have expected six values.");
}
else
{
for( int iTA = 0; iTA < 6; iTA++ )
psPam->adfGeoTransform[iTA] = atof(papszTokens[iTA]);
psPam->bHaveGeoTransform = TRUE;
}
CSLDestroy( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Check for GCPs. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psGCPList = CPLGetXMLNode( psTree, "GCPList" );
if( psGCPList != NULL )
{
CPLXMLNode *psXMLGCP;
OGRSpatialReference oSRS;
const char *pszRawProj = CPLGetXMLValue(psGCPList, "Projection", "");
CPLFree( psPam->pszGCPProjection );
if( strlen(pszRawProj) > 0
&& oSRS.SetFromUserInput( pszRawProj ) == OGRERR_NONE )
oSRS.exportToWkt( &(psPam->pszGCPProjection) );
else
psPam->pszGCPProjection = CPLStrdup("");
// Count GCPs.
int nGCPMax = 0;
for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;
psXMLGCP = psXMLGCP->psNext )
nGCPMax++;
psPam->pasGCPList = (GDAL_GCP *) CPLCalloc(sizeof(GDAL_GCP),nGCPMax);
for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;
psXMLGCP = psXMLGCP->psNext )
{
GDAL_GCP *psGCP = psPam->pasGCPList + psPam->nGCPCount;
if( !EQUAL(psXMLGCP->pszValue,"GCP") ||
psXMLGCP->eType != CXT_Element )
continue;
GDALInitGCPs( 1, psGCP );
CPLFree( psGCP->pszId );
psGCP->pszId = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Id",""));
CPLFree( psGCP->pszInfo );
psGCP->pszInfo = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Info",""));
psGCP->dfGCPPixel = atof(CPLGetXMLValue(psXMLGCP,"Pixel","0.0"));
psGCP->dfGCPLine = atof(CPLGetXMLValue(psXMLGCP,"Line","0.0"));
psGCP->dfGCPX = atof(CPLGetXMLValue(psXMLGCP,"X","0.0"));
psGCP->dfGCPY = atof(CPLGetXMLValue(psXMLGCP,"Y","0.0"));
psGCP->dfGCPZ = atof(CPLGetXMLValue(psXMLGCP,"Z","0.0"));
psPam->nGCPCount++;
}
}
/* -------------------------------------------------------------------- */
/* Apply any dataset level metadata. */
/* -------------------------------------------------------------------- */
oMDMD.XMLInit( psTree, TRUE );
/* -------------------------------------------------------------------- */
/* Process bands. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psBandTree;
for( psBandTree = psTree->psChild;
psBandTree != NULL; psBandTree = psBandTree->psNext )
{
if( psBandTree->eType != CXT_Element
|| !EQUAL(psBandTree->pszValue,"PAMRasterBand") )
continue;
int nBand = atoi(CPLGetXMLValue( psBandTree, "band", "0"));
if( nBand < 1 || nBand > GetRasterCount() )
continue;
GDALPamRasterBand *poBand = (GDALPamRasterBand *)
GetRasterBand(nBand);
if( poBand == NULL || !(poBand->GetMOFlags() & GMO_PAM_CLASS) )
continue;
poBand->XMLInit( psBandTree, pszVRTPath );
}
/* -------------------------------------------------------------------- */
/* Clear dirty flag. */
/* -------------------------------------------------------------------- */
nPamFlags &= ~GPF_DIRTY;
return CE_None;
}
OGRSpatialReference* OGRGeoJSONReadSpatialReference( json_object* poObj) {
/* -------------------------------------------------------------------- */
/* Read spatial reference definition. */
/* -------------------------------------------------------------------- */
OGRSpatialReference* poSRS = NULL;
json_object* poObjSrs = OGRGeoJSONFindMemberByName( poObj, "crs" );
if( NULL != poObjSrs )
{
json_object* poObjSrsType = OGRGeoJSONFindMemberByName( poObjSrs, "type" );
if (poObjSrsType == NULL)
return NULL;
const char* pszSrsType = json_object_get_string( poObjSrsType );
// TODO: Add URL and URN types support
if( EQUALN( pszSrsType, "NAME", 4 ) )
{
json_object* poObjSrsProps = OGRGeoJSONFindMemberByName( poObjSrs, "properties" );
if (poObjSrsProps == NULL)
return NULL;
json_object* poNameURL = OGRGeoJSONFindMemberByName( poObjSrsProps, "name" );
if (poNameURL == NULL)
return NULL;
const char* pszName = json_object_get_string( poNameURL );
poSRS = new OGRSpatialReference();
if( OGRERR_NONE != poSRS->SetFromUserInput( pszName ) )
{
delete poSRS;
poSRS = NULL;
}
}
if( EQUALN( pszSrsType, "EPSG", 4 ) )
{
json_object* poObjSrsProps = OGRGeoJSONFindMemberByName( poObjSrs, "properties" );
if (poObjSrsProps == NULL)
return NULL;
json_object* poObjCode = OGRGeoJSONFindMemberByName( poObjSrsProps, "code" );
if (poObjCode == NULL)
return NULL;
int nEPSG = json_object_get_int( poObjCode );
poSRS = new OGRSpatialReference();
if( OGRERR_NONE != poSRS->importFromEPSG( nEPSG ) )
{
delete poSRS;
poSRS = NULL;
}
}
if( EQUALN( pszSrsType, "URL", 3 ) || EQUALN( pszSrsType, "LINK", 4 ) )
{
json_object* poObjSrsProps = OGRGeoJSONFindMemberByName( poObjSrs, "properties" );
if (poObjSrsProps == NULL)
return NULL;
json_object* poObjURL = OGRGeoJSONFindMemberByName( poObjSrsProps, "url" );
if (NULL == poObjURL) {
poObjURL = OGRGeoJSONFindMemberByName( poObjSrsProps, "href" );
}
if (poObjURL == NULL)
return NULL;
const char* pszURL = json_object_get_string( poObjURL );
poSRS = new OGRSpatialReference();
if( OGRERR_NONE != poSRS->importFromUrl( pszURL ) )
{
delete poSRS;
poSRS = NULL;
}
}
if( EQUAL( pszSrsType, "OGC" ) )
{
json_object* poObjSrsProps = OGRGeoJSONFindMemberByName( poObjSrs, "properties" );
if (poObjSrsProps == NULL)
return NULL;
json_object* poObjURN = OGRGeoJSONFindMemberByName( poObjSrsProps, "urn" );
if (poObjURN == NULL)
return NULL;
poSRS = new OGRSpatialReference();
if( OGRERR_NONE != poSRS->importFromURN( json_object_get_string(poObjURN) ) )
{
delete poSRS;
poSRS = NULL;
}
}
}
return poSRS;
}
CPLErr GNMFileNetwork::Create( const char* pszFilename, char** papszOptions )
{
// check required options
// check name
const char* pszNetworkName = CSLFetchNameValue(papszOptions, GNM_MD_NAME);
if( NULL == pszNetworkName )
{
CPLError( CE_Failure, CPLE_IllegalArg,
"The network name should be present" );
return CE_Failure;
}
else
{
m_soName = pszNetworkName;
}
const char* pszNetworkDescription = CSLFetchNameValue(papszOptions,
GNM_MD_DESCR);
if(NULL != pszNetworkDescription)
sDescription = pszNetworkDescription;
// check Spatial reference
const char* pszSRS = CSLFetchNameValue(papszOptions, GNM_MD_SRS);
if( NULL == pszSRS )
{
CPLError( CE_Failure, CPLE_IllegalArg,
"The network spatial reference should be present" );
return CE_Failure;
}
else
{
OGRSpatialReference spatialRef;
if (spatialRef.SetFromUserInput(pszSRS) != OGRERR_NONE)
{
CPLError( CE_Failure, CPLE_IllegalArg,
"The network spatial reference should be present" );
return CE_Failure;
}
char *wktSrs = NULL;
if (spatialRef.exportToWkt(&wktSrs) != OGRERR_NONE)
{
CPLError( CE_Failure, CPLE_IllegalArg,
"The network spatial reference should be present" );
return CE_Failure;
}
m_soSRS = wktSrs;
CPLFree(wktSrs);
}
int nResult = CheckNetworkExist(pszFilename, papszOptions);
if(TRUE == nResult)
{
CPLError( CE_Failure, CPLE_IllegalArg, "The network already exist" );
return CE_Failure;
}
// Create the necessary system layers and fields
// Create meta layer
CPLErr eResult = CreateMetadataLayerFromFile(pszFilename, GNM_VERSION_NUM, papszOptions);
if(CE_None != eResult)
{
//an error message should come from function
return CE_Failure;
}
// Create graph layer
eResult = CreateGraphLayerFromFile(pszFilename, papszOptions);
if(CE_None != eResult)
{
DeleteMetadataLayer();
return CE_Failure;
}
// Create features layer
eResult = CreateFeaturesLayerFromFile(pszFilename, papszOptions);
if(CE_None != eResult)
{
DeleteMetadataLayer();
DeleteGraphLayer();
return CE_Failure;
}
return CE_None;
}
CPLErr GNMDatabaseNetwork::Create( const char* pszFilename, char** papszOptions )
{
FormName(pszFilename, papszOptions);
if(m_soName.empty() || m_soNetworkFullName.empty())
{
CPLError( CE_Failure, CPLE_IllegalArg,
"The network name should be present" );
return CE_Failure;
}
if(NULL == m_poDS)
{
m_poDS = (GDALDataset*) GDALOpenEx( m_soNetworkFullName, GDAL_OF_VECTOR |
GDAL_OF_UPDATE, NULL, NULL, papszOptions );
}
if( NULL == m_poDS )
{
CPLError( CE_Failure, CPLE_OpenFailed, "Open '%s' failed",
m_soNetworkFullName.c_str() );
return CE_Failure;
}
GDALDriver *l_poDriver = m_poDS->GetDriver();
if(NULL == l_poDriver)
{
CPLError( CE_Failure, CPLE_OpenFailed, "Get dataset driver failed");
return CE_Failure;
}
if(!CheckStorageDriverSupport(l_poDriver->GetDescription()))
{
return CE_Failure;
}
// check required options
const char* pszNetworkDescription = CSLFetchNameValue(papszOptions,
GNM_MD_DESCR);
if(NULL != pszNetworkDescription)
sDescription = pszNetworkDescription;
// check Spatial reference
const char* pszSRS = CSLFetchNameValue(papszOptions, GNM_MD_SRS);
if( NULL == pszSRS )
{
CPLError( CE_Failure, CPLE_IllegalArg,
"The network spatial reference should be present" );
return CE_Failure;
}
else
{
OGRSpatialReference spatialRef;
if (spatialRef.SetFromUserInput(pszSRS) != OGRERR_NONE)
{
CPLError( CE_Failure, CPLE_IllegalArg,
"The network spatial reference should be present" );
return CE_Failure;
}
char *wktSrs = NULL;
if (spatialRef.exportToWkt(&wktSrs) != OGRERR_NONE)
{
CPLError( CE_Failure, CPLE_IllegalArg,
"The network spatial reference should be present" );
return CE_Failure;
}
m_soSRS = wktSrs;
CPLFree(wktSrs);
}
int nResult = CheckNetworkExist(pszFilename, papszOptions);
if(TRUE == nResult)
{
CPLError( CE_Failure, CPLE_IllegalArg, "The network already exist" );
return CE_Failure;
}
// Create the necessary system layers and fields
// Create meta layer
CPLErr eResult = CreateMetadataLayer(m_poDS, GNM_VERSION_NUM);
if(CE_None != eResult)
{
//an error message should come from function
return CE_Failure; }
// Create graph layer
eResult = CreateGraphLayer(m_poDS);
if(CE_None != eResult)
{
DeleteMetadataLayer();
return CE_Failure;
}
// Create features layer
eResult = CreateFeaturesLayer(m_poDS);
if(CE_None != eResult)
{
DeleteMetadataLayer();
DeleteGraphLayer();
return CE_Failure;
}
return CE_None;
}
CPLErr GDALParseGMLCoverage( CPLXMLNode *psXML,
int *pnXSize, int *pnYSize,
double *padfGeoTransform,
char **ppszProjection )
{
CPLStripXMLNamespace( psXML, NULL, TRUE );
/* -------------------------------------------------------------------- */
/* Isolate RectifiedGrid. Eventually we will need to support */
/* other georeferencing objects. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRG = CPLSearchXMLNode( psXML, "=RectifiedGrid" );
CPLXMLNode *psOriginPoint = NULL;
const char *pszOffset1=NULL, *pszOffset2=NULL;
if( psRG != NULL )
{
psOriginPoint = CPLGetXMLNode( psRG, "origin.Point" );
if( psOriginPoint == NULL )
psOriginPoint = CPLGetXMLNode( psRG, "origin" );
CPLXMLNode *psOffset1 = CPLGetXMLNode( psRG, "offsetVector" );
if( psOffset1 != NULL )
{
pszOffset1 = CPLGetXMLValue( psOffset1, "", NULL );
pszOffset2 = CPLGetXMLValue( psOffset1->psNext, "=offsetVector",
NULL );
}
}
/* -------------------------------------------------------------------- */
/* If we are missing any of the origin or 2 offsets then give up. */
/* -------------------------------------------------------------------- */
if( psRG == NULL || psOriginPoint == NULL
|| pszOffset1 == NULL || pszOffset2 == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to find GML RectifiedGrid, origin or offset vectors");
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Search for the GridEnvelope and derive the raster size. */
/* -------------------------------------------------------------------- */
char **papszLow = CSLTokenizeString(
CPLGetXMLValue( psRG, "limits.GridEnvelope.low", ""));
char **papszHigh = CSLTokenizeString(
CPLGetXMLValue( psRG, "limits.GridEnvelope.high",""));
if( CSLCount(papszLow) < 2 || CSLCount(papszHigh) < 2 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to find or parse GridEnvelope.low/high." );
return CE_Failure;
}
if( pnXSize != NULL )
*pnXSize = atoi(papszHigh[0]) - atoi(papszLow[0]) + 1;
if( pnYSize != NULL )
*pnYSize = atoi(papszHigh[1]) - atoi(papszLow[1]) + 1;
CSLDestroy( papszLow );
CSLDestroy( papszHigh );
/* -------------------------------------------------------------------- */
/* Extract origin location. */
/* -------------------------------------------------------------------- */
OGRPoint *poOriginGeometry = NULL;
const char *pszSRSName = NULL;
if( psOriginPoint != NULL )
{
int bOldWrap = FALSE;
// old coverages (ie. WCS) just have <pos> under <origin> so we
// may need to temporarily force <origin> to <Point>
if( psOriginPoint->eType == CXT_Element
&& EQUAL(psOriginPoint->pszValue,"origin") )
{
strcpy( psOriginPoint->pszValue, "Point");
bOldWrap = TRUE;
}
poOriginGeometry = (OGRPoint *)
OGR_G_CreateFromGMLTree( psOriginPoint );
if( poOriginGeometry != NULL
&& wkbFlatten(poOriginGeometry->getGeometryType()) != wkbPoint )
{
delete poOriginGeometry;
poOriginGeometry = NULL;
}
if( bOldWrap )
strcpy( psOriginPoint->pszValue, "origin");
// SRS?
pszSRSName = CPLGetXMLValue( psOriginPoint, "srsName", NULL );
}
/* -------------------------------------------------------------------- */
/* Extract offset(s) */
/* -------------------------------------------------------------------- */
char **papszOffset1Tokens = NULL;
char **papszOffset2Tokens = NULL;
int bSuccess = FALSE;
papszOffset1Tokens =
CSLTokenizeStringComplex( pszOffset1, " ,", FALSE, FALSE );
papszOffset2Tokens =
CSLTokenizeStringComplex( pszOffset2, " ,", FALSE, FALSE );
if( CSLCount(papszOffset1Tokens) >= 2
&& CSLCount(papszOffset2Tokens) >= 2
&& poOriginGeometry != NULL )
{
padfGeoTransform[0] = poOriginGeometry->getX();
padfGeoTransform[1] = atof(papszOffset1Tokens[0]);
padfGeoTransform[2] = atof(papszOffset1Tokens[1]);
padfGeoTransform[3] = poOriginGeometry->getY();
padfGeoTransform[4] = atof(papszOffset2Tokens[0]);
padfGeoTransform[5] = atof(papszOffset2Tokens[1]);
// offset from center of pixel.
padfGeoTransform[0] -= padfGeoTransform[1]*0.5;
padfGeoTransform[0] -= padfGeoTransform[2]*0.5;
padfGeoTransform[3] -= padfGeoTransform[4]*0.5;
padfGeoTransform[3] -= padfGeoTransform[5]*0.5;
bSuccess = TRUE;
//bHaveGeoTransform = TRUE;
}
CSLDestroy( papszOffset1Tokens );
CSLDestroy( papszOffset2Tokens );
if( poOriginGeometry != NULL )
delete poOriginGeometry;
/* -------------------------------------------------------------------- */
/* If we have gotten a geotransform, then try to interprete the */
/* srsName. */
/* -------------------------------------------------------------------- */
if( bSuccess && pszSRSName != NULL
&& (*ppszProjection == NULL || strlen(*ppszProjection) == 0) )
{
if( EQUALN(pszSRSName,"epsg:",5) )
{
OGRSpatialReference oSRS;
if( oSRS.SetFromUserInput( pszSRSName ) == OGRERR_NONE )
oSRS.exportToWkt( ppszProjection );
}
else if( EQUALN(pszSRSName,"urn:ogc:def:crs:",16) )
{
OGRSpatialReference oSRS;
if( oSRS.importFromURN( pszSRSName ) == OGRERR_NONE )
oSRS.exportToWkt( ppszProjection );
}
else
*ppszProjection = CPLStrdup(pszSRSName);
}
if( *ppszProjection )
CPLDebug( "GDALJP2Metadata",
"Got projection from GML box: %s",
*ppszProjection );
return CE_None;
}
int FindSRS( const char *pszInput, OGRSpatialReference &oSRS )
{
int bGotSRS = FALSE;
VSILFILE *fp = NULL;
GDALDataset *poGDALDS = NULL;
OGRLayer *poLayer = NULL;
const char *pszProjection = NULL;
CPLErrorHandler oErrorHandler = NULL;
int bIsFile = FALSE;
OGRErr eErr = OGRERR_NONE;
int bDebug = FALSE;
/* temporarily suppress error messages we may get from xOpen() */
bDebug = CSLTestBoolean(CPLGetConfigOption("CPL_DEBUG", "OFF"));
if ( ! bDebug )
oErrorHandler = CPLSetErrorHandler ( CPLQuietErrorHandler );
/* Test if argument is a file */
fp = VSIFOpenL( pszInput, "r" );
if ( fp ) {
bIsFile = TRUE;
VSIFCloseL( fp );
CPLDebug( "gdalsrsinfo", "argument is a file" );
}
/* try to open with GDAL */
if( strncmp(pszInput, "http://spatialreference.org/",
strlen("http://spatialreference.org/")) != 0 )
{
CPLDebug( "gdalsrsinfo", "trying to open with GDAL" );
poGDALDS = (GDALDataset *) GDALOpenEx( pszInput, 0, NULL, NULL, NULL );
}
if ( poGDALDS != NULL ) {
pszProjection = poGDALDS->GetProjectionRef( );
if( pszProjection != NULL && pszProjection[0] != '\0' )
{
char* pszProjectionTmp = (char*) pszProjection;
if( oSRS.importFromWkt( &pszProjectionTmp ) == OGRERR_NONE ) {
CPLDebug( "gdalsrsinfo", "got SRS from GDAL" );
bGotSRS = TRUE;
}
}
else if( poGDALDS->GetLayerCount() > 0 )
{
poLayer = poGDALDS->GetLayer( 0 );
if ( poLayer != NULL ) {
OGRSpatialReference *poSRS = poLayer->GetSpatialRef( );
if ( poSRS != NULL ) {
CPLDebug( "gdalsrsinfo", "got SRS from OGR" );
bGotSRS = TRUE;
OGRSpatialReference* poSRSClone = poSRS->Clone();
oSRS = *poSRSClone;
OGRSpatialReference::DestroySpatialReference( poSRSClone );
}
}
}
GDALClose( (GDALDatasetH) poGDALDS );
if ( ! bGotSRS )
CPLDebug( "gdalsrsinfo", "did not open with GDAL" );
}
/* Try ESRI file */
if ( ! bGotSRS && bIsFile && (strstr(pszInput,".prj") != NULL) ) {
CPLDebug( "gdalsrsinfo",
"trying to get SRS from ESRI .prj file [%s]", pszInput );
char **pszTemp;
if ( strstr(pszInput,"ESRI::") != NULL )
pszTemp = CSLLoad( pszInput+6 );
else
pszTemp = CSLLoad( pszInput );
if( pszTemp ) {
eErr = oSRS.importFromESRI( pszTemp );
CSLDestroy( pszTemp );
}
else
eErr = OGRERR_UNSUPPORTED_SRS;
if( eErr != OGRERR_NONE ) {
CPLDebug( "gdalsrsinfo", "did not get SRS from ESRI .prj file" );
}
else {
CPLDebug( "gdalsrsinfo", "got SRS from ESRI .prj file" );
bGotSRS = TRUE;
}
}
/* Last resort, try OSRSetFromUserInput() */
if ( ! bGotSRS ) {
CPLDebug( "gdalsrsinfo",
"trying to get SRS from user input [%s]", pszInput );
eErr = oSRS.SetFromUserInput( pszInput );
if( eErr != OGRERR_NONE ) {
CPLDebug( "gdalsrsinfo", "did not get SRS from user input" );
}
else {
CPLDebug( "gdalsrsinfo", "got SRS from user input" );
bGotSRS = TRUE;
}
}
/* restore error messages */
if ( ! bDebug )
CPLSetErrorHandler ( oErrorHandler );
return bGotSRS;
}
GDALDataset *DIMAPDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The DIMAP driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Get the metadata filename. */
/* -------------------------------------------------------------------- */
CPLString osMDFilename;
if( poOpenInfo->bIsDirectory )
{
osMDFilename =
CPLFormCIFilename( poOpenInfo->pszFilename, "METADATA.DIM", NULL );
}
else
osMDFilename = poOpenInfo->pszFilename;
/* -------------------------------------------------------------------- */
/* Ingest the xml file. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psProduct, *psImageAttributes;
psProduct = CPLParseXMLFile( osMDFilename );
if( psProduct == NULL )
return NULL;
CPLXMLNode *psDoc = CPLGetXMLNode( psProduct, "=Dimap_Document" );
psImageAttributes = CPLGetXMLNode( psDoc, "Raster_Dimensions" );
if( psImageAttributes == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to find <Raster_Dimensions> in document." );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the dataset. */
/* -------------------------------------------------------------------- */
DIMAPDataset *poDS = new DIMAPDataset();
poDS->psProduct = psProduct;
/* -------------------------------------------------------------------- */
/* Get overall image information. */
/* -------------------------------------------------------------------- */
#ifdef DEBUG
int nBands =
atoi(CPLGetXMLValue( psImageAttributes, "NBANDS", "-1" ));
#endif
poDS->nRasterXSize =
atoi(CPLGetXMLValue( psImageAttributes, "NCOLS", "-1" ));
poDS->nRasterYSize =
atoi(CPLGetXMLValue( psImageAttributes, "NROWS", "-1" ));
/* -------------------------------------------------------------------- */
/* Get the name of the underlying file. */
/* -------------------------------------------------------------------- */
const char *pszHref = CPLGetXMLValue(
psDoc, "Data_Access.Data_File.DATA_FILE_PATH.href", "" );
CPLString osPath = CPLGetPath(osMDFilename);
CPLString osImageFilename =
CPLFormFilename( osPath, pszHref, NULL );
/* -------------------------------------------------------------------- */
/* Try and open the file. */
/* -------------------------------------------------------------------- */
poDS->poImageDS = (GDALDataset *) GDALOpen( osImageFilename, GA_ReadOnly );
if( poDS->poImageDS == NULL )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Attach the bands. */
/* -------------------------------------------------------------------- */
int iBand;
CPLAssert( nBands == poDS->poImageDS->GetRasterCount() );
for( iBand = 1; iBand <= poDS->poImageDS->GetRasterCount(); iBand++ )
poDS->SetBand( iBand, poDS->poImageDS->GetRasterBand( iBand ) );
/* -------------------------------------------------------------------- */
/* Try to collect simple insertion point. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psGeoLoc =
CPLGetXMLNode( psDoc, "Geoposition.Geoposition_Insert" );
if( psGeoLoc != NULL )
{
poDS->bHaveGeoTransform = TRUE;
poDS->adfGeoTransform[0] = atof(CPLGetXMLValue(psGeoLoc,"ULXMAP","0"));
poDS->adfGeoTransform[1] = atof(CPLGetXMLValue(psGeoLoc,"XDIM","0"));
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = atof(CPLGetXMLValue(psGeoLoc,"ULYMAP","0"));
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = -atof(CPLGetXMLValue(psGeoLoc,"YDIM","0"));
}
/* -------------------------------------------------------------------- */
/* Collect GCPs. */
/* -------------------------------------------------------------------- */
psGeoLoc = CPLGetXMLNode( psDoc, "Geoposition.Geoposition_Points" );
if( psGeoLoc != NULL )
{
CPLXMLNode *psNode;
// count gcps.
poDS->nGCPCount = 0;
for( psNode = psGeoLoc->psChild; psNode != NULL;
psNode = psNode->psNext )
{
if( EQUAL(psNode->pszValue,"Tie_Point") )
poDS->nGCPCount++ ;
}
poDS->pasGCPList = (GDAL_GCP *)
CPLCalloc(sizeof(GDAL_GCP),poDS->nGCPCount);
poDS->nGCPCount = 0;
for( psNode = psGeoLoc->psChild; psNode != NULL;
psNode = psNode->psNext )
{
char szID[32];
GDAL_GCP *psGCP = poDS->pasGCPList + poDS->nGCPCount;
if( !EQUAL(psNode->pszValue,"Tie_Point") )
continue;
poDS->nGCPCount++ ;
sprintf( szID, "%d", poDS->nGCPCount );
psGCP->pszId = CPLStrdup( szID );
psGCP->pszInfo = CPLStrdup("");
psGCP->dfGCPPixel =
atof(CPLGetXMLValue(psNode,"TIE_POINT_DATA_X","0"))-0.5;
psGCP->dfGCPLine =
atof(CPLGetXMLValue(psNode,"TIE_POINT_DATA_Y","0"))-0.5;
psGCP->dfGCPX =
atof(CPLGetXMLValue(psNode,"TIE_POINT_CRS_X",""));
psGCP->dfGCPY =
atof(CPLGetXMLValue(psNode,"TIE_POINT_CRS_Y",""));
psGCP->dfGCPZ =
atof(CPLGetXMLValue(psNode,"TIE_POINT_CRS_Z",""));
}
}
/* -------------------------------------------------------------------- */
/* Collect the CRS. For now we look only for EPSG codes. */
/* -------------------------------------------------------------------- */
const char *pszSRS = CPLGetXMLValue(
psDoc,
"Coordinate_Reference_System.Horizontal_CS.HORIZONTAL_CS_CODE",
NULL );
if( pszSRS != NULL )
{
OGRSpatialReference oSRS;
if( oSRS.SetFromUserInput( pszSRS ) == OGRERR_NONE )
{
if( poDS->nGCPCount > 0 )
{
CPLFree(poDS->pszGCPProjection);
oSRS.exportToWkt( &(poDS->pszGCPProjection) );
}
else
{
char *pszProjection = NULL;
oSRS.exportToWkt( &pszProjection );
poDS->osProjection = pszProjection;
CPLFree( pszProjection );
}
}
}
/* -------------------------------------------------------------------- */
/* Translate other metadata of interest. */
/* -------------------------------------------------------------------- */
static const char *apszMetadataTranslation[] =
{
"Production", "",
"Production.Facility", "FACILITY_",
"Dataset_Sources.Source_Information.Scene_Source", "",
"Data_Processing", "",
"Image_Interpretation.Spectral_Band_Info", "SPECTRAL_",
NULL, NULL
};
int iTrItem;
for( iTrItem = 0; apszMetadataTranslation[iTrItem] != NULL; iTrItem += 2 )
{
CPLXMLNode *psParent =
CPLGetXMLNode( psDoc, apszMetadataTranslation[iTrItem] );
if( psParent == NULL )
continue;
// hackey logic to support directly access a name/value entry
// or a parent element with many name/values.
CPLXMLNode *psTarget;
if( psParent->psChild != NULL
&& psParent->psChild->eType == CXT_Text )
psTarget = psParent;
else
psTarget = psParent->psChild;
for( ; psTarget != NULL && psTarget != psParent;
psTarget = psTarget->psNext )
{
if( psTarget->eType == CXT_Element
&& psTarget->psChild != NULL
&& psTarget->psChild->eType == CXT_Text )
{
CPLString osName = apszMetadataTranslation[iTrItem+1];
osName += psTarget->pszValue;
poDS->SetMetadataItem( osName, psTarget->psChild->pszValue );
}
}
}
/* -------------------------------------------------------------------- */
/* Set Band metadata from the <Spectral_Band_Info> content */
/* -------------------------------------------------------------------- */
CPLXMLNode *psImageInterpretationNode =
CPLGetXMLNode( psDoc, "Image_Interpretation" );
if (psImageInterpretationNode != NULL)
{
CPLXMLNode *psSpectralBandInfoNode = psImageInterpretationNode->psChild;
while (psSpectralBandInfoNode != NULL)
{
if (psSpectralBandInfoNode->eType == CXT_Element &&
EQUAL(psSpectralBandInfoNode->pszValue, "Spectral_Band_Info"))
{
CPLXMLNode *psTag = psSpectralBandInfoNode->psChild;
int nBandIndex = 0;
while(psTag != NULL)
{
if (psTag->eType == CXT_Element && psTag->psChild != NULL &&
psTag->psChild->eType == CXT_Text && psTag->pszValue != NULL)
{
if (EQUAL(psTag->pszValue, "BAND_INDEX"))
{
nBandIndex = atoi(psTag->psChild->pszValue);
if (nBandIndex <= 0 ||
nBandIndex > poDS->poImageDS->GetRasterCount())
{
CPLError(CE_Warning, CPLE_AppDefined,
"Bad BAND_INDEX value : %s", psTag->psChild->pszValue);
nBandIndex = 0;
}
}
else if (nBandIndex >= 1)
{
poDS->GetRasterBand(nBandIndex)->SetMetadataItem(
psTag->pszValue, psTag->psChild->pszValue);
}
}
psTag = psTag->psNext;
}
}
psSpectralBandInfoNode = psSpectralBandInfoNode->psNext;
}
}
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( osMDFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, osMDFilename );
return( poDS );
}
/** 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);
}