OGRDataSource *AoIIntersection::buildIntersectionDataSource ( const char *outFmt )
{
// get driver registrar
OGRSFDriverRegistrar *reg = OGRSFDriverRegistrar::GetRegistrar();
// create an OGRDataSource
OGRSFDriver *driverToUse = reg->GetDriverByName( outFmt );
if ( driverToUse )
{
return( driverToUse->CreateDataSource( "C:\\Minerva\\Data\\intersection.mem", NULL ) );
}
return 0;
}
bool AoIIntersection::testFormatAvailable ( const char *outFmt )
{
// this is how you find what drivers are available
OGRSFDriverRegistrar *reg = OGRSFDriverRegistrar::GetRegistrar();
int driverCount = reg->GetDriverCount();
for ( int i = 0; i < driverCount; ++i )
{
OGRSFDriver *driver = reg->GetDriver( i );
if ( driver )
{
const char *name = driver->GetName();
if (! stricmp( name, outFmt ))
return true;
}
}
return false;
}
int main( int nArgc, char ** papszArgv )
{
int nFirstSourceDataset = -1, bLayersWildcarded = TRUE, iArg;
const char *pszFormat = "ESRI Shapefile";
const char *pszTileIndexField = "LOCATION";
const char *pszOutputName = NULL;
int write_absolute_path = FALSE;
int skip_different_projection = FALSE;
char* current_path = NULL;
int accept_different_schemas = FALSE;
int bFirstWarningForNonMatchingAttributes = TRUE;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(papszArgv[0]))
exit(1);
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
for( iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(papszArgv[iArg],"-f") && iArg < nArgc-1 )
{
pszFormat = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-write_absolute_path"))
{
write_absolute_path = TRUE;
}
else if( EQUAL(papszArgv[iArg],"-skip_different_projection"))
{
skip_different_projection = TRUE;
}
else if( EQUAL(papszArgv[iArg],"-accept_different_schemas"))
{
accept_different_schemas = TRUE;
}
else if( EQUAL(papszArgv[iArg],"-tileindex") && iArg < nArgc-1 )
{
pszTileIndexField = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-lnum")
|| EQUAL(papszArgv[iArg],"-lname") )
{
iArg++;
bLayersWildcarded = FALSE;
}
else if( papszArgv[iArg][0] == '-' )
Usage();
else if( pszOutputName == NULL )
pszOutputName = papszArgv[iArg];
else if( nFirstSourceDataset == -1 )
nFirstSourceDataset = iArg;
}
if( pszOutputName == NULL || nFirstSourceDataset == -1 )
Usage();
/* -------------------------------------------------------------------- */
/* Try to open as an existing dataset for update access. */
/* -------------------------------------------------------------------- */
OGRDataSource *poDstDS;
OGRLayer *poDstLayer = NULL;
poDstDS = OGRSFDriverRegistrar::Open( pszOutputName, TRUE );
/* -------------------------------------------------------------------- */
/* If that failed, find the driver so we can create the tile index.*/
/* -------------------------------------------------------------------- */
if( poDstDS == NULL )
{
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
OGRSFDriver *poDriver = NULL;
int iDriver;
for( iDriver = 0;
iDriver < poR->GetDriverCount() && poDriver == NULL;
iDriver++ )
{
if( EQUAL(poR->GetDriver(iDriver)->GetName(),pszFormat) )
{
poDriver = poR->GetDriver(iDriver);
}
}
if( poDriver == NULL )
{
fprintf( stderr, "Unable to find driver `%s'.\n", pszFormat );
fprintf( stderr, "The following drivers are available:\n" );
for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
fprintf( stderr, " -> `%s'\n", poR->GetDriver(iDriver)->GetName() );
}
exit( 1 );
}
if( !poDriver->TestCapability( ODrCCreateDataSource ) )
{
fprintf( stderr, "%s driver does not support data source creation.\n",
pszFormat );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Now create it. */
/* -------------------------------------------------------------------- */
poDstDS = poDriver->CreateDataSource( pszOutputName, NULL );
if( poDstDS == NULL )
{
fprintf( stderr, "%s driver failed to create %s\n",
pszFormat, pszOutputName );
exit( 1 );
}
if( poDstDS->GetLayerCount() == 0 )
{
OGRFieldDefn oLocation( pszTileIndexField, OFTString );
oLocation.SetWidth( 200 );
if( nFirstSourceDataset < nArgc && papszArgv[nFirstSourceDataset][0] == '-' )
{
nFirstSourceDataset++;
}
OGRSpatialReference* poSrcSpatialRef = NULL;
/* Fetches the SRS of the first layer and use it when creating the tileindex layer */
if (nFirstSourceDataset < nArgc)
{
OGRDataSource* poDS = OGRSFDriverRegistrar::Open( papszArgv[nFirstSourceDataset],
FALSE );
if (poDS)
{
int iLayer;
for( iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
int bRequested = bLayersWildcarded;
OGRLayer *poLayer = poDS->GetLayer(iLayer);
for( iArg = 1; iArg < nArgc && !bRequested; iArg++ )
{
if( EQUAL(papszArgv[iArg],"-lnum")
&& atoi(papszArgv[iArg+1]) == iLayer )
bRequested = TRUE;
else if( EQUAL(papszArgv[iArg],"-lname")
&& EQUAL(papszArgv[iArg+1],
poLayer->GetLayerDefn()->GetName()) )
bRequested = TRUE;
}
if( !bRequested )
continue;
if ( poLayer->GetSpatialRef() )
poSrcSpatialRef = poLayer->GetSpatialRef()->Clone();
break;
}
}
OGRDataSource::DestroyDataSource( poDS );
}
poDstLayer = poDstDS->CreateLayer( "tileindex", poSrcSpatialRef );
poDstLayer->CreateField( &oLocation, OFTString );
OGRSpatialReference::DestroySpatialReference( poSrcSpatialRef );
}
}
/* -------------------------------------------------------------------- */
/* Identify target layer and field. */
/* -------------------------------------------------------------------- */
int iTileIndexField;
poDstLayer = poDstDS->GetLayer(0);
if( poDstLayer == NULL )
{
fprintf( stderr, "Can't find any layer in output tileindex!\n" );
exit( 1 );
}
iTileIndexField =
poDstLayer->GetLayerDefn()->GetFieldIndex( pszTileIndexField );
if( iTileIndexField == -1 )
{
fprintf( stderr, "Can't find %s field in tile index dataset.\n",
pszTileIndexField );
exit( 1 );
}
OGRFeatureDefn* poFeatureDefn = NULL;
/* Load in memory existing file names in SHP */
int nExistingLayers = 0;
char** existingLayersTab = NULL;
OGRSpatialReference* alreadyExistingSpatialRef = NULL;
int alreadyExistingSpatialRefValid = FALSE;
nExistingLayers = poDstLayer->GetFeatureCount();
if (nExistingLayers)
{
int i;
existingLayersTab = (char**)CPLMalloc(nExistingLayers * sizeof(char*));
for(i=0;i<nExistingLayers;i++)
{
OGRFeature* feature = poDstLayer->GetNextFeature();
existingLayersTab[i] = CPLStrdup(feature->GetFieldAsString( iTileIndexField));
if (i == 0)
{
OGRDataSource *poDS;
char* filename = CPLStrdup(existingLayersTab[i]);
int j;
for(j=strlen(filename)-1;j>=0;j--)
{
if (filename[j] == ',')
break;
}
if (j >= 0)
{
int iLayer = atoi(filename + j + 1);
filename[j] = 0;
poDS = OGRSFDriverRegistrar::Open(filename,
FALSE );
if (poDS)
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if (poLayer)
{
alreadyExistingSpatialRefValid = TRUE;
alreadyExistingSpatialRef =
(poLayer->GetSpatialRef()) ? poLayer->GetSpatialRef()->Clone() : NULL;
if (poFeatureDefn == NULL)
poFeatureDefn = poLayer->GetLayerDefn()->Clone();
}
OGRDataSource::DestroyDataSource( poDS );
}
}
}
}
}
if (write_absolute_path)
{
current_path = CPLGetCurrentDir();
if (current_path == NULL)
{
fprintf( stderr, "This system does not support the CPLGetCurrentDir call. "
"The option -write_absolute_path will have no effect\n");
write_absolute_path = FALSE;
}
}
/* ==================================================================== */
/* Process each input datasource in turn. */
/* ==================================================================== */
for(; nFirstSourceDataset < nArgc; nFirstSourceDataset++ )
{
int i;
OGRDataSource *poDS;
if( papszArgv[nFirstSourceDataset][0] == '-' )
{
nFirstSourceDataset++;
continue;
}
char* fileNameToWrite;
VSIStatBuf sStatBuf;
if (write_absolute_path && CPLIsFilenameRelative( papszArgv[nFirstSourceDataset] ) &&
VSIStat( papszArgv[nFirstSourceDataset], &sStatBuf ) == 0)
{
fileNameToWrite = CPLStrdup(CPLProjectRelativeFilename(current_path,papszArgv[nFirstSourceDataset]));
}
else
{
fileNameToWrite = CPLStrdup(papszArgv[nFirstSourceDataset]);
}
poDS = OGRSFDriverRegistrar::Open( papszArgv[nFirstSourceDataset],
FALSE );
if( poDS == NULL )
{
fprintf( stderr, "Failed to open dataset %s, skipping.\n",
papszArgv[nFirstSourceDataset] );
CPLFree(fileNameToWrite);
continue;
}
/* -------------------------------------------------------------------- */
/* Check all layers, and see if they match requests. */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
int bRequested = bLayersWildcarded;
OGRLayer *poLayer = poDS->GetLayer(iLayer);
for( iArg = 1; iArg < nArgc && !bRequested; iArg++ )
{
if( EQUAL(papszArgv[iArg],"-lnum")
&& atoi(papszArgv[iArg+1]) == iLayer )
bRequested = TRUE;
else if( EQUAL(papszArgv[iArg],"-lname")
&& EQUAL(papszArgv[iArg+1],
poLayer->GetLayerDefn()->GetName()) )
bRequested = TRUE;
}
if( !bRequested )
continue;
/* Checks that the layer is not already in tileindex */
for(i=0;i<nExistingLayers;i++)
{
char szLocation[5000];
sprintf( szLocation, "%s,%d",
fileNameToWrite, iLayer );
if (EQUAL(szLocation, existingLayersTab[i]))
{
fprintf(stderr, "Layer %d of %s is already in tileindex. Skipping it.\n",
iLayer, papszArgv[nFirstSourceDataset]);
break;
}
}
if (i != nExistingLayers)
{
continue;
}
OGRSpatialReference* spatialRef = poLayer->GetSpatialRef();
if (alreadyExistingSpatialRefValid)
{
if ((spatialRef != NULL && alreadyExistingSpatialRef != NULL &&
spatialRef->IsSame(alreadyExistingSpatialRef) == FALSE) ||
((spatialRef != NULL) != (alreadyExistingSpatialRef != NULL)))
{
fprintf(stderr, "Warning : layer %d of %s is not using the same projection system as "
"other files in the tileindex. This may cause problems when "
"using it in MapServer for example.%s\n", iLayer, papszArgv[nFirstSourceDataset],
(skip_different_projection) ? " Skipping it" : "");
if (skip_different_projection)
{
continue;
}
}
}
else
{
alreadyExistingSpatialRefValid = TRUE;
alreadyExistingSpatialRef = (spatialRef) ? spatialRef->Clone() : NULL;
}
/* -------------------------------------------------------------------- */
/* Check if all layers in dataset have the same attributes schema. */
/* -------------------------------------------------------------------- */
if( poFeatureDefn == NULL )
{
poFeatureDefn = poLayer->GetLayerDefn()->Clone();
}
else if ( !accept_different_schemas )
{
OGRFeatureDefn* poFeatureDefnCur = poLayer->GetLayerDefn();
assert(NULL != poFeatureDefnCur);
int fieldCount = poFeatureDefnCur->GetFieldCount();
if( fieldCount != poFeatureDefn->GetFieldCount())
{
fprintf( stderr, "Number of attributes of layer %s of %s does not match ... skipping it.\n",
poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset]);
if (bFirstWarningForNonMatchingAttributes)
{
fprintf( stderr, "Note : you can override this behaviour with -accept_different_schemas option\n"
"but this may result in a tileindex incompatible with MapServer\n");
bFirstWarningForNonMatchingAttributes = FALSE;
}
continue;
}
int bSkip = FALSE;
for( int fn = 0; fn < poFeatureDefnCur->GetFieldCount(); fn++ )
{
OGRFieldDefn* poField = poFeatureDefn->GetFieldDefn(fn);
OGRFieldDefn* poFieldCur = poFeatureDefnCur->GetFieldDefn(fn);
/* XXX - Should those pointers be checked against NULL? */
assert(NULL != poField);
assert(NULL != poFieldCur);
if( poField->GetType() != poFieldCur->GetType()
|| poField->GetWidth() != poFieldCur->GetWidth()
|| poField->GetPrecision() != poFieldCur->GetPrecision()
|| !EQUAL( poField->GetNameRef(), poFieldCur->GetNameRef() ) )
{
fprintf( stderr, "Schema of attributes of layer %s of %s does not match ... skipping it.\n",
poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset]);
if (bFirstWarningForNonMatchingAttributes)
{
fprintf( stderr, "Note : you can override this behaviour with -accept_different_schemas option\n"
"but this may result in a tileindex incompatible with MapServer\n");
bFirstWarningForNonMatchingAttributes = FALSE;
}
bSkip = TRUE;
break;
}
}
if (bSkip)
continue;
}
/* -------------------------------------------------------------------- */
/* Get layer extents, and create a corresponding polygon */
/* geometry. */
/* -------------------------------------------------------------------- */
OGREnvelope sExtents;
OGRPolygon oRegion;
OGRLinearRing oRing;
if( poLayer->GetExtent( &sExtents, TRUE ) != OGRERR_NONE )
{
fprintf( stderr, "GetExtent() failed on layer %s of %s, skipping.\n",
poLayer->GetLayerDefn()->GetName(),
papszArgv[nFirstSourceDataset] );
continue;
}
oRing.addPoint( sExtents.MinX, sExtents.MinY );
oRing.addPoint( sExtents.MinX, sExtents.MaxY );
oRing.addPoint( sExtents.MaxX, sExtents.MaxY );
oRing.addPoint( sExtents.MaxX, sExtents.MinY );
oRing.addPoint( sExtents.MinX, sExtents.MinY );
oRegion.addRing( &oRing );
/* -------------------------------------------------------------------- */
/* Add layer to tileindex. */
/* -------------------------------------------------------------------- */
char szLocation[5000];
OGRFeature oTileFeat( poDstLayer->GetLayerDefn() );
sprintf( szLocation, "%s,%d",
fileNameToWrite, iLayer );
oTileFeat.SetGeometry( &oRegion );
oTileFeat.SetField( iTileIndexField, szLocation );
if( poDstLayer->CreateFeature( &oTileFeat ) != OGRERR_NONE )
{
fprintf( stderr, "Failed to create feature on tile index ... terminating." );
OGRDataSource::DestroyDataSource( poDstDS );
exit( 1 );
}
}
/* -------------------------------------------------------------------- */
/* Cleanup this data source. */
/* -------------------------------------------------------------------- */
CPLFree(fileNameToWrite);
OGRDataSource::DestroyDataSource( poDS );
}
/* -------------------------------------------------------------------- */
/* Close tile index and clear buffers. */
/* -------------------------------------------------------------------- */
OGRDataSource::DestroyDataSource( poDstDS );
OGRFeatureDefn::DestroyFeatureDefn( poFeatureDefn );
if (alreadyExistingSpatialRef != NULL)
OGRSpatialReference::DestroySpatialReference( alreadyExistingSpatialRef );
CPLFree(current_path);
if (nExistingLayers)
{
int i;
for(i=0;i<nExistingLayers;i++)
{
CPLFree(existingLayersTab[i]);
}
CPLFree(existingLayersTab);
}
return 0;
}
int OGRGeneralCmdLineProcessor( int nArgc, char ***ppapszArgv, int nOptions )
{
char **papszReturn = NULL;
int iArg;
char **papszArgv = *ppapszArgv;
(void) nOptions;
/* -------------------------------------------------------------------- */
/* Preserve the program name. */
/* -------------------------------------------------------------------- */
papszReturn = CSLAddString( papszReturn, papszArgv[0] );
/* ==================================================================== */
/* Loop over all arguments. */
/* ==================================================================== */
for( iArg = 1; iArg < nArgc; iArg++ )
{
/* -------------------------------------------------------------------- */
/* --version */
/* -------------------------------------------------------------------- */
if( EQUAL(papszArgv[iArg],"--version") )
{
printf( "%s\n", GDALVersionInfo( "--version" ) );
CSLDestroy( papszReturn );
return 0;
}
/* -------------------------------------------------------------------- */
/* --license */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--license") )
{
printf( "%s\n", GDALVersionInfo( "LICENSE" ) );
CSLDestroy( papszReturn );
return 0;
}
/* -------------------------------------------------------------------- */
/* --config */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--config") )
{
if( iArg + 2 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--config option given without a key and value argument." );
CSLDestroy( papszReturn );
return -1;
}
CPLSetConfigOption( papszArgv[iArg+1], papszArgv[iArg+2] );
iArg += 2;
}
/* -------------------------------------------------------------------- */
/* --mempreload */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--mempreload") )
{
int i;
if( iArg + 1 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--mempreload option given without directory path.");
CSLDestroy( papszReturn );
return -1;
}
char **papszFiles = CPLReadDir( papszArgv[iArg+1] );
if( CSLCount(papszFiles) == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--mempreload given invalid or empty directory.");
CSLDestroy( papszReturn );
return -1;
}
for( i = 0; papszFiles[i] != NULL; i++ )
{
CPLString osOldPath, osNewPath;
if( EQUAL(papszFiles[i],".") || EQUAL(papszFiles[i],"..") )
continue;
osOldPath = CPLFormFilename( papszArgv[iArg+1],
papszFiles[i], NULL );
osNewPath.Printf( "/vsimem/%s", papszFiles[i] );
CPLDebug( "VSI", "Preloading %s to %s.",
osOldPath.c_str(), osNewPath.c_str() );
if( CPLCopyFile( osNewPath, osOldPath ) != 0 )
return -1;
}
CSLDestroy( papszFiles );
iArg += 1;
}
/* -------------------------------------------------------------------- */
/* --debug */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--debug") )
{
if( iArg + 1 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--debug option given without debug level." );
CSLDestroy( papszReturn );
return -1;
}
CPLSetConfigOption( "CPL_DEBUG", papszArgv[iArg+1] );
iArg += 1;
}
/* -------------------------------------------------------------------- */
/* --optfile */
/* */
/* Annoyingly the options inserted by --optfile will *not* be */
/* processed properly if they are general options. */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--optfile") )
{
const char *pszLine;
FILE *fpOptFile;
if( iArg + 1 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--optfile option given without filename." );
CSLDestroy( papszReturn );
return -1;
}
fpOptFile = VSIFOpen( papszArgv[iArg+1], "rb" );
if( fpOptFile == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to open optfile '%s'.\n%s",
papszArgv[iArg+1], VSIStrerror( errno ) );
CSLDestroy( papszReturn );
return -1;
}
while( (pszLine = CPLReadLine( fpOptFile )) != NULL )
{
char **papszTokens;
int i;
if( pszLine[0] == '#' || strlen(pszLine) == 0 )
continue;
papszTokens = CSLTokenizeString( pszLine );
for( i = 0; papszTokens != NULL && papszTokens[i] != NULL; i++)
papszReturn = CSLAddString( papszReturn, papszTokens[i] );
CSLDestroy( papszTokens );
}
VSIFClose( fpOptFile );
iArg += 1;
}
/* -------------------------------------------------------------------- */
/* --formats */
/* -------------------------------------------------------------------- */
#ifdef OGR_ENABLED
else if( EQUAL(papszArgv[iArg], "--formats") )
{
int iDr;
printf( "Supported Formats:\n" );
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
for( iDr = 0; iDr < poR->GetDriverCount(); iDr++ )
{
OGRSFDriver *poDriver = poR->GetDriver(iDr);
if( poDriver->TestCapability( ODrCCreateDataSource ) )
printf( " -> \"%s\" (read/write)\n",
poDriver->GetName() );
else
printf( " -> \"%s\" (readonly)\n",
poDriver->GetName() );
}
CSLDestroy( papszReturn );
return 0;
}
#endif /* OGR_ENABLED */
/* -------------------------------------------------------------------- */
/* --locale */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--locale") && iArg < nArgc-1 )
{
setlocale( LC_ALL, papszArgv[++iArg] );
}
/* -------------------------------------------------------------------- */
/* --pause - "hit enter" pause useful to connect a debugger. */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--pause") )
{
char szLine[81];
printf( "Hit <ENTER> to continue.\n" );
fgets( szLine, sizeof(szLine), stdin );
}
/* -------------------------------------------------------------------- */
/* --help-general */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--help-general") )
{
printf( "Generic GDAL/OGR utility command options:\n" );
printf( " --version: report version of GDAL/OGR in use.\n" );
printf( " --license: report GDAL/OGR license info.\n" );
#ifdef OGR_ENABLED
printf( " --formats: report all configured format drivers.\n" );
#endif /* OGR_ENABLED */
printf( " --optfile filename: expand an option file into the argument list.\n" );
printf( " --config key value: set system configuration option.\n" );
printf( " --debug [on/off/value]: set debug level.\n" );
printf( " --help-general: report detailed help on general options.\n" );
CSLDestroy( papszReturn );
return 0;
}
/* -------------------------------------------------------------------- */
/* carry through unrecognised options. */
/* -------------------------------------------------------------------- */
else
{
papszReturn = CSLAddString( papszReturn, papszArgv[iArg] );
}
}
*ppapszArgv = papszReturn;
return CSLCount( *ppapszArgv );
}
int main( int nArgc, char ** papszArgv )
{
const char *pszWHERE = NULL;
const char *pszDataSource = NULL;
char **papszLayers = NULL;
OGRGeometry *poSpatialFilter = NULL;
int nRepeatCount = 1, bAllLayers = FALSE;
const char *pszSQLStatement = NULL;
const char *pszDialect = NULL;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(papszArgv[0]))
exit(1);
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 1 )
exit( -nArgc );
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(papszArgv[iArg],"-ro") )
bReadOnly = TRUE;
else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet"))
bVerbose = FALSE;
else if( EQUAL(papszArgv[iArg],"-fid") && iArg < nArgc-1 )
nFetchFID = atoi(papszArgv[++iArg]);
else if( EQUAL(papszArgv[iArg],"-spat")
&& papszArgv[iArg+1] != NULL
&& papszArgv[iArg+2] != NULL
&& papszArgv[iArg+3] != NULL
&& papszArgv[iArg+4] != NULL )
{
OGRLinearRing oRing;
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) );
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+4]) );
oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+4]) );
oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+2]) );
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) );
poSpatialFilter = new OGRPolygon();
((OGRPolygon *) poSpatialFilter)->addRing( &oRing );
iArg += 4;
}
else if( EQUAL(papszArgv[iArg],"-where") && papszArgv[iArg+1] != NULL )
{
pszWHERE = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-sql") && papszArgv[iArg+1] != NULL )
{
pszSQLStatement = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-dialect")
&& papszArgv[iArg+1] != NULL )
{
pszDialect = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-rc") && papszArgv[iArg+1] != NULL )
{
nRepeatCount = atoi(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg],"-al") )
{
bAllLayers = TRUE;
}
else if( EQUAL(papszArgv[iArg],"-so")
|| EQUAL(papszArgv[iArg],"-summary") )
{
bSummaryOnly = TRUE;
}
else if( EQUALN(papszArgv[iArg],"-fields=", strlen("-fields=")) )
{
char* pszTemp = (char*)CPLMalloc(32 + strlen(papszArgv[iArg]));
sprintf(pszTemp, "DISPLAY_FIELDS=%s", papszArgv[iArg] + strlen("-fields="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( EQUALN(papszArgv[iArg],"-geom=", strlen("-geom=")) )
{
char* pszTemp = (char*)CPLMalloc(32 + strlen(papszArgv[iArg]));
sprintf(pszTemp, "DISPLAY_GEOMETRY=%s", papszArgv[iArg] + strlen("-geom="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( papszArgv[iArg][0] == '-' )
{
Usage();
}
else if( pszDataSource == NULL )
pszDataSource = papszArgv[iArg];
else
{
papszLayers = CSLAddString( papszLayers, papszArgv[iArg] );
bAllLayers = FALSE;
}
}
if( pszDataSource == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
OGRDataSource *poDS = NULL;
OGRSFDriver *poDriver = NULL;
poDS = OGRSFDriverRegistrar::Open( pszDataSource, !bReadOnly, &poDriver );
if( poDS == NULL && !bReadOnly )
{
poDS = OGRSFDriverRegistrar::Open( pszDataSource, FALSE, &poDriver );
if( poDS != NULL && bVerbose )
{
printf( "Had to open data source read-only.\n" );
bReadOnly = TRUE;
}
}
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( poDS == NULL )
{
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
printf( "FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
pszDataSource );
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
printf( " -> %s\n", poR->GetDriver(iDriver)->GetName() );
}
exit( 1 );
}
CPLAssert( poDriver != NULL);
/* -------------------------------------------------------------------- */
/* Some information messages. */
/* -------------------------------------------------------------------- */
if( bVerbose )
printf( "INFO: Open of `%s'\n"
" using driver `%s' successful.\n",
pszDataSource, poDriver->GetName() );
if( bVerbose && !EQUAL(pszDataSource,poDS->GetName()) )
{
printf( "INFO: Internal data source name `%s'\n"
" different from user name `%s'.\n",
poDS->GetName(), pszDataSource );
}
/* -------------------------------------------------------------------- */
/* Special case for -sql clause. No source layers required. */
/* -------------------------------------------------------------------- */
if( pszSQLStatement != NULL )
{
OGRLayer *poResultSet = NULL;
nRepeatCount = 0; // skip layer reporting.
if( CSLCount(papszLayers) > 0 )
printf( "layer names ignored in combination with -sql.\n" );
poResultSet = poDS->ExecuteSQL( pszSQLStatement, poSpatialFilter,
pszDialect );
if( poResultSet != NULL )
{
if( pszWHERE != NULL )
poResultSet->SetAttributeFilter( pszWHERE );
ReportOnLayer( poResultSet, NULL, NULL );
poDS->ReleaseResultSet( poResultSet );
}
}
CPLDebug( "OGR", "GetLayerCount() = %d\n", poDS->GetLayerCount() );
for( int iRepeat = 0; iRepeat < nRepeatCount; iRepeat++ )
{
if ( CSLCount(papszLayers) == 0 )
{
/* -------------------------------------------------------------------- */
/* Process each data source layer. */
/* -------------------------------------------------------------------- */
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer );
exit( 1 );
}
if (!bAllLayers)
{
printf( "%d: %s",
iLayer+1,
poLayer->GetLayerDefn()->GetName() );
if( poLayer->GetLayerDefn()->GetGeomType() != wkbUnknown )
printf( " (%s)",
OGRGeometryTypeToName(
poLayer->GetLayerDefn()->GetGeomType() ) );
printf( "\n" );
}
else
{
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer( poLayer, pszWHERE, poSpatialFilter );
}
}
}
else
{
/* -------------------------------------------------------------------- */
/* Process specified data source layers. */
/* -------------------------------------------------------------------- */
char** papszIter = papszLayers;
for( ; *papszIter != NULL; papszIter++ )
{
OGRLayer *poLayer = poDS->GetLayerByName(*papszIter);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch requested layer %s!\n",
*papszIter );
exit( 1 );
}
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer( poLayer, pszWHERE, poSpatialFilter );
}
}
}
/* -------------------------------------------------------------------- */
/* Close down. */
/* -------------------------------------------------------------------- */
CSLDestroy( papszArgv );
CSLDestroy( papszLayers );
CSLDestroy( papszOptions );
OGRDataSource::DestroyDataSource( poDS );
if (poSpatialFilter)
OGRGeometryFactory::destroyGeometry( poSpatialFilter );
OGRCleanupAll();
return 0;
}
int main( int nArgc, char ** papszArgv )
{
const char *pszWHERE = NULL;
const char *pszDataSource = NULL;
char **papszLayers = NULL;
OGRGeometry *poSpatialFilter = NULL;
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
RegisterOGRTAB();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg],"-ro") )
bReadOnly = TRUE;
else if( EQUAL(papszArgv[iArg],"-q") )
bVerbose = FALSE;
else if( EQUAL(papszArgv[iArg],"-spat")
&& papszArgv[iArg+1] != NULL
&& papszArgv[iArg+2] != NULL
&& papszArgv[iArg+3] != NULL
&& papszArgv[iArg+4] != NULL )
{
OGRLinearRing oRing;
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) );
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+4]) );
oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+4]) );
oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+2]) );
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) );
poSpatialFilter = new OGRPolygon();
((OGRPolygon *) poSpatialFilter)->addRing( &oRing );
iArg += 4;
}
else if( EQUAL(papszArgv[iArg],"-where") && papszArgv[iArg+1] != NULL )
{
pszWHERE = papszArgv[++iArg];
}
else if( papszArgv[iArg][0] == '-' )
{
Usage();
}
else if( pszDataSource == NULL )
pszDataSource = papszArgv[iArg];
else
papszLayers = CSLAddString( papszLayers, papszArgv[iArg] );
}
if( pszDataSource == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
OGRDataSource *poDS;
OGRSFDriver *poDriver;
poDS = OGRSFDriverRegistrar::Open( pszDataSource, !bReadOnly, &poDriver );
if( poDS == NULL && !bReadOnly )
{
poDS = OGRSFDriverRegistrar::Open( pszDataSource, FALSE, &poDriver );
if( poDS != NULL && bVerbose )
{
printf( "Had to open data source read-only.\n" );
bReadOnly = TRUE;
}
}
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( poDS == NULL )
{
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
printf( "FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
pszDataSource );
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
printf( " -> %s\n", poR->GetDriver(iDriver)->GetName() );
}
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Some information messages. */
/* -------------------------------------------------------------------- */
if( bVerbose )
printf( "INFO: Open of `%s'\n"
"using driver `%s' successful.\n",
pszDataSource, poDriver->GetName() );
if( bVerbose && !EQUAL(pszDataSource,poDS->GetName()) )
{
printf( "INFO: Internal data source name `%s'\n"
" different from user name `%s'.\n",
poDS->GetName(), pszDataSource );
}
/* -------------------------------------------------------------------- */
/* Process each data source layer. */
/* -------------------------------------------------------------------- */
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer );
exit( 1 );
}
if( CSLCount(papszLayers) == 0 )
{
printf( "%d: %s",
iLayer+1,
poLayer->GetLayerDefn()->GetName() );
if( poLayer->GetLayerDefn()->GetGeomType() != wkbUnknown )
printf( " (%s)",
OGRGeometryTypeToName(
poLayer->GetLayerDefn()->GetGeomType() ) );
printf( "\n" );
}
else if( CSLFindString( papszLayers,
poLayer->GetLayerDefn()->GetName() ) != -1 )
{
ReportOnLayer( poLayer, pszWHERE, poSpatialFilter );
}
}
/* -------------------------------------------------------------------- */
/* Close down. */
/* -------------------------------------------------------------------- */
delete poDS;
#ifdef DBMALLOC
malloc_dump(1);
#endif
return 0;
}
int main( int argc, char ** argv )
{
int i;
int bGotSRS = FALSE;
int bPretty = FALSE;
int bValidate = FALSE;
int bDebug = FALSE;
int bFindEPSG = FALSE;
int nEPSGCode = -1;
const char *pszInput = NULL;
const char *pszOutputType = "default";
OGRSpatialReference oSRS;
/* 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 and OGR drivers. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
#ifdef OGR_ENABLED
OGRRegisterAll();
#endif
/* -------------------------------------------------------------------- */
/* Process --formats option. */
/* Code copied from gcore/gdal_misc.cpp and ogr/ogrutils.cpp. */
/* This is not ideal, but is best for more descriptive output and */
/* we don't want to call OGRGeneralCmdLineProcessor(). */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i], "--formats") )
{
int iDr;
/* GDAL formats */
printf( "Supported Raster Formats:\n" );
for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ )
{
GDALDriverH hDriver = GDALGetDriver(iDr);
const char *pszRWFlag, *pszVirtualIO;
if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) )
pszRWFlag = "rw+";
else if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATECOPY,
NULL ) )
pszRWFlag = "rw";
else
pszRWFlag = "ro";
if( GDALGetMetadataItem( hDriver, GDAL_DCAP_VIRTUALIO, NULL) )
pszVirtualIO = "v";
else
pszVirtualIO = "";
printf( " %s (%s%s): %s\n",
GDALGetDriverShortName( hDriver ),
pszRWFlag, pszVirtualIO,
GDALGetDriverLongName( hDriver ) );
}
/* OGR formats */
#ifdef OGR_ENABLED
printf( "\nSupported Vector Formats:\n" );
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
for( iDr = 0; iDr < poR->GetDriverCount(); iDr++ )
{
OGRSFDriver *poDriver = poR->GetDriver(iDr);
if( poDriver->TestCapability( ODrCCreateDataSource ) )
printf( " -> \"%s\" (read/write)\n",
poDriver->GetName() );
else
printf( " -> \"%s\" (readonly)\n",
poDriver->GetName() );
}
#endif
exit(1);
}
}
/* -------------------------------------------------------------------- */
/* Register standard GDAL drivers, and process generic GDAL */
/* command options. */
/* -------------------------------------------------------------------- */
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], "-e") )
bFindEPSG = TRUE;
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();
}
/* Search for SRS */
bGotSRS = FindSRS( pszInput, oSRS, bDebug );
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 {
/* Find EPSG code - experimental */
if ( EQUAL(pszOutputType,"epsg") )
bFindEPSG = TRUE;
if ( bFindEPSG ) {
CPLError( CE_Warning, CPLE_AppDefined,
"EPSG detection is experimental and requires new data files (see bug #4345)" );
nEPSGCode = FindEPSG( oSRS );
/* If found, replace oSRS based on EPSG code */
if(nEPSGCode != -1) {
CPLDebug( "gdalsrsinfo",
"Found EPSG code %d", nEPSGCode );
OGRSpatialReference oSRS2;
if ( oSRS2.importFromEPSG( nEPSGCode ) == OGRERR_NONE )
oSRS = oSRS2;
}
}
/* 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("default", pszOutputType ) ) {
/* does this work in MSVC? */
const char* papszOutputTypes[] =
{ "proj4", "wkt", NULL };
if ( bFindEPSG )
printf("\nEPSG:%d\n",nEPSGCode);
PrintSRSOutputTypes( oSRS, papszOutputTypes );
}
else if ( EQUAL("all", pszOutputType ) ) {
if ( bFindEPSG )
printf("\nEPSG:%d\n\n",nEPSGCode);
const char* papszOutputTypes[] =
{"proj4","wkt","wkt_simple","wkt_noct","wkt_esri","mapinfo","xml",NULL};
PrintSRSOutputTypes( oSRS, papszOutputTypes );
}
else if ( EQUAL("wkt_all", pszOutputType ) ) {
const char* papszOutputTypes[] =
{ "wkt", "wkt_simple", "wkt_noct", "wkt_esri", NULL };
PrintSRSOutputTypes( oSRS, papszOutputTypes );
}
else {
if ( bPretty )
printf( "\n" );
if ( EQUAL(pszOutputType,"epsg") )
printf("EPSG:%d\n",nEPSGCode);
else
PrintSRS( oSRS, pszOutputType, bPretty, FALSE );
if ( bPretty )
printf( "\n" );
}
}
/* cleanup anything left */
GDALDestroyDriverManager();
#ifdef OGR_ENABLED
OGRCleanupAll();
#endif
CSLDestroy( argv );
return 0;
}
int main( int nArgc, char ** papszArgv )
{
const char *pszDataSource = NULL;
char** papszLayers = NULL;
const char *pszSQLStatement = NULL;
int bRet = TRUE;
/* Must process OGR_SKIP before OGRRegisterAll(), but we can't call */
/* OGRGeneralCmdLineProcessor before it needs the drivers to be registered */
/* for the --format or --formats options */
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--config") && iArg + 2 < nArgc &&
EQUAL(papszArgv[iArg+1], "OGR_SKIP") )
{
CPLSetConfigOption(papszArgv[iArg+1], papszArgv[iArg+2]);
break;
}
}
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 1 )
exit( -nArgc );
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(papszArgv[iArg],"-ro") )
bReadOnly = TRUE;
else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet"))
bVerbose = FALSE;
else if( EQUAL(papszArgv[iArg],"-sql") && iArg + 1 < nArgc)
pszSQLStatement = papszArgv[++iArg];
else if( papszArgv[iArg][0] == '-' )
{
Usage();
}
else if (pszDataSource == NULL)
pszDataSource = papszArgv[iArg];
else
papszLayers = CSLAddString(papszLayers, papszArgv[iArg]);
}
if( pszDataSource == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
OGRDataSource *poDS;
OGRSFDriver *poDriver;
poDS = OGRSFDriverRegistrar::Open( pszDataSource, !bReadOnly, &poDriver );
if( poDS == NULL && !bReadOnly )
{
poDS = OGRSFDriverRegistrar::Open( pszDataSource, FALSE, &poDriver );
if( poDS != NULL && bVerbose )
{
printf( "Had to open data source read-only.\n" );
bReadOnly = TRUE;
}
}
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( poDS == NULL )
{
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
printf( "FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
pszDataSource );
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
printf( " -> %s\n", poR->GetDriver(iDriver)->GetName() );
}
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Some information messages. */
/* -------------------------------------------------------------------- */
if( bVerbose )
printf( "INFO: Open of `%s' using driver `%s' successful.\n",
pszDataSource, poDriver->GetName() );
if( bVerbose && !EQUAL(pszDataSource,poDS->GetName()) )
{
printf( "INFO: Internal data source name `%s'\n"
" different from user name `%s'.\n",
poDS->GetName(), pszDataSource );
}
/* -------------------------------------------------------------------- */
/* Process optionnal SQL request. */
/* -------------------------------------------------------------------- */
if (pszSQLStatement != NULL)
{
OGRLayer *poResultSet = poDS->ExecuteSQL(pszSQLStatement, NULL, NULL);
if (poResultSet == NULL)
exit(1);
printf( "INFO: Testing layer %s.\n",
poResultSet->GetName() );
bRet = TestOGRLayer( poDS, poResultSet, TRUE );
poDS->ReleaseResultSet(poResultSet);
}
/* -------------------------------------------------------------------- */
/* Process each data source layer. */
/* -------------------------------------------------------------------- */
else if (papszLayers == NULL)
{
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer );
exit( 1 );
}
printf( "INFO: Testing layer %s.\n",
poLayer->GetName() );
bRet &= TestOGRLayer( poDS, poLayer, FALSE );
}
}
else
{
/* -------------------------------------------------------------------- */
/* Or process layers specified by the user */
/* -------------------------------------------------------------------- */
char** papszLayerIter = papszLayers;
while (*papszLayerIter)
{
OGRLayer *poLayer = poDS->GetLayerByName(*papszLayerIter);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch requested layer %s!\n",
*papszLayerIter );
exit( 1 );
}
printf( "INFO: Testing layer %s.\n",
poLayer->GetName() );
bRet &= TestOGRLayer( poDS, poLayer, FALSE );
papszLayerIter ++;
}
}
/* -------------------------------------------------------------------- */
/* Close down. */
/* -------------------------------------------------------------------- */
OGRDataSource::DestroyDataSource(poDS);
OGRCleanupAll();
CSLDestroy(papszLayers);
CSLDestroy(papszArgv);
#ifdef DBMALLOC
malloc_dump(1);
#endif
return (bRet) ? 0 : 1;
}
int Delaunay(maps*& conf,maps*& inputs,maps*& outputs){
#ifdef DEBUG
fprintf(stderr,"\nService internal print\nStarting\n");
#endif
maps* cursor=inputs;
OGRGeometryH geometry,res;
int bufferDistance;
map* tmpm=NULL;
OGRRegisterAll();
std::vector<Point> points;
if(int res=parseInput(conf,inputs,&points,"/vsimem/tmp")!=SERVICE_SUCCEEDED)
return res;
DelaunayT T;
T.insert(points.begin(), points.end());
/* -------------------------------------------------------------------- */
/* Try opening the output datasource as an existing, writable */
/* -------------------------------------------------------------------- */
#if GDAL_VERSION_MAJOR >= 2
GDALDataset *poODS;
GDALDriverManager* poR=GetGDALDriverManager();
GDALDriver *poDriver = NULL;
#else
OGRDataSource *poODS;
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
OGRSFDriver *poDriver = NULL;
#endif
int iDriver;
map *tmpMap=getMapFromMaps(outputs,"Result","mimeType");
const char *oDriver;
oDriver="GeoJSON";
if(tmpMap!=NULL){
if(strcmp(tmpMap->value,"text/xml")==0){
oDriver="GML";
}
}
for( iDriver = 0;
iDriver < poR->GetDriverCount() && poDriver == NULL;
iDriver++ )
{
#ifdef DEBUG
#if GDAL_VERSION_MAJOR >= 2
fprintf(stderr,"D:%s\n",poR->GetDriver(iDriver)->GetDescription());
#else
fprintf(stderr,"D:%s\n",poR->GetDriver(iDriver)->GetName());
#endif
#endif
if( EQUAL(
#if GDAL_VERSION_MAJOR >= 2
poR->GetDriver(iDriver)->GetDescription()
#else
poR->GetDriver(iDriver)->GetName()
#endif
,
oDriver) )
{
poDriver = poR->GetDriver(iDriver);
}
}
if( poDriver == NULL )
{
char emessage[8192];
sprintf( emessage, "Unable to find driver `%s'.\n", oDriver );
sprintf( emessage, "%sThe following drivers are available:\n",emessage );
for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
#if GDAL_VERSION_MAJOR >= 2
sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetDescription() );
#else
sprintf( emessage, "%s -> `%s'\n", emessage, poR->GetDriver(iDriver)->GetName() );
#endif
}
setMapInMaps(conf,"lenv","message",emessage);
return SERVICE_FAILED;
}
#if GDAL_VERSION_MAJOR >=2
if( !CPLTestBool( CSLFetchNameValueDef(poDriver->GetMetadata(), GDAL_DCAP_CREATE, "FALSE") ) )
#else
if( !poDriver->TestCapability( ODrCCreateDataSource ) )
#endif
{
char emessage[1024];
sprintf( emessage, "%s driver does not support data source creation.\n",
"json" );
setMapInMaps(conf,"lenv","message",emessage);
return SERVICE_FAILED;
}
/* -------------------------------------------------------------------- */
/* Create the output data source. */
/* -------------------------------------------------------------------- */
char *pszDestDataSource=(char*)malloc(100);
char **papszDSCO=NULL;
sprintf(pszDestDataSource,"/vsimem/result_%d",getpid());
#if GDAL_VERSION_MAJOR >=2
poODS = poDriver->Create( pszDestDataSource, 0, 0, 0, GDT_Unknown, papszDSCO );
#else
poODS = poDriver->CreateDataSource( pszDestDataSource, papszDSCO );
#endif
if( poODS == NULL ){
char emessage[1024];
sprintf( emessage, "%s driver failed to create %s\n",
"json", pszDestDataSource );
setMapInMaps(conf,"lenv","message",emessage);
return SERVICE_FAILED;
}
/* -------------------------------------------------------------------- */
/* Create the layer. */
/* -------------------------------------------------------------------- */
if( !poODS->TestCapability( ODsCCreateLayer ) )
{
char emessage[1024];
sprintf( emessage,
"Layer %s not found, and CreateLayer not supported by driver.",
"Result" );
setMapInMaps(conf,"lenv","message",emessage);
return SERVICE_FAILED;
}
CPLErrorReset();
OGRLayer *poDstLayer = poODS->CreateLayer( "Result", NULL,wkbPolygon,NULL);
if( poDstLayer == NULL ){
setMapInMaps(conf,"lenv","message","Layer creation failed.\n");
return SERVICE_FAILED;
}
for(DelaunayT::Finite_faces_iterator fit = T.finite_faces_begin();
fit != T.finite_faces_end(); ++fit) {
DelaunayT::Face_handle face = fit;
OGRFeatureH hFeature = OGR_F_Create( OGR_L_GetLayerDefn( poDstLayer ) );
OGRGeometryH hCollection = OGR_G_CreateGeometry( wkbGeometryCollection );
OGRGeometryH currLine=OGR_G_CreateGeometry(wkbLinearRing);
OGRGeometryH currPoly=OGR_G_CreateGeometry(wkbPolygon);
OGR_G_AddPoint_2D(currLine,T.triangle(face)[0].x(),T.triangle(face)[0].y());
OGR_G_AddPoint_2D(currLine,T.triangle(face)[1].x(),T.triangle(face)[1].y());
OGR_G_AddPoint_2D(currLine,T.triangle(face)[2].x(),T.triangle(face)[2].y());
OGR_G_AddPoint_2D(currLine,T.triangle(face)[0].x(),T.triangle(face)[0].y());
OGR_G_AddGeometryDirectly( currPoly, currLine );
OGR_G_AddGeometryDirectly( hCollection, currPoly );
OGR_F_SetGeometry( hFeature, hCollection );
OGR_G_DestroyGeometry(hCollection);
if( OGR_L_CreateFeature( poDstLayer, hFeature ) != OGRERR_NONE ){
setMapInMaps(conf,"lenv","message","Failed to create feature in file.\n");
return SERVICE_FAILED;
}
OGR_F_Destroy( hFeature );
}
OGR_DS_Destroy( poODS );
#ifdef DEBUG
std::cerr << "The Voronoi diagram has " << ns << " finite edges "
<< " and " << nr << " rays" << std::endl;
#endif
char *res1=readVSIFile(conf,pszDestDataSource);
if(res1==NULL)
return SERVICE_FAILED;
setMapInMaps(outputs,"Result","value",res1);
free(res1);
if(strcmp(oDriver,"GML")==0)
setMapInMaps(outputs,"Result","mimeType","text/xml");
else
setMapInMaps(outputs,"Result","mimeType","application/json");
setMapInMaps(outputs,"Result","encoding","UTF-8");
OGRCleanupAll();
return SERVICE_SUCCEEDED;
}
MAIN_START(nArgc, papszArgv)
{
// Check strict compilation and runtime library version as we use C++ API.
if( !GDAL_CHECK_VERSION(papszArgv[0]) )
exit(1);
EarlySetConfigOptions(nArgc, papszArgv);
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor(nArgc, &papszArgv, 0);
if( nArgc < 1 )
exit(-nArgc);
char *pszWHERE = nullptr;
const char *pszDataSource = nullptr;
char **papszLayers = nullptr;
OGRGeometry *poSpatialFilter = nullptr;
int nRepeatCount = 1;
bool bAllLayers = false;
char *pszSQLStatement = nullptr;
const char *pszDialect = nullptr;
int nRet = 0;
const char* pszGeomField = nullptr;
char **papszOpenOptions = nullptr;
char **papszExtraMDDomains = nullptr;
bool bListMDD = false;
bool bShowMetadata = true;
bool bFeatureCount = true;
bool bExtent = true;
bool bDatasetGetNextFeature = false;
bool bReadOnly = false;
bool bUpdate = false;
const char* pszWKTFormat = "WKT2";
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and "
"is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME,
GDALVersionInfo("RELEASE_NAME"));
CSLDestroy(papszArgv);
return 0;
}
else if( EQUAL(papszArgv[iArg], "--help") )
{
Usage();
}
else if( EQUAL(papszArgv[iArg], "-ro") )
{
bReadOnly = true;
}
else if( EQUAL(papszArgv[iArg], "-update") )
{
bUpdate = true;
}
else if( EQUAL(papszArgv[iArg], "-q") ||
EQUAL(papszArgv[iArg], "-quiet"))
{
bVerbose = false;
}
else if( EQUAL(papszArgv[iArg], "-qq") )
{
/* Undocumented: mainly only useful for AFL testing */
bVerbose = false;
bSuperQuiet = true;
}
else if( EQUAL(papszArgv[iArg], "-fid") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
nFetchFID = CPLAtoGIntBig(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-spat") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(4);
OGRLinearRing oRing;
oRing.addPoint(CPLAtof(papszArgv[iArg+1]),
CPLAtof(papszArgv[iArg+2]));
oRing.addPoint(CPLAtof(papszArgv[iArg+1]),
CPLAtof(papszArgv[iArg+4]));
oRing.addPoint(CPLAtof(papszArgv[iArg+3]),
CPLAtof(papszArgv[iArg+4]));
oRing.addPoint(CPLAtof(papszArgv[iArg+3]),
CPLAtof(papszArgv[iArg+2]));
oRing.addPoint(CPLAtof(papszArgv[iArg+1]),
CPLAtof(papszArgv[iArg+2]));
poSpatialFilter = new OGRPolygon();
static_cast<OGRPolygon *>(poSpatialFilter)->addRing(&oRing);
iArg += 4;
}
else if( EQUAL(papszArgv[iArg], "-geomfield") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszGeomField = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg], "-where") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
iArg++;
CPLFree(pszWHERE);
GByte* pabyRet = nullptr;
if( papszArgv[iArg][0] == '@' &&
VSIIngestFile(nullptr, papszArgv[iArg] + 1, &pabyRet,
nullptr, 1024*1024) )
{
RemoveBOM(pabyRet);
pszWHERE = reinterpret_cast<char *>(pabyRet);
}
else
{
pszWHERE = CPLStrdup(papszArgv[iArg]);
}
}
else if( EQUAL(papszArgv[iArg], "-sql") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
iArg++;
CPLFree(pszSQLStatement);
GByte* pabyRet = nullptr;
if( papszArgv[iArg][0] == '@' &&
VSIIngestFile(nullptr, papszArgv[iArg] + 1, &pabyRet,
nullptr, 1024*1024) )
{
RemoveBOM(pabyRet);
pszSQLStatement = reinterpret_cast<char *>(pabyRet);
RemoveSQLComments(pszSQLStatement);
}
else
{
pszSQLStatement = CPLStrdup(papszArgv[iArg]);
}
}
else if( EQUAL(papszArgv[iArg], "-dialect") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszDialect = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg], "-rc") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
nRepeatCount = atoi(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-al") )
{
bAllLayers = true;
}
else if( EQUAL(papszArgv[iArg], "-so") ||
EQUAL(papszArgv[iArg], "-summary") )
{
bSummaryOnly = true;
}
else if( STARTS_WITH_CI(papszArgv[iArg], "-fields=") )
{
char* pszTemp =
static_cast<char *>(CPLMalloc(32 + strlen(papszArgv[iArg])));
snprintf(pszTemp,
32 + strlen(papszArgv[iArg]),
"DISPLAY_FIELDS=%s", papszArgv[iArg] + strlen("-fields="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( STARTS_WITH_CI(papszArgv[iArg], "-geom=") )
{
char* pszTemp =
static_cast<char *>(CPLMalloc(32 + strlen(papszArgv[iArg])));
snprintf(pszTemp,
32 + strlen(papszArgv[iArg]),
"DISPLAY_GEOMETRY=%s", papszArgv[iArg] + strlen("-geom="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( EQUAL(papszArgv[iArg], "-oo") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszOpenOptions = CSLAddString(papszOpenOptions,
papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-nomd") )
{
bShowMetadata = false;
}
else if( EQUAL(papszArgv[iArg], "-listmdd") )
{
bListMDD = true;
}
else if( EQUAL(papszArgv[iArg], "-mdd") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszExtraMDDomains = CSLAddString(papszExtraMDDomains,
papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-nocount") )
{
bFeatureCount = false;
}
else if( EQUAL(papszArgv[iArg], "-noextent") )
{
bExtent = false;
}
else if( EQUAL(papszArgv[iArg], "-rl"))
{
bDatasetGetNextFeature = true;
}
else if( EQUAL(papszArgv[iArg], "-wkt_format") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszWKTFormat = papszArgv[++iArg];
}
else if( papszArgv[iArg][0] == '-' )
{
Usage(CPLSPrintf("Unknown option name '%s'", papszArgv[iArg]));
}
else if( pszDataSource == nullptr )
{
pszDataSource = papszArgv[iArg];
}
else
{
papszLayers = CSLAddString(papszLayers, papszArgv[iArg]);
bAllLayers = false;
}
}
if( pszDataSource == nullptr )
Usage("No datasource specified.");
if( pszDialect != nullptr && pszWHERE != nullptr &&
pszSQLStatement == nullptr )
printf("Warning: -dialect is ignored with -where. Use -sql instead");
if( bDatasetGetNextFeature && pszSQLStatement )
{
Usage("-rl is incompatible with -sql");
}
#ifdef __AFL_HAVE_MANUAL_CONTROL
while (__AFL_LOOP(1000)) {
#endif
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
GDALDataset *poDS = static_cast<GDALDataset *>(GDALOpenEx(
pszDataSource,
((bReadOnly || pszSQLStatement == nullptr) &&
!bUpdate ? GDAL_OF_READONLY : GDAL_OF_UPDATE) | GDAL_OF_VECTOR,
nullptr, papszOpenOptions, nullptr));
if( poDS == nullptr && !bReadOnly && !bUpdate &&
pszSQLStatement == nullptr )
{
// In some cases (empty geopackage for example), opening in read-only
// mode fails, so retry in update mode
if( GDALIdentifyDriverEx(pszDataSource, GDAL_OF_VECTOR,
nullptr, nullptr) )
{
poDS = static_cast<GDALDataset *>(GDALOpenEx(
pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_VECTOR, nullptr,
papszOpenOptions, nullptr));
}
}
if( poDS == nullptr && !bReadOnly && !bUpdate &&
pszSQLStatement != nullptr )
{
poDS = static_cast<GDALDataset *>(GDALOpenEx(
pszDataSource,
GDAL_OF_READONLY | GDAL_OF_VECTOR, nullptr,
papszOpenOptions, nullptr));
if( poDS != nullptr && bVerbose )
{
printf("Had to open data source read-only.\n");
#ifdef __AFL_HAVE_MANUAL_CONTROL
bReadOnly = true;
#endif
}
}
GDALDriver *poDriver = nullptr;
if( poDS != nullptr )
poDriver = poDS->GetDriver();
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( poDS == nullptr )
{
printf("FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
pszDataSource);
#ifdef __AFL_HAVE_MANUAL_CONTROL
continue;
#else
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
printf(" -> %s\n", poR->GetDriver(iDriver)->GetDescription());
}
nRet = 1;
goto end;
#endif
}
CPLAssert(poDriver != nullptr);
/* -------------------------------------------------------------------- */
/* Some information messages. */
/* -------------------------------------------------------------------- */
if( bVerbose )
printf("INFO: Open of `%s'\n"
" using driver `%s' successful.\n",
pszDataSource, poDriver->GetDescription());
if( bVerbose && !EQUAL(pszDataSource,poDS->GetDescription()) )
{
printf("INFO: Internal data source name `%s'\n"
" different from user name `%s'.\n",
poDS->GetDescription(), pszDataSource);
}
GDALInfoReportMetadata(static_cast<GDALMajorObjectH>(poDS),
bListMDD,
bShowMetadata,
papszExtraMDDomains);
if( bDatasetGetNextFeature )
{
nRepeatCount = 0; // skip layer reporting.
/* -------------------------------------------------------------------- */
/* Set filters if provided. */
/* -------------------------------------------------------------------- */
if( pszWHERE != nullptr || poSpatialFilter != nullptr )
{
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == nullptr )
{
printf("FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer);
exit(1);
}
if( pszWHERE != nullptr )
{
if( poLayer->SetAttributeFilter(pszWHERE) != OGRERR_NONE )
{
printf("WARNING: SetAttributeFilter(%s) "
"failed on layer %s.\n",
pszWHERE, poLayer->GetName());
}
}
if( poSpatialFilter != nullptr )
{
if( pszGeomField != nullptr )
{
OGRFeatureDefn *poDefn = poLayer->GetLayerDefn();
const int iGeomField =
poDefn->GetGeomFieldIndex(pszGeomField);
if( iGeomField >= 0 )
poLayer->SetSpatialFilter(iGeomField,
poSpatialFilter);
else
printf("WARNING: Cannot find geometry field %s.\n",
pszGeomField);
}
else
{
poLayer->SetSpatialFilter(poSpatialFilter);
}
}
}
}
std::set<OGRLayer*> oSetLayers;
while( true )
{
OGRLayer* poLayer = nullptr;
OGRFeature* poFeature = poDS->GetNextFeature(&poLayer, nullptr,
nullptr, nullptr);
if( poFeature == nullptr )
break;
if( papszLayers == nullptr || poLayer == nullptr ||
CSLFindString(papszLayers, poLayer->GetName()) >= 0 )
{
if( bVerbose && poLayer != nullptr &&
oSetLayers.find(poLayer) == oSetLayers.end() )
{
oSetLayers.insert(poLayer);
const bool bSummaryOnlyBackup = bSummaryOnly;
bSummaryOnly = true;
ReportOnLayer(poLayer, nullptr, nullptr, nullptr,
bListMDD, bShowMetadata,
papszExtraMDDomains,
bFeatureCount,
bExtent,
pszWKTFormat);
bSummaryOnly = bSummaryOnlyBackup;
}
if( !bSuperQuiet && !bSummaryOnly )
poFeature->DumpReadable(nullptr, papszOptions);
}
OGRFeature::DestroyFeature(poFeature);
}
}
/* -------------------------------------------------------------------- */
/* Special case for -sql clause. No source layers required. */
/* -------------------------------------------------------------------- */
else if( pszSQLStatement != nullptr )
{
nRepeatCount = 0; // skip layer reporting.
if( CSLCount(papszLayers) > 0 )
printf("layer names ignored in combination with -sql.\n");
OGRLayer *poResultSet =
poDS->ExecuteSQL(
pszSQLStatement,
pszGeomField == nullptr ? poSpatialFilter : nullptr,
pszDialect);
if( poResultSet != nullptr )
{
if( pszWHERE != nullptr )
{
if( poResultSet->SetAttributeFilter(pszWHERE) != OGRERR_NONE )
{
printf("FAILURE: SetAttributeFilter(%s) failed.\n",
pszWHERE);
exit(1);
}
}
if( pszGeomField != nullptr )
ReportOnLayer(poResultSet, nullptr,
pszGeomField, poSpatialFilter,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
else
ReportOnLayer(poResultSet, nullptr, nullptr, nullptr,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
poDS->ReleaseResultSet(poResultSet);
}
}
// coverity[tainted_data]
for( int iRepeat = 0; iRepeat < nRepeatCount; iRepeat++ )
{
if( papszLayers == nullptr || *papszLayers == nullptr )
{
if( iRepeat == 0 )
CPLDebug("OGR", "GetLayerCount() = %d\n",
poDS->GetLayerCount());
/* -------------------------------------------------------------------- */
/* Process each data source layer. */
/* -------------------------------------------------------------------- */
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == nullptr )
{
printf("FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer);
exit(1);
}
if( !bAllLayers )
{
printf("%d: %s", iLayer + 1, poLayer->GetName());
const int nGeomFieldCount =
poLayer->GetLayerDefn()->GetGeomFieldCount();
if( nGeomFieldCount > 1 )
{
printf(" (");
for( int iGeom = 0; iGeom < nGeomFieldCount; iGeom++ )
{
if( iGeom > 0 )
printf(", ");
OGRGeomFieldDefn* poGFldDefn =
poLayer->GetLayerDefn()->
GetGeomFieldDefn(iGeom);
printf(
"%s",
OGRGeometryTypeToName(
poGFldDefn->GetType()));
}
printf(")");
}
else if( poLayer->GetGeomType() != wkbUnknown )
printf(" (%s)",
OGRGeometryTypeToName(
poLayer->GetGeomType()));
printf("\n");
}
else
{
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer(poLayer, pszWHERE,
pszGeomField, poSpatialFilter,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
}
}
}
else
{
/* -------------------------------------------------------------------- */
/* Process specified data source layers. */
/* -------------------------------------------------------------------- */
for( char** papszIter = papszLayers;
*papszIter != nullptr;
++papszIter )
{
OGRLayer *poLayer = poDS->GetLayerByName(*papszIter);
if( poLayer == nullptr )
{
printf("FAILURE: Couldn't fetch requested layer %s!\n",
*papszIter);
exit(1);
}
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer(poLayer, pszWHERE, pszGeomField, poSpatialFilter,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
}
}
}
/* -------------------------------------------------------------------- */
/* Close down. */
/* -------------------------------------------------------------------- */
GDALClose(poDS);
#ifdef __AFL_HAVE_MANUAL_CONTROL
}
#else
end:
#endif
CSLDestroy(papszArgv);
CSLDestroy(papszLayers);
CSLDestroy(papszOptions);
CSLDestroy(papszOpenOptions);
CSLDestroy(papszExtraMDDomains);
if( poSpatialFilter )
OGRGeometryFactory::destroyGeometry(poSpatialFilter);
CPLFree(pszSQLStatement);
CPLFree(pszWHERE);
OGRCleanupAll();
return nRet;
}
static void Usage(const char* pszAdditionalMsg, int bShort)
{
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
printf( "Usage: ogr2ogr [--help-general] [-skipfailures] [-append] [-update]\n"
" [-select field_list] [-where restricted_where|@filename]\n"
" [-progress] [-sql <sql statement>|@filename] [-dialect dialect]\n"
" [-preserve_fid] [-fid FID]\n"
" [-spat xmin ymin xmax ymax] [-spat_srs srs_def] [-geomfield field]\n"
" [-a_srs srs_def] [-t_srs srs_def] [-s_srs srs_def]\n"
" [-f format_name] [-overwrite] [[-dsco NAME=VALUE] ...]\n"
" dst_datasource_name src_datasource_name\n"
" [-lco NAME=VALUE] [-nln name] \n"
" [-nlt type|PROMOTE_TO_MULTI|CONVERT_TO_LINEAR|CONVERT_TO_CURVE]\n"
" [-dim 2|3|layer_dim] [layer [layer ...]]\n"
"\n"
"Advanced options :\n"
" [-gt n] [-ds_transaction]\n"
" [[-oo NAME=VALUE] ...] [[-doo NAME=VALUE] ...]\n"
" [-clipsrc [xmin ymin xmax ymax]|WKT|datasource|spat_extent]\n"
" [-clipsrcsql sql_statement] [-clipsrclayer layer]\n"
" [-clipsrcwhere expression]\n"
" [-clipdst [xmin ymin xmax ymax]|WKT|datasource]\n"
" [-clipdstsql sql_statement] [-clipdstlayer layer]\n"
" [-clipdstwhere expression]\n"
" [-wrapdateline][-datelineoffset val]\n"
" [[-simplify tolerance] | [-segmentize max_dist]]\n"
" [-addfields] [-unsetFid]\n"
" [-relaxedFieldNameMatch] [-forceNullable] [-unsetDefault]\n"
" [-fieldTypeToString All|(type1[,type2]*)] [-unsetFieldWidth]\n"
" [-mapFieldType srctype|All=dsttype[,srctype2=dsttype2]*]\n"
" [-fieldmap identity | index1[,index2]*]\n"
" [-splitlistfields] [-maxsubfields val]\n"
" [-explodecollections] [-zfield field_name]\n"
" [-gcp pixel line easting northing [elevation]]* [-order n | -tps]\n"
" [-nomd] [-mo \"META-TAG=VALUE\"]* [-noNativeData]\n");
if (bShort)
{
printf( "\nNote: ogr2ogr --long-usage for full help.\n");
if( pszAdditionalMsg )
fprintf(stderr, "\nFAILURE: %s\n", pszAdditionalMsg);
exit( 1 );
}
printf("\n -f format_name: output file format name, possible values are:\n");
std::vector<CPLString> aoSetDrivers;
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
GDALDriver *poDriver = poR->GetDriver(iDriver);
if( CPLTestBool( CSLFetchNameValueDef(poDriver->GetMetadata(), GDAL_DCAP_CREATE, "FALSE") ) )
aoSetDrivers.push_back( poDriver->GetDescription() );
}
std::sort (aoSetDrivers.begin(), aoSetDrivers.end(), StringCISortFunction);
for( size_t i = 0; i < aoSetDrivers.size(); i++ )
{
printf( " -f \"%s\"\n", aoSetDrivers[i].c_str() );
}
printf( " -append: Append to existing layer instead of creating new if it exists\n"
" -overwrite: delete the output layer and recreate it empty\n"
" -update: Open existing output datasource in update mode\n"
" -progress: Display progress on terminal. Only works if input layers have the \n"
" \"fast feature count\" capability\n"
" -select field_list: Comma-delimited list of fields from input layer to\n"
" copy to the new layer (defaults to all)\n"
" -where restricted_where: Attribute query (like SQL WHERE)\n"
" -wrapdateline: split geometries crossing the dateline meridian\n"
" (long. = +/- 180deg)\n"
" -datelineoffset: offset from dateline in degrees\n"
" (default long. = +/- 10deg,\n"
" geometries within 170deg to -170deg will be split)\n"
" -sql statement: Execute given SQL statement and save result.\n"
" -dialect value: select a dialect, usually OGRSQL to avoid native sql.\n"
" -skipfailures: skip features or layers that fail to convert\n"
" -gt n: group n features per transaction (default 20000). n can be set to unlimited\n"
" -spat xmin ymin xmax ymax: spatial query extents\n"
" -simplify tolerance: distance tolerance for simplification.\n"
" -segmentize max_dist: maximum distance between 2 nodes.\n"
" Used to create intermediate points\n"
" -dsco NAME=VALUE: Dataset creation option (format specific)\n"
" -lco NAME=VALUE: Layer creation option (format specific)\n"
" -oo NAME=VALUE: Input dataset open option (format specific)\n"
" -doo NAME=VALUE: Destination dataset open option (format specific)\n"
" -nln name: Assign an alternate name to the new layer\n"
" -nlt type: Force a geometry type for new layer. One of NONE, GEOMETRY,\n"
" POINT, LINESTRING, POLYGON, GEOMETRYCOLLECTION, MULTIPOINT,\n"
" MULTIPOLYGON, or MULTILINESTRING, or PROMOTE_TO_MULTI or CONVERT_TO_LINEAR. Add \"25D\" for 3D layers.\n"
" Default is type of source layer.\n"
" -dim dimension: Force the coordinate dimension to the specified value.\n"
" -fieldTypeToString type1,...: Converts fields of specified types to\n"
" fields of type string in the new layer. Valid types are : Integer,\n"
" Integer64, Real, String, Date, Time, DateTime, Binary, IntegerList, Integer64List, RealList,\n"
" StringList. Special value All will convert all fields to strings.\n"
" -fieldmap index1,index2,...: Specifies the list of field indexes to be\n"
" copied from the source to the destination. The (n)th value specified\n"
" in the list is the index of the field in the target layer definition\n"
" in which the n(th) field of the source layer must be copied. Index count\n"
" starts at zero. There must be exactly as many values in the list as\n"
" the count of the fields in the source layer. We can use the 'identity'\n"
" setting to specify that the fields should be transferred by using the\n"
" same order. This setting should be used along with the append setting.");
printf(" -a_srs srs_def: Assign an output SRS\n"
" -t_srs srs_def: Reproject/transform to this SRS on output\n"
" -s_srs srs_def: Override source SRS\n"
"\n"
" Srs_def can be a full WKT definition (hard to escape properly),\n"
" or a well known definition (i.e. EPSG:4326) or a file with a WKT\n"
" definition.\n" );
if( pszAdditionalMsg )
fprintf(stderr, "\nFAILURE: %s\n", pszAdditionalMsg);
}
int main( int nArgc, char ** papszArgv )
{
GDALDatasetH hDS = NULL;
GDALDatasetH hODS = NULL;
int bCloseODS = TRUE;
int bUsageError = FALSE;
GDALDatasetH hDstDS;
int nRetCode = 1;
GDALVectorTranslateOptionsForBinary* psOptionsForBinary;
GDALVectorTranslateOptions *psOptions;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(papszArgv[0]))
exit(1);
EarlySetConfigOptions(nArgc, papszArgv);
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 1 )
{
papszArgv = NULL;
nRetCode = -nArgc;
goto exit;
}
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
nRetCode = 0;
goto exit;
}
else if( EQUAL(papszArgv[iArg],"--help") )
{
Usage();
goto exit;
}
else if ( EQUAL(papszArgv[iArg], "--long-usage") )
{
Usage(FALSE);
goto exit;
}
}
psOptionsForBinary = GDALVectorTranslateOptionsForBinaryNew();
psOptions = GDALVectorTranslateOptionsNew(papszArgv + 1, psOptionsForBinary);
if( psOptions == NULL )
{
Usage();
GDALVectorTranslateOptionsForBinaryFree(psOptionsForBinary);
goto exit;
}
if( psOptionsForBinary->pszDataSource == NULL ||
psOptionsForBinary->pszDestDataSource == NULL )
{
if( psOptionsForBinary->pszDestDataSource == NULL )
Usage("no target datasource provided");
else
Usage("no source datasource provided");
GDALVectorTranslateOptionsFree(psOptions);
GDALVectorTranslateOptionsForBinaryFree(psOptionsForBinary);
goto exit;
}
if( strcmp(psOptionsForBinary->pszDestDataSource, "/vsistdout/") == 0 )
psOptionsForBinary->bQuiet = TRUE;
if (!psOptionsForBinary->bQuiet && !psOptionsForBinary->bFormatExplicitlySet &&
psOptionsForBinary->eAccessMode == ACCESS_CREATION)
{
CheckDestDataSourceNameConsistency(psOptionsForBinary->pszDestDataSource,
psOptionsForBinary->pszFormat);
}
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
/* Avoid opening twice the same datasource if it is both the input and output */
/* Known to cause problems with at least FGdb, SQlite and GPKG drivers. See #4270 */
if (psOptionsForBinary->eAccessMode != ACCESS_CREATION &&
strcmp(psOptionsForBinary->pszDestDataSource, psOptionsForBinary->pszDataSource) == 0)
{
hODS = GDALOpenEx( psOptionsForBinary->pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_VECTOR, NULL, psOptionsForBinary->papszOpenOptions, NULL );
GDALDriverH hDriver = NULL;
if( hODS != NULL )
hDriver = GDALGetDatasetDriver(hODS);
/* Restrict to those 3 drivers. For example it is known to break with */
/* the PG driver due to the way it manages transactions... */
if (hDriver && !(EQUAL(GDALGetDescription(hDriver), "FileGDB") ||
EQUAL(GDALGetDescription(hDriver), "SQLite") ||
EQUAL(GDALGetDescription(hDriver), "GPKG")))
{
hDS = GDALOpenEx( psOptionsForBinary->pszDataSource,
GDAL_OF_VECTOR, NULL, psOptionsForBinary->papszOpenOptions, NULL );
}
else
{
hDS = hODS;
bCloseODS = FALSE;
}
}
else
{
hDS = GDALOpenEx( psOptionsForBinary->pszDataSource,
GDAL_OF_VECTOR, NULL, psOptionsForBinary->papszOpenOptions, NULL );
}
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( hDS == NULL )
{
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
fprintf( stderr, "FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
psOptionsForBinary->pszDataSource );
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
fprintf( stderr, " -> %s\n", poR->GetDriver(iDriver)->GetDescription() );
}
GDALVectorTranslateOptionsFree(psOptions);
GDALVectorTranslateOptionsForBinaryFree(psOptionsForBinary);
goto exit;
}
if( !(psOptionsForBinary->bQuiet) )
{
GDALVectorTranslateOptionsSetProgress(psOptions, GDALTermProgress, NULL);
}
hDstDS = GDALVectorTranslate(psOptionsForBinary->pszDestDataSource, hODS,
1, &hDS, psOptions, &bUsageError);
if( bUsageError )
Usage();
else
nRetCode = (hDstDS) ? 0 : 1;
GDALVectorTranslateOptionsFree(psOptions);
GDALVectorTranslateOptionsForBinaryFree(psOptionsForBinary);
if(hDS)
GDALClose(hDS);
if(bCloseODS)
GDALClose(hDstDS);
exit:
CSLDestroy( papszArgv );
OGRCleanupAll();
return nRetCode;
}
