FBErr FBProjectGdal::writeDataFileFirst (QString strPath)
{
// Open existing GDAL dataset.
// NOTE: we do not need do set specific GDAL opening settings, while it was
// done during the creation of this project IN THIS SESSION of the program
// (otherwise this method just will have not be called).
QByteArray ba = strDatasetPath.toUtf8();
GDALDataset *datasetSrc = (GDALDataset*) GDALOpenEx(ba.data(),
GDAL_OF_VECTOR, NULL, NULL, NULL);
if (datasetSrc == NULL)
{
FBProject::CUR_ERR_INFO = QObject::tr("Unable to open source dataset to"
" copy its layer");
return FBErrGDALFail;
}
// Copy layer from the source dataset to the GeoJSON new dataset of the .ngfp
// file. All fields and geometry changes will be also done inside this method.
FBErr err = this->writeDataFile(datasetSrc, strPath);
GDALClose(datasetSrc);
if (err != FBErrNone)
return err;
return FBErrNone;
}
QVector<QgsDataItem *> QgsOgrDataCollectionItem::createChildren()
{
QVector<QgsDataItem *> children;
QStringList skippedLayerNames;
char **papszOptions = nullptr;
papszOptions = CSLSetNameValue( papszOptions, "@LIST_ALL_TABLES", "YES" );
gdal::dataset_unique_ptr hDataSource( GDALOpenEx( mPath.toUtf8().constData(), GDAL_OF_VECTOR, nullptr, papszOptions, nullptr ) );
CSLDestroy( papszOptions );
GDALDriverH hDriver = GDALGetDatasetDriver( hDataSource.get() );
QString driverName = QString::fromUtf8( GDALGetDriverShortName( hDriver ) );
if ( driverName == QStringLiteral( "SQLite" ) )
{
skippedLayerNames = QgsSqliteUtils::systemTables();
}
if ( !hDataSource )
return children;
int numLayers = GDALDatasetGetLayerCount( hDataSource.get() );
// Check if layer names are unique, so we can use |layername= in URI
QMap< QString, int > mapLayerNameToCount;
QList< int > skippedLayers;
bool uniqueNames = true;
for ( int i = 0; i < numLayers; ++i )
{
OGRLayerH hLayer = GDALDatasetGetLayer( hDataSource.get(), i );
OGRFeatureDefnH hDef = OGR_L_GetLayerDefn( hLayer );
QString layerName = QString::fromUtf8( OGR_FD_GetName( hDef ) );
++mapLayerNameToCount[layerName];
if ( mapLayerNameToCount[layerName] > 1 )
{
uniqueNames = false;
break;
}
if ( ( driverName == QStringLiteral( "SQLite" ) && layerName.contains( QRegularExpression( QStringLiteral( "idx_.*_geometry($|_.*)" ) ) ) )
|| skippedLayerNames.contains( layerName ) )
{
skippedLayers << i;
}
}
children.reserve( numLayers );
for ( int i = 0; i < numLayers; ++i )
{
if ( !skippedLayers.contains( i ) )
{
QgsOgrLayerItem *item = dataItemForLayer( this, QString(), mPath, hDataSource.get(), i, true, uniqueNames );
children.append( item );
}
}
return children;
}
OGRDataSourceH OGROpenShared( const char *pszName, int bUpdate,
OGRSFDriverH *pahDriverList )
{
VALIDATE_POINTER1( pszName, "OGROpenShared", NULL );
GDALDatasetH hDS = GDALOpenEx(pszName, GDAL_OF_VECTOR |
((bUpdate) ? GDAL_OF_UPDATE: 0) | GDAL_OF_SHARED, NULL, NULL, NULL);
if( hDS != NULL && pahDriverList != NULL )
*pahDriverList = (OGRSFDriverH) GDALGetDatasetDriver(hDS);
return (OGRDataSourceH) hDS;
}
int GNMDatabaseNetwork::CheckNetworkExist(const char *pszFilename, char **papszOptions)
{
// check if path exist
// if path exist check if network already present and OVERWRITE option
// else create the path
if(FormName(pszFilename, papszOptions) != CE_None)
{
return TRUE;
}
if(NULL == m_poDS)
{
m_poDS = (GDALDataset*) GDALOpenEx( m_soNetworkFullName, GDAL_OF_VECTOR |
GDAL_OF_UPDATE, NULL, NULL, papszOptions );
}
const bool bOverwrite = CPLFetchBool(papszOptions, "OVERWRITE", false);
std::vector<int> anDeleteLayers;
int i;
for(i = 0; i < m_poDS->GetLayerCount(); ++i)
{
OGRLayer* poLayer = m_poDS->GetLayer(i);
if(NULL == poLayer)
continue;
if(EQUAL(poLayer->GetName(), GNM_SYSLAYER_META) ||
EQUAL(poLayer->GetName(), GNM_SYSLAYER_GRAPH) ||
EQUAL(poLayer->GetName(), GNM_SYSLAYER_FEATURES) )
{
anDeleteLayers.push_back(i);
}
}
if(anDeleteLayers.empty())
return FALSE;
if( bOverwrite )
{
for(i = (int)anDeleteLayers.size(); i > 0; i--)
{
CPLDebug("GNM", "Delete layer: %d", i);
if(m_poDS->DeleteLayer(anDeleteLayers[i - 1]) != OGRERR_NONE)
return TRUE;
}
return FALSE;
}
else
{
return TRUE;
}
}
GDALDataset* geGdalVSI::VsiGdalOpenInternalWrap(
std::string* const vsifile,
const std::string& image_alpha) {
GDALDatasetH hvsi_ds;
khMutex &mutex = GetMutex();
khLockGuard lock(mutex);
*vsifile = UniqueVSIFilename();
VSIFCloseL(VSIFileFromMemBuffer((*vsifile).c_str(),
reinterpret_cast<GByte*>
(const_cast<char*>(&(image_alpha[0]))),
image_alpha.size(), FALSE));
hvsi_ds = GDALOpenEx((*vsifile).c_str(), GA_ReadOnly,
kGdalAllowedDrivers, NULL, NULL);
return static_cast<GDALDataset*>(hvsi_ds);
}
boost::shared_ptr<GDALDataset> OgrUtilities::openDataSource(const QString url, bool readonly)
{
/* Check for the correct driver name, if unknown try all drivers.
* This can be an issue because drivers are tried in the order that they are
* loaded which has been known to cause issues.
*/
OgrDriverInfo driverInfo = getDriverInfo(url, readonly);
// With GDALOpenEx, we need to specify the GDAL_OF_UPDATE option or the dataset will get opened
// Read Only.
if (! readonly)
{
driverInfo._driverType = driverInfo._driverType | GDAL_OF_UPDATE;
}
LOG_VART(driverInfo._driverName);
LOG_VART(driverInfo._driverType);
LOG_VART(url.toUtf8().data());
const char* drivers[2] = { driverInfo._driverName, NULL };
// Setup read options for various file types
OgrOptions options;
if (QString(driverInfo._driverName) == "CSV")
{
options["X_POSSIBLE_NAMES"] = ConfigOptions().getOgrReaderCsvLonfield();
options["Y_POSSIBLE_NAMES"] = ConfigOptions().getOgrReaderCsvLatfield();
// options["Z_POSSIBLE_NAMES"] = ConfigOptions().getOgrReaderCsvZfield();
options["KEEP_GEOM_COLUMNS"] = ConfigOptions().getOgrReaderCsvKeepGeomFields();
}
if (QString(driverInfo._driverName) == "OGR_OGDI")
{
// From the GDAL docs:
// From GDAL/OGR 1.8.0, setting the OGR_OGDI_LAUNDER_LAYER_NAMES configuration option
// (or environment variable) to YES causes the layer names to be simplified.
// For example : watrcrsl_hydro instead of 'watrcrsl@hydro(*)_line'
options["OGR_OGDI_LAUNDER_LAYER_NAMES"] = ConfigOptions().getOgrReaderOgdiLaunderLayerNames();
}
boost::shared_ptr<GDALDataset> result(static_cast<GDALDataset*>(GDALOpenEx(url.toUtf8().data(),
driverInfo._driverType, (driverInfo._driverName != NULL ? drivers : NULL), options.getCrypticOptions(), NULL)));
if (!result)
throw HootException("Unable to open: " + url);
return result;
}
QVector<QgsDataItem *> QgsOgrDataCollectionItem::createChildren()
{
QVector<QgsDataItem *> children;
gdal::dataset_unique_ptr hDataSource( GDALOpenEx( mPath.toUtf8().constData(), GDAL_OF_VECTOR, nullptr, nullptr, nullptr ) );
if ( !hDataSource )
return children;
int numLayers = GDALDatasetGetLayerCount( hDataSource.get() );
children.reserve( numLayers );
for ( int i = 0; i < numLayers; ++i )
{
QgsOgrLayerItem *item = dataItemForLayer( this, QString(), mPath, hDataSource.get(), i, true );
children.append( item );
}
return children;
}
// Read from a RAM Tiff. This is rather generic
static CPLErr DecompressTIF(buf_mgr &dst, buf_mgr &src, const ILImage &img)
{
CPLString fname = uniq_memfname("mrf_tif_read");
VSILFILE *fp = VSIFileFromMemBuffer(fname, (GByte *)(src.buffer), src.size, false);
// Comes back opened, but we can't use it
if (fp)
VSIFCloseL(fp);
else {
CPLError(CE_Failure,CPLE_AppDefined,
"MRF: TIFF, can't open %s as a temp file", fname.c_str());
return CE_Failure;
}
#if GDAL_VERSION_MAJOR >= 2
const char* const apszAllowedDrivers[] = { "GTiff", NULL };
GDALDataset *poTiff = reinterpret_cast<GDALDataset*>(GDALOpenEx(fname, GDAL_OF_RASTER, apszAllowedDrivers, NULL, NULL));
#else
GDALDataset *poTiff = reinterpret_cast<GDALDataset*>(GDALOpen(fname, GA_ReadOnly));
#endif
if (poTiff == NULL) {
CPLError(CE_Failure,CPLE_AppDefined,
"MRF: TIFF, can't open page as a Tiff");
VSIUnlink(fname);
return CE_Failure;
}
CPLErr ret;
// Bypass the GDAL caching
if (img.pagesize.c == 1) {
ret = poTiff->GetRasterBand(1)->ReadBlock(0,0,dst.buffer);
} else {
ret = poTiff->RasterIO(GF_Read,0,0,img.pagesize.x,img.pagesize.y,
dst.buffer, img.pagesize.x, img.pagesize.y, img.dt, img.pagesize.c,
NULL, 0,0,0
#if GDAL_VERSION_MAJOR >= 2
,NULL
#endif
);
}
GDALClose(poTiff);
VSIUnlink(fname);
return ret;
}
OGRDataSourceH OGROpen( const char *pszName, int bUpdate,
OGRSFDriverH *pahDriverList )
{
VALIDATE_POINTER1( pszName, "OGROpen", NULL );
#ifdef OGRAPISPY_ENABLED
int iSnapshot = OGRAPISpyOpenTakeSnapshot(pszName, bUpdate);
#endif
GDALDatasetH hDS = GDALOpenEx(pszName, GDAL_OF_VECTOR |
((bUpdate) ? GDAL_OF_UPDATE: 0), NULL, NULL, NULL);
if( hDS != NULL && pahDriverList != NULL )
*pahDriverList = (OGRSFDriverH) GDALGetDatasetDriver(hDS);
#ifdef OGRAPISPY_ENABLED
OGRAPISpyOpen(pszName, bUpdate, iSnapshot, &hDS);
#endif
return (OGRDataSourceH) hDS;
}
CPLErr GNMFileNetwork::LoadNetworkLayer(const char *pszLayername)
{
// check if not loaded
for(size_t i = 0; i < m_apoLayers.size(); ++i)
{
if(EQUAL(m_apoLayers[i]->GetName(), pszLayername))
return CE_None;
}
const char* pszExt = m_poLayerDriver->GetMetadataItem(GDAL_DMD_EXTENSION);
CPLString soFile = CPLFormFilename(m_soNetworkFullName, pszLayername, pszExt);
GDALDataset *poDS = (GDALDataset*) GDALOpenEx( soFile, GDAL_OF_VECTOR |
GDAL_OF_UPDATE, NULL, NULL, NULL );
if( NULL == poDS )
{
CPLError( CE_Failure, CPLE_OpenFailed, "Open '%s' file failed",
soFile.c_str() );
return CE_Failure;
}
OGRLayer* poLayer = poDS->GetLayer(0);
if(NULL == poLayer)
{
CPLError( CE_Failure, CPLE_OpenFailed, "Layer '%s' is not exist",
pszLayername );
return CE_Failure;
}
CPLDebug("GNM", "Layer '%s' loaded", poLayer->GetName());
GNMGenericLayer* pGNMLayer = new GNMGenericLayer(poLayer, this);
m_apoLayers.push_back(pGNMLayer);
m_mpLayerDatasetMap[pGNMLayer] = poDS;
return CE_None;
}
OGRDataSourceH OGR_Dr_Open( OGRSFDriverH hDriver, const char *pszName,
int bUpdate )
{
VALIDATE_POINTER1( hDriver, "OGR_Dr_Open", NULL );
const char* const apszDrivers[] = { ((GDALDriver*)hDriver)->GetDescription(),
NULL };
#ifdef OGRAPISPY_ENABLED
int iSnapshot = OGRAPISpyOpenTakeSnapshot(pszName, bUpdate);
#endif
GDALDatasetH hDS = GDALOpenEx(pszName,
GDAL_OF_VECTOR |
((bUpdate) ? GDAL_OF_UPDATE: 0),
apszDrivers, NULL, NULL);
#ifdef OGRAPISPY_ENABLED
OGRAPISpyOpen(pszName, bUpdate, iSnapshot, &hDS);
#endif
return (OGRDataSourceH) hDS;
}
QgsOgrLayerItem::QgsOgrLayerItem( QgsDataItem *parent,
const QString &name, const QString &path, const QString &uri, LayerType layerType, bool isSubLayer )
: QgsLayerItem( parent, name, path, uri, layerType, QStringLiteral( "ogr" ) )
{
mIsSubLayer = isSubLayer;
mToolTip = uri;
setState( Populated ); // children are not expected
if ( mPath.endsWith( QLatin1String( ".shp" ), Qt::CaseInsensitive ) )
{
if ( OGRGetDriverCount() == 0 )
{
OGRRegisterAll();
}
gdal::dataset_unique_ptr hDataSource( GDALOpenEx( mPath.toUtf8().constData(), GDAL_OF_VECTOR | GDAL_OF_UPDATE, nullptr, nullptr, nullptr ) );
if ( hDataSource )
{
mCapabilities |= SetCrs;
}
// It it is impossible to assign a crs to an existing layer
// No OGR_L_SetSpatialRef : http://trac.osgeo.org/gdal/ticket/4032
}
}
CPLErr GNMDatabaseNetwork::Open(GDALOpenInfo *poOpenInfo)
{
FormName(poOpenInfo->pszFilename, poOpenInfo->papszOpenOptions);
if(CSLFindName(poOpenInfo->papszOpenOptions, "LIST_ALL_TABLES") == -1)
poOpenInfo->papszOpenOptions = CSLAddNameValue(
poOpenInfo->papszOpenOptions, "LIST_ALL_TABLES", "YES");
m_poDS = (GDALDataset*) GDALOpenEx( m_soNetworkFullName, GDAL_OF_VECTOR |
GDAL_OF_UPDATE, NULL, NULL, poOpenInfo->papszOpenOptions );
if( NULL == m_poDS )
{
CPLError( CE_Failure, CPLE_OpenFailed, "Open '%s' failed",
m_soNetworkFullName.c_str() );
return CE_Failure;
}
// There should be only one schema so no schema name can be in table name
if(LoadMetadataLayer(m_poDS) != CE_None)
{
return CE_Failure;
}
if(LoadGraphLayer(m_poDS) != CE_None)
{
return CE_Failure;
}
if(LoadFeaturesLayer(m_poDS) != CE_None)
{
return CE_Failure;
}
return CE_None;
}
MAIN_START(argc, argv)
{
// Check that we are running against at least GDAL 1.4.
// Note to developers: if we use newer API, please change the requirement.
if( atoi(GDALVersionInfo("VERSION_NUM")) < 1400 )
{
fprintf(stderr,
"At least, GDAL >= 1.4.0 is required for this version of %s, "
"which was compiled against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
OGRRegisterAll();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Get commandline arguments other than the GDAL raster filenames. */
/* -------------------------------------------------------------------- */
const char* pszIndexLayerName = nullptr;
const char *index_filename = nullptr;
const char *tile_index = "location";
const char* pszDriverName = nullptr;
size_t nMaxFieldSize = 254;
bool write_absolute_path = false;
char* current_path = nullptr;
bool skip_different_projection = false;
const char *pszTargetSRS = "";
bool bSetTargetSRS = false;
const char* pszSrcSRSName = nullptr;
int i_SrcSRSName = -1;
bool bSrcSRSFormatSpecified = false;
SrcSRSFormat eSrcSRSFormat = FORMAT_AUTO;
int iArg = 1; // Used after for.
for( ; iArg < argc; iArg++ )
{
if( EQUAL(argv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against "
"GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
CSLDestroy( argv );
return 0;
}
else if( EQUAL(argv[iArg],"--help") )
Usage(nullptr);
else if( (strcmp(argv[iArg],"-f") == 0 || strcmp(argv[iArg],"-of") == 0) )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszDriverName = argv[++iArg];
}
else if( strcmp(argv[iArg],"-lyr_name") == 0 )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszIndexLayerName = argv[++iArg];
}
else if( strcmp(argv[iArg],"-tileindex") == 0 )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
tile_index = argv[++iArg];
}
else if( strcmp(argv[iArg],"-t_srs") == 0 )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszTargetSRS = argv[++iArg];
bSetTargetSRS = true;
}
else if ( strcmp(argv[iArg],"-write_absolute_path") == 0 )
{
write_absolute_path = true;
}
else if ( strcmp(argv[iArg],"-skip_different_projection") == 0 )
{
skip_different_projection = true;
}
else if( strcmp(argv[iArg], "-src_srs_name") == 0 )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszSrcSRSName = argv[++iArg];
}
else if( strcmp(argv[iArg], "-src_srs_format") == 0 )
{
const char* pszFormat;
bSrcSRSFormatSpecified = true;
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszFormat = argv[++iArg];
if( EQUAL(pszFormat, "AUTO") )
eSrcSRSFormat = FORMAT_AUTO;
else if( EQUAL(pszFormat, "WKT") )
eSrcSRSFormat = FORMAT_WKT;
else if( EQUAL(pszFormat, "EPSG") )
eSrcSRSFormat = FORMAT_EPSG;
else if( EQUAL(pszFormat, "PROJ") )
eSrcSRSFormat = FORMAT_PROJ;
}
else if( argv[iArg][0] == '-' )
Usage(CPLSPrintf("Unknown option name '%s'", argv[iArg]));
else if( index_filename == nullptr )
{
index_filename = argv[iArg];
iArg++;
break;
}
}
if( index_filename == nullptr )
Usage("No index filename specified.");
if( iArg == argc )
Usage("No file to index specified.");
if( bSrcSRSFormatSpecified && pszSrcSRSName == nullptr )
Usage("-src_srs_name must be specified when -src_srs_format is "
"specified.");
/* -------------------------------------------------------------------- */
/* Create and validate target SRS if given. */
/* -------------------------------------------------------------------- */
OGRSpatialReferenceH hTargetSRS = nullptr;
if( bSetTargetSRS )
{
if( skip_different_projection )
{
fprintf( stderr,
"Warning : -skip_different_projection does not apply "
"when -t_srs is requested.\n" );
}
hTargetSRS = OSRNewSpatialReference("");
OSRSetAxisMappingStrategy(hTargetSRS, OAMS_TRADITIONAL_GIS_ORDER);
// coverity[tainted_data]
if( OSRSetFromUserInput( hTargetSRS, pszTargetSRS ) != CE_None )
{
OSRDestroySpatialReference( hTargetSRS );
fprintf( stderr, "Invalid target SRS `%s'.\n",
pszTargetSRS );
exit(1);
}
}
/* -------------------------------------------------------------------- */
/* Open or create the target datasource */
/* -------------------------------------------------------------------- */
GDALDatasetH hTileIndexDS = GDALOpenEx(
index_filename, GDAL_OF_VECTOR | GDAL_OF_UPDATE, nullptr, nullptr, nullptr );
OGRLayerH hLayer = nullptr;
CPLString osFormat;
if( hTileIndexDS != nullptr )
{
GDALDriverH hDriver = GDALGetDatasetDriver(hTileIndexDS);
if( hDriver )
osFormat = GDALGetDriverShortName(hDriver);
if( GDALDatasetGetLayerCount(hTileIndexDS) == 1 )
{
hLayer = GDALDatasetGetLayer(hTileIndexDS, 0);
}
else
{
if( pszIndexLayerName == nullptr )
{
printf( "-lyr_name must be specified.\n" );
exit( 1 );
}
CPLPushErrorHandler(CPLQuietErrorHandler);
hLayer = GDALDatasetGetLayerByName(hTileIndexDS, pszIndexLayerName);
CPLPopErrorHandler();
}
}
else
{
printf( "Creating new index file...\n" );
if( pszDriverName == nullptr )
{
std::vector<CPLString> aoDrivers =
GetOutputDriversFor(index_filename, GDAL_OF_VECTOR);
if( aoDrivers.empty() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot guess driver for %s", index_filename);
exit( 10 );
}
else
{
if( aoDrivers.size() > 1 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Several drivers matching %s extension. Using %s",
CPLGetExtension(index_filename), aoDrivers[0].c_str() );
}
osFormat = aoDrivers[0];
}
}
else
{
osFormat = pszDriverName;
}
if( !EQUAL(osFormat, "ESRI Shapefile") )
nMaxFieldSize = 0;
GDALDriverH hDriver = GDALGetDriverByName( osFormat.c_str() );
if( hDriver == nullptr )
{
printf( "%s driver not available.\n", osFormat.c_str() );
exit( 1 );
}
hTileIndexDS =
GDALCreate( hDriver, index_filename, 0, 0, 0, GDT_Unknown, nullptr );
}
if( hTileIndexDS != nullptr && hLayer == nullptr )
{
OGRSpatialReferenceH hSpatialRef = nullptr;
char* pszLayerName = nullptr;
if( pszIndexLayerName == nullptr )
{
VSIStatBuf sStat;
if( EQUAL(osFormat, "ESRI Shapefile") ||
VSIStat(index_filename, &sStat) == 0 )
{
pszLayerName = CPLStrdup(CPLGetBasename(index_filename));
}
else
{
printf( "-lyr_name must be specified.\n" );
exit( 1 );
}
}
else
{
pszLayerName = CPLStrdup(pszIndexLayerName);
}
/* get spatial reference for output file from target SRS (if set) */
/* or from first input file */
if( bSetTargetSRS )
{
hSpatialRef = OSRClone( hTargetSRS );
}
else
{
GDALDatasetH hDS = GDALOpen( argv[iArg], GA_ReadOnly );
if( hDS )
{
const char* pszWKT = GDALGetProjectionRef(hDS);
if (pszWKT != nullptr && pszWKT[0] != '\0')
{
hSpatialRef = OSRNewSpatialReference(pszWKT);
OSRSetAxisMappingStrategy(hSpatialRef, OAMS_TRADITIONAL_GIS_ORDER);
}
GDALClose(hDS);
}
}
hLayer =
GDALDatasetCreateLayer( hTileIndexDS, pszLayerName, hSpatialRef,
wkbPolygon, nullptr );
CPLFree(pszLayerName);
if( hSpatialRef )
OSRRelease(hSpatialRef);
if( hLayer )
{
OGRFieldDefnH hFieldDefn = OGR_Fld_Create( tile_index, OFTString );
if( nMaxFieldSize )
OGR_Fld_SetWidth( hFieldDefn, static_cast<int>(nMaxFieldSize));
OGR_L_CreateField( hLayer, hFieldDefn, TRUE );
OGR_Fld_Destroy(hFieldDefn);
if( pszSrcSRSName != nullptr )
{
hFieldDefn = OGR_Fld_Create( pszSrcSRSName, OFTString );
if( nMaxFieldSize )
OGR_Fld_SetWidth(hFieldDefn,
static_cast<int>(nMaxFieldSize));
OGR_L_CreateField( hLayer, hFieldDefn, TRUE );
OGR_Fld_Destroy(hFieldDefn);
}
}
}
if( hTileIndexDS == nullptr || hLayer == nullptr )
{
fprintf( stderr, "Unable to open/create shapefile `%s'.\n",
index_filename );
exit(2);
}
OGRFeatureDefnH hFDefn = OGR_L_GetLayerDefn(hLayer);
const int ti_field = OGR_FD_GetFieldIndex( hFDefn, tile_index );
if( ti_field < 0 )
{
fprintf( stderr, "Unable to find field `%s' in file `%s'.\n",
tile_index, index_filename );
exit(2);
}
if( pszSrcSRSName != nullptr )
i_SrcSRSName = OGR_FD_GetFieldIndex( hFDefn, pszSrcSRSName );
// Load in memory existing file names in SHP.
int nExistingFiles = static_cast<int>(OGR_L_GetFeatureCount(hLayer, FALSE));
if( nExistingFiles < 0)
nExistingFiles = 0;
char** existingFilesTab = nullptr;
bool alreadyExistingProjectionRefValid = false;
char* alreadyExistingProjectionRef = nullptr;
if( nExistingFiles > 0 )
{
OGRFeatureH hFeature = nullptr;
existingFilesTab = static_cast<char **>(
CPLMalloc(nExistingFiles * sizeof(char*)));
for( int i = 0; i < nExistingFiles; i++ )
{
hFeature = OGR_L_GetNextFeature(hLayer);
existingFilesTab[i] =
CPLStrdup(OGR_F_GetFieldAsString( hFeature, ti_field ));
if( i == 0 )
{
GDALDatasetH hDS = GDALOpen(existingFilesTab[i], GA_ReadOnly );
if( hDS )
{
alreadyExistingProjectionRefValid = true;
alreadyExistingProjectionRef =
CPLStrdup(GDALGetProjectionRef(hDS));
GDALClose(hDS);
}
}
OGR_F_Destroy( hFeature );
}
}
if( write_absolute_path )
{
current_path = CPLGetCurrentDir();
if (current_path == nullptr)
{
fprintf( stderr,
"This system does not support the CPLGetCurrentDir call. "
"The option -write_absolute_path will have no effect\n" );
write_absolute_path = FALSE;
}
}
/* -------------------------------------------------------------------- */
/* loop over GDAL files, processing. */
/* -------------------------------------------------------------------- */
for( ; iArg < argc; iArg++ )
{
char *fileNameToWrite = nullptr;
VSIStatBuf sStatBuf;
// Make sure it is a file before building absolute path name.
if( write_absolute_path && CPLIsFilenameRelative( argv[iArg] ) &&
VSIStat( argv[iArg], &sStatBuf ) == 0 )
{
fileNameToWrite =
CPLStrdup(CPLProjectRelativeFilename(current_path, argv[iArg]));
}
else
{
fileNameToWrite = CPLStrdup(argv[iArg]);
}
// Checks that file is not already in tileindex.
{
int i = 0; // Used after for.
for( ; i < nExistingFiles; i++ )
{
if (EQUAL(fileNameToWrite, existingFilesTab[i]))
{
fprintf(stderr,
"File %s is already in tileindex. Skipping it.\n",
fileNameToWrite);
break;
}
}
if (i != nExistingFiles)
{
CPLFree(fileNameToWrite);
continue;
}
}
GDALDatasetH hDS = GDALOpen( argv[iArg], GA_ReadOnly );
if( hDS == nullptr )
{
fprintf( stderr, "Unable to open %s, skipping.\n",
argv[iArg] );
CPLFree(fileNameToWrite);
continue;
}
double adfGeoTransform[6] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
GDALGetGeoTransform( hDS, adfGeoTransform );
if( adfGeoTransform[0] == 0.0
&& adfGeoTransform[1] == 1.0
&& adfGeoTransform[3] == 0.0
&& std::abs(adfGeoTransform[5]) == 1.0 )
{
fprintf( stderr,
"It appears no georeferencing is available for\n"
"`%s', skipping.\n",
argv[iArg] );
GDALClose( hDS );
CPLFree(fileNameToWrite);
continue;
}
const char *projectionRef = GDALGetProjectionRef(hDS);
// If not set target srs, test that the current file uses same
// projection as others.
if( !bSetTargetSRS )
{
if( alreadyExistingProjectionRefValid )
{
int projectionRefNotNull, alreadyExistingProjectionRefNotNull;
projectionRefNotNull = projectionRef && projectionRef[0];
alreadyExistingProjectionRefNotNull =
alreadyExistingProjectionRef &&
alreadyExistingProjectionRef[0];
if ((projectionRefNotNull &&
alreadyExistingProjectionRefNotNull &&
EQUAL(projectionRef, alreadyExistingProjectionRef) == 0) ||
(projectionRefNotNull != alreadyExistingProjectionRefNotNull))
{
fprintf(
stderr,
"Warning : %s is not using the same projection system "
"as other files in the tileindex.\n"
"This may cause problems when using it in MapServer "
"for example.\n"
"Use -t_srs option to set target projection system "
"(not supported by MapServer).\n"
"%s\n", argv[iArg],
skip_different_projection ? "Skipping this file." : "");
if( skip_different_projection )
{
CPLFree(fileNameToWrite);
GDALClose( hDS );
continue;
}
}
}
else
{
alreadyExistingProjectionRefValid = true;
alreadyExistingProjectionRef = CPLStrdup(projectionRef);
}
}
const int nXSize = GDALGetRasterXSize( hDS );
const int nYSize = GDALGetRasterYSize( hDS );
double adfX[5] = { 0.0, 0.0, 0.0, 0.0, 0.0 };
double adfY[5] = { 0.0, 0.0, 0.0, 0.0, 0.0 };
adfX[0] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[0] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
adfX[1] = adfGeoTransform[0]
+ nXSize * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[1] = adfGeoTransform[3]
+ nXSize * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
adfX[2] = adfGeoTransform[0]
+ nXSize * adfGeoTransform[1]
+ nYSize * adfGeoTransform[2];
adfY[2] = adfGeoTransform[3]
+ nXSize * adfGeoTransform[4]
+ nYSize * adfGeoTransform[5];
adfX[3] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ nYSize * adfGeoTransform[2];
adfY[3] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ nYSize * adfGeoTransform[5];
adfX[4] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[4] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
OGRSpatialReferenceH hSourceSRS = nullptr;
if( (bSetTargetSRS || i_SrcSRSName >= 0) &&
projectionRef != nullptr &&
projectionRef[0] != '\0' )
{
hSourceSRS = OSRNewSpatialReference( projectionRef );
OSRSetAxisMappingStrategy(hSourceSRS, OAMS_TRADITIONAL_GIS_ORDER);
}
// If set target srs, do the forward transformation of all points.
if( bSetTargetSRS && projectionRef != nullptr && projectionRef[0] != '\0' )
{
OGRCoordinateTransformationH hCT = nullptr;
if( hSourceSRS && !OSRIsSame( hSourceSRS, hTargetSRS ) )
{
hCT = OCTNewCoordinateTransformation( hSourceSRS, hTargetSRS );
if( hCT == nullptr || !OCTTransform( hCT, 5, adfX, adfY, nullptr ) )
{
fprintf(
stderr,
"Warning : unable to transform points from source "
"SRS `%s' to target SRS `%s'\n"
"for file `%s' - file skipped\n",
projectionRef, pszTargetSRS, fileNameToWrite );
if( hCT )
OCTDestroyCoordinateTransformation( hCT );
if( hSourceSRS )
OSRDestroySpatialReference( hSourceSRS );
continue;
}
if( hCT )
OCTDestroyCoordinateTransformation( hCT );
}
}
OGRFeatureH hFeature = OGR_F_Create( OGR_L_GetLayerDefn( hLayer ) );
OGR_F_SetFieldString( hFeature, ti_field, fileNameToWrite );
if( i_SrcSRSName >= 0 && hSourceSRS != nullptr )
{
const char* pszAuthorityCode =
OSRGetAuthorityCode(hSourceSRS, nullptr);
const char* pszAuthorityName =
OSRGetAuthorityName(hSourceSRS, nullptr);
if( eSrcSRSFormat == FORMAT_AUTO )
{
if( pszAuthorityName != nullptr && pszAuthorityCode != nullptr )
{
OGR_F_SetFieldString(
hFeature, i_SrcSRSName,
CPLSPrintf("%s:%s",
pszAuthorityName, pszAuthorityCode) );
}
else if( nMaxFieldSize == 0 ||
strlen(projectionRef) <= nMaxFieldSize )
{
OGR_F_SetFieldString(hFeature, i_SrcSRSName, projectionRef);
}
else
{
char* pszProj4 = nullptr;
if( OSRExportToProj4(hSourceSRS, &pszProj4) == OGRERR_NONE )
{
OGR_F_SetFieldString( hFeature, i_SrcSRSName,
pszProj4 );
CPLFree(pszProj4);
}
else
{
OGR_F_SetFieldString( hFeature, i_SrcSRSName,
projectionRef );
}
}
}
else if( eSrcSRSFormat == FORMAT_WKT )
{
if( nMaxFieldSize == 0 ||
strlen(projectionRef) <= nMaxFieldSize )
{
OGR_F_SetFieldString( hFeature, i_SrcSRSName,
projectionRef );
}
else
{
fprintf(stderr,
"Cannot write WKT for file %s as it is too long!\n",
fileNameToWrite);
}
}
else if( eSrcSRSFormat == FORMAT_PROJ )
{
char* pszProj4 = nullptr;
if( OSRExportToProj4(hSourceSRS, &pszProj4) == OGRERR_NONE )
{
OGR_F_SetFieldString( hFeature, i_SrcSRSName, pszProj4 );
CPLFree(pszProj4);
}
}
else if( eSrcSRSFormat == FORMAT_EPSG )
{
if( pszAuthorityName != nullptr && pszAuthorityCode != nullptr )
OGR_F_SetFieldString(
hFeature, i_SrcSRSName,
CPLSPrintf("%s:%s",
pszAuthorityName, pszAuthorityCode) );
}
}
if( hSourceSRS )
OSRDestroySpatialReference( hSourceSRS );
OGRGeometryH hPoly = OGR_G_CreateGeometry(wkbPolygon);
OGRGeometryH hRing = OGR_G_CreateGeometry(wkbLinearRing);
for( int k = 0; k < 5; k++ )
OGR_G_SetPoint_2D(hRing, k, adfX[k], adfY[k]);
OGR_G_AddGeometryDirectly( hPoly, hRing );
OGR_F_SetGeometryDirectly( hFeature, hPoly );
if( OGR_L_CreateFeature( hLayer, hFeature ) != OGRERR_NONE )
{
printf( "Failed to create feature in shapefile.\n" );
break;
}
OGR_F_Destroy( hFeature );
CPLFree(fileNameToWrite);
GDALClose( hDS );
}
CPLFree(current_path);
if (nExistingFiles)
{
for( int i = 0; i < nExistingFiles; i++ )
{
CPLFree(existingFilesTab[i]);
}
CPLFree(existingFilesTab);
}
CPLFree(alreadyExistingProjectionRef);
if ( hTargetSRS )
OSRDestroySpatialReference( hTargetSRS );
GDALClose( hTileIndexDS );
GDALDestroyDriverManager();
OGRCleanupAll();
CSLDestroy(argv);
exit( 0 );
}
void
NIImporter_ArcView::load() {
#ifdef HAVE_GDAL
PROGRESS_BEGIN_MESSAGE("Loading data from '" + mySHPName + "'");
#if GDAL_VERSION_MAJOR < 2
OGRRegisterAll();
OGRDataSource* poDS = OGRSFDriverRegistrar::Open(mySHPName.c_str(), FALSE);
#else
GDALAllRegister();
GDALDataset* poDS = (GDALDataset*)GDALOpenEx(mySHPName.c_str(), GDAL_OF_VECTOR | GA_ReadOnly, NULL, NULL, NULL);
#endif
if (poDS == NULL) {
WRITE_ERROR("Could not open shape description '" + mySHPName + "'.");
return;
}
// begin file parsing
OGRLayer* poLayer = poDS->GetLayer(0);
poLayer->ResetReading();
// build coordinate transformation
OGRSpatialReference* origTransf = poLayer->GetSpatialRef();
OGRSpatialReference destTransf;
// use wgs84 as destination
destTransf.SetWellKnownGeogCS("WGS84");
OGRCoordinateTransformation* poCT = OGRCreateCoordinateTransformation(origTransf, &destTransf);
if (poCT == NULL) {
if (myOptions.isSet("shapefile.guess-projection")) {
OGRSpatialReference origTransf2;
origTransf2.SetWellKnownGeogCS("WGS84");
poCT = OGRCreateCoordinateTransformation(&origTransf2, &destTransf);
}
if (poCT == 0) {
WRITE_WARNING("Could not create geocoordinates converter; check whether proj.4 is installed.");
}
}
OGRFeature* poFeature;
poLayer->ResetReading();
while ((poFeature = poLayer->GetNextFeature()) != NULL) {
// read in edge attributes
std::string id, name, from_node, to_node;
if (!getStringEntry(poFeature, "shapefile.street-id", "LINK_ID", true, id)) {
WRITE_ERROR("Needed field '" + id + "' (from node id) is missing.");
}
if (id == "") {
WRITE_ERROR("Could not obtain edge id.");
return;
}
getStringEntry(poFeature, "shapefile.street-id", "ST_NAME", true, name);
name = StringUtils::replace(name, "&", "&");
if (!getStringEntry(poFeature, "shapefile.from-id", "REF_IN_ID", true, from_node)) {
WRITE_ERROR("Needed field '" + from_node + "' (from node id) is missing.");
}
if (!getStringEntry(poFeature, "shapefile.to-id", "NREF_IN_ID", true, to_node)) {
WRITE_ERROR("Needed field '" + to_node + "' (to node id) is missing.");
}
if (from_node == "" || to_node == "") {
from_node = toString(myRunningNodeID++);
to_node = toString(myRunningNodeID++);
}
std::string type;
if (myOptions.isSet("shapefile.type-id") && poFeature->GetFieldIndex(myOptions.getString("shapefile.type-id").c_str()) >= 0) {
type = poFeature->GetFieldAsString(myOptions.getString("shapefile.type-id").c_str());
} else if (poFeature->GetFieldIndex("ST_TYP_AFT") >= 0) {
type = poFeature->GetFieldAsString("ST_TYP_AFT");
}
SUMOReal width = myTypeCont.getWidth(type);
SUMOReal speed = getSpeed(*poFeature, id);
int nolanes = getLaneNo(*poFeature, id, speed);
int priority = getPriority(*poFeature, id);
if (nolanes == 0 || speed == 0) {
if (myOptions.getBool("shapefile.use-defaults-on-failure")) {
nolanes = myTypeCont.getNumLanes("");
speed = myTypeCont.getSpeed("");
} else {
OGRFeature::DestroyFeature(poFeature);
WRITE_ERROR("The description seems to be invalid. Please recheck usage of types.");
return;
}
}
if (mySpeedInKMH) {
speed = speed / (SUMOReal) 3.6;
}
// read in the geometry
OGRGeometry* poGeometry = poFeature->GetGeometryRef();
OGRwkbGeometryType gtype = poGeometry->getGeometryType();
assert(gtype == wkbLineString);
UNUSED_PARAMETER(gtype); // ony used for assertion
OGRLineString* cgeom = (OGRLineString*) poGeometry;
if (poCT != 0) {
// try transform to wgs84
cgeom->transform(poCT);
}
PositionVector shape;
for (int j = 0; j < cgeom->getNumPoints(); j++) {
Position pos((SUMOReal) cgeom->getX(j), (SUMOReal) cgeom->getY(j));
if (!NBNetBuilder::transformCoordinate(pos)) {
WRITE_WARNING("Unable to project coordinates for edge '" + id + "'.");
}
shape.push_back_noDoublePos(pos);
}
// build from-node
NBNode* from = myNodeCont.retrieve(from_node);
if (from == 0) {
Position from_pos = shape[0];
from = myNodeCont.retrieve(from_pos);
if (from == 0) {
from = new NBNode(from_node, from_pos);
if (!myNodeCont.insert(from)) {
WRITE_ERROR("Node '" + from_node + "' could not be added");
delete from;
continue;
}
}
}
// build to-node
NBNode* to = myNodeCont.retrieve(to_node);
if (to == 0) {
Position to_pos = shape[-1];
to = myNodeCont.retrieve(to_pos);
if (to == 0) {
to = new NBNode(to_node, to_pos);
if (!myNodeCont.insert(to)) {
WRITE_ERROR("Node '" + to_node + "' could not be added");
delete to;
continue;
}
}
}
if (from == to) {
WRITE_WARNING("Edge '" + id + "' connects identical nodes, skipping.");
continue;
}
// retrieve the information whether the street is bi-directional
std::string dir;
int index = poFeature->GetDefnRef()->GetFieldIndex("DIR_TRAVEL");
if (index >= 0 && poFeature->IsFieldSet(index)) {
dir = poFeature->GetFieldAsString(index);
}
// add positive direction if wanted
if (dir == "B" || dir == "F" || dir == "" || myOptions.getBool("shapefile.all-bidirectional")) {
if (myEdgeCont.retrieve(id) == 0) {
LaneSpreadFunction spread = dir == "B" || dir == "FALSE" ? LANESPREAD_RIGHT : LANESPREAD_CENTER;
NBEdge* edge = new NBEdge(id, from, to, type, speed, nolanes, priority, width, NBEdge::UNSPECIFIED_OFFSET, shape, name, id, spread);
myEdgeCont.insert(edge);
checkSpread(edge);
}
}
// add negative direction if wanted
if (dir == "B" || dir == "T" || myOptions.getBool("shapefile.all-bidirectional")) {
if (myEdgeCont.retrieve("-" + id) == 0) {
LaneSpreadFunction spread = dir == "B" || dir == "FALSE" ? LANESPREAD_RIGHT : LANESPREAD_CENTER;
NBEdge* edge = new NBEdge("-" + id, to, from, type, speed, nolanes, priority, width, NBEdge::UNSPECIFIED_OFFSET, shape.reverse(), name, id, spread);
myEdgeCont.insert(edge);
checkSpread(edge);
}
}
//
OGRFeature::DestroyFeature(poFeature);
}
#if GDAL_VERSION_MAJOR < 2
OGRDataSource::DestroyDataSource(poDS);
#else
GDALClose(poDS);
#endif
PROGRESS_DONE_MESSAGE();
#else
WRITE_ERROR("SUMO was compiled without GDAL support.");
#endif
}
int main(int argc, char** argv)
{
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
exit(1);
EarlySetConfigOptions(argc, argv);
/* -------------------------------------------------------------------- */
/* Generic arg processing. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
for( int i = 0; i < argc; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
CSLDestroy( argv );
return 0;
}
else if( EQUAL(argv[i],"--help") )
{
Usage();
}
}
GDALRasterizeOptionsForBinary* psOptionsForBinary = GDALRasterizeOptionsForBinaryNew();
GDALRasterizeOptions *psOptions = GDALRasterizeOptionsNew(argv + 1, psOptionsForBinary);
CSLDestroy( argv );
if( psOptions == NULL )
{
Usage();
}
if( !(psOptionsForBinary->bQuiet) )
{
GDALRasterizeOptionsSetProgress(psOptions, GDALTermProgress, NULL);
}
if( psOptionsForBinary->pszSource == NULL )
Usage("No input file specified.");
if( psOptionsForBinary->pszDest == NULL )
Usage("No output file specified.");
/* -------------------------------------------------------------------- */
/* Open input file. */
/* -------------------------------------------------------------------- */
GDALDatasetH hInDS = GDALOpenEx( psOptionsForBinary->pszSource, GDAL_OF_VECTOR | GDAL_OF_VERBOSE_ERROR,
NULL, NULL, NULL );
if( hInDS == NULL )
exit( 1 );
/* -------------------------------------------------------------------- */
/* Open output file if it exists. */
/* -------------------------------------------------------------------- */
GDALDatasetH hDstDS = NULL;
if( !(psOptionsForBinary->bCreateOutput) )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
hDstDS = GDALOpenEx( psOptionsForBinary->pszDest, GDAL_OF_RASTER | GDAL_OF_VERBOSE_ERROR | GDAL_OF_UPDATE,
NULL, NULL, NULL );
CPLPopErrorHandler();
}
if (hDstDS == NULL && !psOptionsForBinary->bQuiet && !psOptionsForBinary->bFormatExplicitlySet)
CheckExtensionConsistency(psOptionsForBinary->pszDest, psOptionsForBinary->pszFormat);
int bUsageError = FALSE;
GDALDatasetH hRetDS = GDALRasterize(psOptionsForBinary->pszDest,
hDstDS,
hInDS,
psOptions, &bUsageError);
if(bUsageError == TRUE)
Usage();
int nRetCode = (hRetDS) ? 0 : 1;
GDALClose(hInDS);
GDALClose(hRetDS);
GDALRasterizeOptionsFree(psOptions);
GDALRasterizeOptionsForBinaryFree(psOptionsForBinary);
GDALDestroyDriverManager();
return nRetCode;
}
static GDALDataset *OGRSQLiteDriverOpen( GDALOpenInfo* poOpenInfo )
{
if( OGRSQLiteDriverIdentify(poOpenInfo) == FALSE )
return NULL;
/* -------------------------------------------------------------------- */
/* Check VirtualShape:xxx.shp syntax */
/* -------------------------------------------------------------------- */
int nLen = (int) strlen(poOpenInfo->pszFilename);
if (EQUALN(poOpenInfo->pszFilename, "VirtualShape:", strlen( "VirtualShape:" )) &&
nLen > 4 && EQUAL(poOpenInfo->pszFilename + nLen - 4, ".SHP"))
{
OGRSQLiteDataSource *poDS;
poDS = new OGRSQLiteDataSource();
char** papszOptions = CSLAddString(NULL, "SPATIALITE=YES");
int nRet = poDS->Create( ":memory:", papszOptions );
poDS->SetDescription(poOpenInfo->pszFilename);
CSLDestroy(papszOptions);
if (!nRet)
{
delete poDS;
return NULL;
}
char* pszSQLiteFilename = CPLStrdup(poOpenInfo->pszFilename + strlen( "VirtualShape:" ));
GDALDataset* poSQLiteDS = (GDALDataset*) GDALOpenEx(pszSQLiteFilename,
GDAL_OF_VECTOR, NULL, NULL, NULL);
if (poSQLiteDS == NULL)
{
CPLFree(pszSQLiteFilename);
delete poDS;
return NULL;
}
delete poSQLiteDS;
char* pszLastDot = strrchr(pszSQLiteFilename, '.');
if (pszLastDot)
*pszLastDot = '\0';
const char* pszTableName = CPLGetBasename(pszSQLiteFilename);
char* pszSQL = CPLStrdup(CPLSPrintf("CREATE VIRTUAL TABLE %s USING VirtualShape(%s, CP1252, -1)",
pszTableName, pszSQLiteFilename));
poDS->ExecuteSQL(pszSQL, NULL, NULL);
CPLFree(pszSQL);
CPLFree(pszSQLiteFilename);
poDS->SetUpdate(FALSE);
return poDS;
}
/* -------------------------------------------------------------------- */
/* We think this is really an SQLite database, go ahead and try */
/* and open it. */
/* -------------------------------------------------------------------- */
OGRSQLiteDataSource *poDS;
poDS = new OGRSQLiteDataSource();
if( !poDS->Open( poOpenInfo->pszFilename, poOpenInfo->eAccess == GA_Update,
poOpenInfo->papszOpenOptions ) )
{
delete poDS;
return NULL;
}
else
return poDS;
}
MAIN_START(argc, argv)
{
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
exit(1);
EarlySetConfigOptions(argc, argv);
/* -------------------------------------------------------------------- */
/* Generic arg processing. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
for( int i = 0; i < argc; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
CSLDestroy( argv );
return 0;
}
else if( EQUAL(argv[i],"--help") )
{
Usage();
}
}
GDALGridOptionsForBinary* psOptionsForBinary = GDALGridOptionsForBinaryNew();
/* coverity[tainted_data] */
GDALGridOptions *psOptions = GDALGridOptionsNew(argv + 1, psOptionsForBinary);
CSLDestroy( argv );
if( psOptions == nullptr )
{
Usage();
}
if( !(psOptionsForBinary->bQuiet) )
{
GDALGridOptionsSetProgress(psOptions, GDALTermProgress, nullptr);
}
if( psOptionsForBinary->pszSource == nullptr )
Usage("No input file specified.");
if( psOptionsForBinary->pszDest== nullptr )
Usage("No output file specified.");
if( psOptionsForBinary->pszDest == nullptr )
psOptionsForBinary->pszDest = CPLStrdup(psOptionsForBinary->pszSource);
/* -------------------------------------------------------------------- */
/* Open input file. */
/* -------------------------------------------------------------------- */
GDALDatasetH hInDS = GDALOpenEx( psOptionsForBinary->pszSource, GDAL_OF_VECTOR | GDAL_OF_VERBOSE_ERROR,
nullptr, nullptr, nullptr );
if( hInDS == nullptr )
exit( 1 );
int bUsageError = FALSE;
GDALDatasetH hOutDS = GDALGrid(psOptionsForBinary->pszDest,
hInDS,
psOptions, &bUsageError);
if(bUsageError == TRUE)
Usage();
int nRetCode = hOutDS ? 0 : 1;
GDALClose(hInDS);
GDALClose(hOutDS);
GDALGridOptionsFree(psOptions);
GDALGridOptionsForBinaryFree(psOptionsForBinary);
OGRCleanupAll();
GDALDestroyDriverManager();
return nRetCode;
}
int GDALDefaultOverviews::HaveMaskFile( char ** papszSiblingFiles,
const char *pszBasename )
{
/* -------------------------------------------------------------------- */
/* Have we already checked for masks? */
/* -------------------------------------------------------------------- */
if( bCheckedForMask )
return poMaskDS != NULL;
if( papszSiblingFiles == NULL )
papszSiblingFiles = papszInitSiblingFiles;
/* -------------------------------------------------------------------- */
/* Are we an overview? If so we need to find the corresponding */
/* overview in the base files mask file (if there is one). */
/* -------------------------------------------------------------------- */
if( poBaseDS != NULL && poBaseDS->oOvManager.HaveMaskFile() )
{
GDALRasterBand * const poBaseBand = poBaseDS->GetRasterBand(1);
GDALRasterBand * poBaseMask = poBaseBand != NULL ?
poBaseBand->GetMaskBand() : NULL;
const int nOverviewCount = poBaseMask != NULL ?
poBaseMask->GetOverviewCount() : 0;
for( int iOver = 0; iOver < nOverviewCount; iOver++ )
{
GDALRasterBand * const poOverBand =
poBaseMask->GetOverview( iOver );
if( poOverBand == NULL )
continue;
if( poOverBand->GetXSize() == poDS->GetRasterXSize()
&& poOverBand->GetYSize() == poDS->GetRasterYSize() )
{
poMaskDS = poOverBand->GetDataset();
break;
}
}
bCheckedForMask = true;
bOwnMaskDS = false;
CPLAssert( poMaskDS != poDS );
return poMaskDS != NULL;
}
/* -------------------------------------------------------------------- */
/* Are we even initialized? If not, we apparently don't want */
/* to support overviews and masks. */
/* -------------------------------------------------------------------- */
if( poDS == NULL )
return FALSE;
/* -------------------------------------------------------------------- */
/* Check for .msk file. */
/* -------------------------------------------------------------------- */
bCheckedForMask = true;
if( pszBasename == NULL )
pszBasename = poDS->GetDescription();
// Don't bother checking for masks of masks.
if( EQUAL(CPLGetExtension(pszBasename),"msk") )
return FALSE;
if( !GDALCanFileAcceptSidecarFile(pszBasename) )
return FALSE;
CPLString osMskFilename;
osMskFilename.Printf( "%s.msk", pszBasename );
std::vector<char> achMskFilename;
achMskFilename.resize(osMskFilename.size() + 1);
memcpy(&(achMskFilename[0]),
osMskFilename.c_str(),
osMskFilename.size() + 1);
bool bExists = CPL_TO_BOOL(
CPLCheckForFile( &achMskFilename[0],
papszSiblingFiles ) );
osMskFilename = &achMskFilename[0];
#if !defined(WIN32)
if( !bExists && !papszSiblingFiles )
{
osMskFilename.Printf( "%s.MSK", pszBasename );
memcpy(&(achMskFilename[0]),
osMskFilename.c_str(),
osMskFilename.size() + 1);
bExists = CPL_TO_BOOL(
CPLCheckForFile( &achMskFilename[0],
papszSiblingFiles ) );
osMskFilename = &achMskFilename[0];
}
#endif
if( !bExists )
return FALSE;
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
poMaskDS = static_cast<GDALDataset *>(
GDALOpenEx( osMskFilename,
GDAL_OF_RASTER |
(poDS->GetAccess() == GA_Update ? GDAL_OF_UPDATE : 0),
NULL, NULL, papszInitSiblingFiles ));
CPLAssert( poMaskDS != poDS );
if( poMaskDS == NULL )
return FALSE;
bOwnMaskDS = true;
return TRUE;
}
int OGRGPSBabelDataSource::Open( const char * pszDatasourceName,
const char* pszGPSBabelDriverNameIn,
char** papszOpenOptionsIn )
{
if (!STARTS_WITH_CI(pszDatasourceName, "GPSBABEL:"))
{
CPLAssert(pszGPSBabelDriverNameIn);
pszGPSBabelDriverName = CPLStrdup(pszGPSBabelDriverNameIn);
pszFilename = CPLStrdup(pszDatasourceName);
}
else
{
if( CSLFetchNameValue(papszOpenOptionsIn, "FILENAME") )
pszFilename = CPLStrdup(CSLFetchNameValue(papszOpenOptionsIn,
"FILENAME"));
if( CSLFetchNameValue(papszOpenOptionsIn, "GPSBABEL_DRIVER") )
{
if( pszFilename == NULL )
{
CPLError(CE_Failure, CPLE_AppDefined, "Missing FILENAME");
return FALSE;
}
pszGPSBabelDriverName
= CPLStrdup(CSLFetchNameValue(papszOpenOptionsIn, "DRIVER"));
/* A bit of validation to avoid command line injection */
if (!IsValidDriverName(pszGPSBabelDriverName))
return FALSE;
}
}
pszName = CPLStrdup( pszDatasourceName );
bool bExplicitFeatures = false;
bool bWaypoints = true;
bool bTracks = true;
bool bRoutes = true;
if (pszGPSBabelDriverName == NULL)
{
const char* pszSep = strchr(pszDatasourceName + 9, ':');
if (pszSep == NULL)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Wrong syntax. Expected GPSBabel:driver_name:file_name");
return FALSE;
}
pszGPSBabelDriverName = CPLStrdup(pszDatasourceName + 9);
*(strchr(pszGPSBabelDriverName, ':')) = '\0';
/* A bit of validation to avoid command line injection */
if (!IsValidDriverName(pszGPSBabelDriverName))
return FALSE;
/* Parse optional features= option */
if (STARTS_WITH_CI(pszSep+1, "features="))
{
const char* pszNextSep = strchr(pszSep+1, ':');
if (pszNextSep == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Wrong syntax. Expected "
"GPSBabel:driver_name[,options]*:["
"features=waypoints,tracks,routes:]file_name");
return FALSE;
}
char* pszFeatures = CPLStrdup(pszSep+1+9);
*strchr(pszFeatures, ':') = 0;
char** papszTokens = CSLTokenizeString(pszFeatures);
char** papszIter = papszTokens;
bool bErr = false;
bExplicitFeatures = true;
bWaypoints = false;
bTracks = false;
bRoutes = false;
while(papszIter && *papszIter)
{
if (EQUAL(*papszIter, "waypoints"))
bWaypoints = true;
else if (EQUAL(*papszIter, "tracks"))
bTracks = true;
else if (EQUAL(*papszIter, "routes"))
bRoutes = true;
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Wrong value for 'features' options");
bErr = true;
}
papszIter++;
}
CSLDestroy(papszTokens);
CPLFree(pszFeatures);
if (bErr)
return FALSE;
pszSep = pszNextSep;
}
if( pszFilename == NULL )
pszFilename = CPLStrdup(pszSep+1);
}
const char* pszOptionUseTempFile = CPLGetConfigOption("USE_TEMPFILE", NULL);
if (pszOptionUseTempFile && CPLTestBool(pszOptionUseTempFile))
osTmpFileName = CPLGenerateTempFilename(NULL);
else
osTmpFileName.Printf("/vsimem/ogrgpsbabeldatasource_%p", this);
bool bRet = false;
if (IsSpecialFile(pszFilename))
{
/* Special file : don't try to open it */
char** argv = GetArgv(bExplicitFeatures, bWaypoints, bRoutes,
bTracks, pszGPSBabelDriverName, pszFilename);
VSILFILE* tmpfp = VSIFOpenL(osTmpFileName.c_str(), "wb");
bRet = (CPLSpawn(argv, NULL, tmpfp, TRUE) == 0);
VSIFCloseL(tmpfp);
tmpfp = NULL;
CSLDestroy(argv);
argv = NULL;
}
else
{
VSILFILE* fp = VSIFOpenL(pszFilename, "rb");
if (fp == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot open file %s", pszFilename);
return FALSE;
}
char** argv = GetArgv(bExplicitFeatures, bWaypoints, bRoutes,
bTracks, pszGPSBabelDriverName, "-");
VSILFILE* tmpfp = VSIFOpenL(osTmpFileName.c_str(), "wb");
CPLPushErrorHandler(CPLQuietErrorHandler);
bRet = (CPLSpawn(argv, fp, tmpfp, TRUE) == 0);
CPLPopErrorHandler();
CSLDestroy(argv);
argv = NULL;
CPLErr nLastErrorType = CPLGetLastErrorType();
CPLErrorNum nLastErrorNo = CPLGetLastErrorNo();
CPLString osLastErrorMsg = CPLGetLastErrorMsg();
VSIFCloseL(tmpfp);
tmpfp = NULL;
VSIFCloseL(fp);
fp = NULL;
if (!bRet)
{
if ( strstr(osLastErrorMsg.c_str(),
"This format cannot be used in piped commands") == NULL)
{
CPLError( nLastErrorType, nLastErrorNo, "%s",
osLastErrorMsg.c_str());
}
else
{
VSIStatBuf sStatBuf;
if (VSIStat(pszFilename, &sStatBuf) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Driver %s only supports real (non virtual) "
"files",
pszGPSBabelDriverName );
return FALSE;
}
/* Try without piping in */
argv = GetArgv(bExplicitFeatures, bWaypoints, bRoutes,
bTracks, pszGPSBabelDriverName, pszFilename);
tmpfp = VSIFOpenL(osTmpFileName.c_str(), "wb");
bRet = (CPLSpawn(argv, NULL, tmpfp, TRUE) == 0);
VSIFCloseL(tmpfp);
tmpfp = NULL;
CSLDestroy(argv);
argv = NULL;
}
}
}
if (bRet)
{
poGPXDS = static_cast<GDALDataset *>(
GDALOpenEx( osTmpFileName.c_str(),
GDAL_OF_VECTOR, NULL, NULL, NULL ) );
if (poGPXDS)
{
if (bWaypoints)
{
OGRLayer* poLayer = poGPXDS->GetLayerByName("waypoints");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
}
if (bRoutes)
{
OGRLayer* poLayer = poGPXDS->GetLayerByName("routes");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
poLayer = poGPXDS->GetLayerByName("route_points");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
}
if (bTracks)
{
OGRLayer* poLayer = poGPXDS->GetLayerByName("tracks");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
poLayer = poGPXDS->GetLayerByName("track_points");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
}
}
}
return nLayers > 0;
}
/*
* Init()
*/
bool OGRNGWDataset::Init(int nOpenFlagsIn)
{
// NOTE: Skip check API version at that moment. We expected API v3.
// Get resource details.
CPLJSONDocument oResourceDetailsReq;
char **papszHTTPOptions = GetHeaders();
bool bResult = oResourceDetailsReq.LoadUrl( NGWAPI::GetResource( osUrl,
osResourceId ), papszHTTPOptions );
CPLDebug("NGW", "Get resource %s details %s", osResourceId.c_str(),
bResult ? "success" : "failed");
if( bResult )
{
CPLJSONObject oRoot = oResourceDetailsReq.GetRoot();
if( oRoot.IsValid() )
{
std::string osResourceType = oRoot.GetString("resource/cls");
FillMetadata( oRoot );
if( osResourceType == "resource_group" )
{
// Check feature paging.
FillCapabilities( papszHTTPOptions );
if( oRoot.GetBool( "resource/children", false ) ) {
// Get child resources.
bResult = FillResources( papszHTTPOptions, nOpenFlagsIn );
}
}
else if( (osResourceType == "vector_layer" ||
osResourceType == "postgis_layer") )
{
// Cehck feature paging.
FillCapabilities( papszHTTPOptions );
// Add vector layer.
AddLayer( oRoot, papszHTTPOptions, nOpenFlagsIn );
}
else if( osResourceType == "mapserver_style" ||
osResourceType == "qgis_vector_style" ||
osResourceType == "raster_style" ||
osResourceType == "wmsclient_layer" )
{
// GetExtent from parent.
OGREnvelope stExtent;
std::string osParentId = oRoot.GetString("resource/parent/id");
bool bExtentResult = NGWAPI::GetExtent(osUrl, osParentId,
papszHTTPOptions, 3857, stExtent);
if( !bExtentResult )
{
// Set full extent for EPSG:3857.
stExtent.MinX = -20037508.34;
stExtent.MaxX = 20037508.34;
stExtent.MinY = -20037508.34;
stExtent.MaxY = 20037508.34;
}
CPLDebug("NGW", "Raster extent is: %f, %f, %f, %f",
stExtent.MinX, stExtent.MinY,
stExtent.MaxX, stExtent.MaxY);
int nEPSG = 3857;
// Get parent details. We can skip this as default SRS in NGW is 3857.
if( osResourceType == "wmsclient_layer" )
{
nEPSG = oRoot.GetInteger("wmsclient_layer/srs/id", nEPSG);
}
else
{
CPLJSONDocument oResourceReq;
bResult = oResourceReq.LoadUrl( NGWAPI::GetResource( osUrl,
osResourceId ), papszHTTPOptions );
if( bResult )
{
CPLJSONObject oParentRoot = oResourceReq.GetRoot();
if( osResourceType == "mapserver_style" ||
osResourceType == "qgis_vector_style" )
{
nEPSG = oParentRoot.GetInteger("vector_layer/srs/id", nEPSG);
}
else if( osResourceType == "raster_style")
{
nEPSG = oParentRoot.GetInteger("raster_layer/srs/id", nEPSG);
}
}
}
// Create raster dataset.
std::string osRasterUrl = NGWAPI::GetTMS(osUrl, osResourceId);
char* pszRasterUrl = CPLEscapeString(osRasterUrl.c_str(), -1, CPLES_XML);
const char *pszConnStr = CPLSPrintf("<GDAL_WMS><Service name=\"TMS\">"
"<ServerUrl>%s</ServerUrl></Service><DataWindow>"
"<UpperLeftX>-20037508.34</UpperLeftX><UpperLeftY>20037508.34</UpperLeftY>"
"<LowerRightX>20037508.34</LowerRightX><LowerRightY>-20037508.34</LowerRightY>"
"<TileLevel>%d</TileLevel><TileCountX>1</TileCountX>"
"<TileCountY>1</TileCountY><YOrigin>top</YOrigin></DataWindow>"
"<Projection>EPSG:%d</Projection><BlockSizeX>256</BlockSizeX>"
"<BlockSizeY>256</BlockSizeY><BandsCount>%d</BandsCount>"
"<Cache><Type>file</Type><Expires>%d</Expires><MaxSize>%d</MaxSize>"
"</Cache><ZeroBlockHttpCodes>204,404</ZeroBlockHttpCodes></GDAL_WMS>",
pszRasterUrl,
22, // NOTE: We have no limit in zoom levels.
nEPSG, // NOTE: Default SRS is EPSG:3857.
4,
nCacheExpires,
nCacheMaxSize);
CPLFree( pszRasterUrl );
poRasterDS = reinterpret_cast<GDALDataset*>(GDALOpenEx(pszConnStr,
GDAL_OF_READONLY | GDAL_OF_RASTER | GDAL_OF_INTERNAL, nullptr,
nullptr, nullptr));
if( poRasterDS )
{
bResult = true;
nRasterXSize = poRasterDS->GetRasterXSize();
nRasterYSize = poRasterDS->GetRasterYSize();
for( int iBand = 1; iBand <= poRasterDS->GetRasterCount();
iBand++ )
{
SetBand( iBand, new NGWWrapperRasterBand(
poRasterDS->GetRasterBand( iBand )) );
}
// Set pixel limits.
bool bHasTransform = false;
double geoTransform[6] = { 0.0 };
double invGeoTransform[6] = { 0.0 };
if(poRasterDS->GetGeoTransform(geoTransform) == CE_None)
{
bHasTransform = GDALInvGeoTransform(geoTransform,
invGeoTransform) == TRUE;
}
if(bHasTransform)
{
GDALApplyGeoTransform(invGeoTransform, stExtent.MinX,
stExtent.MinY, &stPixelExtent.MinX, &stPixelExtent.MaxY);
GDALApplyGeoTransform(invGeoTransform, stExtent.MaxX,
stExtent.MaxY, &stPixelExtent.MaxX, &stPixelExtent.MinY);
CPLDebug("NGW", "Raster extent in px is: %f, %f, %f, %f",
stPixelExtent.MinX, stPixelExtent.MinY,
stPixelExtent.MaxX, stPixelExtent.MaxY);
}
else
{
stPixelExtent.MinX = 0.0;
stPixelExtent.MinY = 0.0;
stPixelExtent.MaxX = std::numeric_limits<double>::max();
stPixelExtent.MaxY = std::numeric_limits<double>::max();
}
}
else
{
bResult = false;
}
}
else if( osResourceType == "raster_layer" ) //FIXME: Do we need this check? && nOpenFlagsIn & GDAL_OF_RASTER )
{
AddRaster( oRoot, papszHTTPOptions );
}
else
{
bResult = false;
}
// TODO: Add support for baselayers, webmap, wfsserver_service, wmsserver_service.
}
}
CSLDestroy( papszHTTPOptions );
return bResult;
}
int main( int argc, char ** argv )
{
const char *pszLocX = NULL, *pszLocY = NULL;
const char *pszSrcFilename = NULL;
char *pszSourceSRS = NULL;
std::vector<int> anBandList;
bool bAsXML = false, bLIFOnly = false;
bool bQuiet = false, bValOnly = false;
int nOverview = -1;
char **papszOpenOptions = NULL;
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
int i;
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],"-b") && i < argc-1 )
{
anBandList.push_back( atoi(argv[++i]) );
}
else if( EQUAL(argv[i],"-overview") && i < argc-1 )
{
nOverview = atoi(argv[++i]) - 1;
}
else if( EQUAL(argv[i],"-l_srs") && i < argc-1 )
{
CPLFree(pszSourceSRS);
pszSourceSRS = SanitizeSRS(argv[++i]);
}
else if( EQUAL(argv[i],"-geoloc") )
{
CPLFree(pszSourceSRS);
pszSourceSRS = CPLStrdup("-geoloc");
}
else if( EQUAL(argv[i],"-wgs84") )
{
CPLFree(pszSourceSRS);
pszSourceSRS = SanitizeSRS("WGS84");
}
else if( EQUAL(argv[i],"-xml") )
{
bAsXML = true;
}
else if( EQUAL(argv[i],"-lifonly") )
{
bLIFOnly = true;
bQuiet = true;
}
else if( EQUAL(argv[i],"-valonly") )
{
bValOnly = true;
bQuiet = true;
}
else if( EQUAL(argv[i], "-oo") && i < argc-1 )
{
papszOpenOptions = CSLAddString( papszOpenOptions,
argv[++i] );
}
else if( argv[i][0] == '-' && !isdigit(argv[i][1]) )
Usage();
else if( pszSrcFilename == NULL )
pszSrcFilename = argv[i];
else if( pszLocX == NULL )
pszLocX = argv[i];
else if( pszLocY == NULL )
pszLocY = argv[i];
else
Usage();
}
if( pszSrcFilename == NULL || (pszLocX != NULL && pszLocY == NULL) )
Usage();
/* -------------------------------------------------------------------- */
/* Open source file. */
/* -------------------------------------------------------------------- */
GDALDatasetH hSrcDS = NULL;
hSrcDS = GDALOpenEx( pszSrcFilename, GDAL_OF_RASTER, NULL,
(const char* const* )papszOpenOptions, NULL );
if( hSrcDS == NULL )
exit( 1 );
/* -------------------------------------------------------------------- */
/* Setup coordinate transformation, if required */
/* -------------------------------------------------------------------- */
OGRSpatialReferenceH hSrcSRS = NULL, hTrgSRS = NULL;
OGRCoordinateTransformationH hCT = NULL;
if( pszSourceSRS != NULL && !EQUAL(pszSourceSRS,"-geoloc") )
{
hSrcSRS = OSRNewSpatialReference( pszSourceSRS );
hTrgSRS = OSRNewSpatialReference( GDALGetProjectionRef( hSrcDS ) );
hCT = OCTNewCoordinateTransformation( hSrcSRS, hTrgSRS );
if( hCT == NULL )
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* If no bands were requested, we will query them all. */
/* -------------------------------------------------------------------- */
if( anBandList.size() == 0 )
{
for( i = 0; i < GDALGetRasterCount( hSrcDS ); i++ )
anBandList.push_back( i+1 );
}
/* -------------------------------------------------------------------- */
/* Turn the location into a pixel and line location. */
/* -------------------------------------------------------------------- */
int inputAvailable = 1;
double dfGeoX;
double dfGeoY;
CPLString osXML;
if( pszLocX == NULL && pszLocY == NULL )
{
if (fscanf(stdin, "%lf %lf", &dfGeoX, &dfGeoY) != 2)
{
inputAvailable = 0;
}
}
else
{
dfGeoX = CPLAtof(pszLocX);
dfGeoY = CPLAtof(pszLocY);
}
while (inputAvailable)
{
int iPixel, iLine;
if (hCT)
{
if( !OCTTransform( hCT, 1, &dfGeoX, &dfGeoY, NULL ) )
exit( 1 );
}
if( pszSourceSRS != NULL )
{
double adfGeoTransform[6], adfInvGeoTransform[6];
if( GDALGetGeoTransform( hSrcDS, adfGeoTransform ) != CE_None )
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot get geotransform");
exit( 1 );
}
if( !GDALInvGeoTransform( adfGeoTransform, adfInvGeoTransform ) )
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot invert geotransform");
exit( 1 );
}
iPixel = (int) floor(
adfInvGeoTransform[0]
+ adfInvGeoTransform[1] * dfGeoX
+ adfInvGeoTransform[2] * dfGeoY );
iLine = (int) floor(
adfInvGeoTransform[3]
+ adfInvGeoTransform[4] * dfGeoX
+ adfInvGeoTransform[5] * dfGeoY );
}
else
{
iPixel = (int) floor(dfGeoX);
iLine = (int) floor(dfGeoY);
}
/* -------------------------------------------------------------------- */
/* Prepare report. */
/* -------------------------------------------------------------------- */
CPLString osLine;
if( bAsXML )
{
osLine.Printf( "<Report pixel=\"%d\" line=\"%d\">",
iPixel, iLine );
osXML += osLine;
}
else if( !bQuiet )
{
printf( "Report:\n" );
printf( " Location: (%dP,%dL)\n", iPixel, iLine );
}
int bPixelReport = TRUE;
if( iPixel < 0 || iLine < 0
|| iPixel >= GDALGetRasterXSize( hSrcDS )
|| iLine >= GDALGetRasterYSize( hSrcDS ) )
{
if( bAsXML )
osXML += "<Alert>Location is off this file! No further details to report.</Alert>";
else if( bValOnly )
printf("\n");
else if( !bQuiet )
printf( "\nLocation is off this file! No further details to report.\n");
bPixelReport = FALSE;
}
/* -------------------------------------------------------------------- */
/* Process each band. */
/* -------------------------------------------------------------------- */
for( i = 0; bPixelReport && i < (int) anBandList.size(); i++ )
{
GDALRasterBandH hBand = GDALGetRasterBand( hSrcDS, anBandList[i] );
int iPixelToQuery = iPixel;
int iLineToQuery = iLine;
if (nOverview >= 0 && hBand != NULL)
{
GDALRasterBandH hOvrBand = GDALGetOverview(hBand, nOverview);
if (hOvrBand != NULL)
{
int nOvrXSize = GDALGetRasterBandXSize(hOvrBand);
int nOvrYSize = GDALGetRasterBandYSize(hOvrBand);
iPixelToQuery = (int)(0.5 + 1.0 * iPixel / GDALGetRasterXSize( hSrcDS ) * nOvrXSize);
iLineToQuery = (int)(0.5 + 1.0 * iLine / GDALGetRasterYSize( hSrcDS ) * nOvrYSize);
if (iPixelToQuery >= nOvrXSize)
iPixelToQuery = nOvrXSize - 1;
if (iLineToQuery >= nOvrYSize)
iLineToQuery = nOvrYSize - 1;
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot get overview %d of band %d",
nOverview + 1, anBandList[i] );
}
hBand = hOvrBand;
}
if (hBand == NULL)
continue;
if( bAsXML )
{
osLine.Printf( "<BandReport band=\"%d\">", anBandList[i] );
osXML += osLine;
}
else if( !bQuiet )
{
printf( " Band %d:\n", anBandList[i] );
}
/* -------------------------------------------------------------------- */
/* Request location info for this location. It is possible */
/* only the VRT driver actually supports this. */
/* -------------------------------------------------------------------- */
CPLString osItem;
osItem.Printf( "Pixel_%d_%d", iPixelToQuery, iLineToQuery );
const char *pszLI = GDALGetMetadataItem( hBand, osItem, "LocationInfo");
if( pszLI != NULL )
{
if( bAsXML )
osXML += pszLI;
else if( !bQuiet )
printf( " %s\n", pszLI );
else if( bLIFOnly )
{
/* Extract all files, if any. */
CPLXMLNode *psRoot = CPLParseXMLString( pszLI );
if( psRoot != NULL
&& psRoot->psChild != NULL
&& psRoot->eType == CXT_Element
&& EQUAL(psRoot->pszValue,"LocationInfo") )
{
CPLXMLNode *psNode;
for( psNode = psRoot->psChild;
psNode != NULL;
psNode = psNode->psNext )
{
if( psNode->eType == CXT_Element
&& EQUAL(psNode->pszValue,"File")
&& psNode->psChild != NULL )
{
char* pszUnescaped = CPLUnescapeString(
psNode->psChild->pszValue, NULL, CPLES_XML);
printf( "%s\n", pszUnescaped );
CPLFree(pszUnescaped);
}
}
}
CPLDestroyXMLNode( psRoot );
}
}
/* -------------------------------------------------------------------- */
/* Report the pixel value of this band. */
/* -------------------------------------------------------------------- */
double adfPixel[2];
if( GDALRasterIO( hBand, GF_Read, iPixelToQuery, iLineToQuery, 1, 1,
adfPixel, 1, 1, GDT_CFloat64, 0, 0) == CE_None )
{
CPLString osValue;
if( GDALDataTypeIsComplex( GDALGetRasterDataType( hBand ) ) )
osValue.Printf( "%.15g+%.15gi", adfPixel[0], adfPixel[1] );
else
osValue.Printf( "%.15g", adfPixel[0] );
if( bAsXML )
{
osXML += "<Value>";
osXML += osValue;
osXML += "</Value>";
}
else if( !bQuiet )
printf( " Value: %s\n", osValue.c_str() );
else if( bValOnly )
printf( "%s\n", osValue.c_str() );
// Report unscaled if we have scale/offset values.
int bSuccess;
double dfOffset = GDALGetRasterOffset( hBand, &bSuccess );
double dfScale = GDALGetRasterScale( hBand, &bSuccess );
if( dfOffset != 0.0 || dfScale != 1.0 )
{
adfPixel[0] = adfPixel[0] * dfScale + dfOffset;
adfPixel[1] = adfPixel[1] * dfScale + dfOffset;
if( GDALDataTypeIsComplex( GDALGetRasterDataType( hBand ) ) )
osValue.Printf( "%.15g+%.15gi", adfPixel[0], adfPixel[1] );
else
osValue.Printf( "%.15g", adfPixel[0] );
if( bAsXML )
{
osXML += "<DescaledValue>";
osXML += osValue;
osXML += "</DescaledValue>";
}
else if( !bQuiet )
printf( " Descaled Value: %s\n", osValue.c_str() );
}
}
if( bAsXML )
osXML += "</BandReport>";
}
osXML += "</Report>";
if( (pszLocX != NULL && pszLocY != NULL) ||
(fscanf(stdin, "%lf %lf", &dfGeoX, &dfGeoY) != 2) )
{
inputAvailable = 0;
}
}
/* -------------------------------------------------------------------- */
/* Finalize xml report and print. */
/* -------------------------------------------------------------------- */
if( bAsXML )
{
CPLXMLNode *psRoot;
char *pszFormattedXML;
psRoot = CPLParseXMLString( osXML );
pszFormattedXML = CPLSerializeXMLTree( psRoot );
CPLDestroyXMLNode( psRoot );
printf( "%s", pszFormattedXML );
CPLFree( pszFormattedXML );
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
if (hCT) {
OSRDestroySpatialReference( hSrcSRS );
OSRDestroySpatialReference( hTrgSRS );
OCTDestroyCoordinateTransformation( hCT );
}
if (hSrcDS)
GDALClose(hSrcDS);
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLFree(pszSourceSRS);
CSLDestroy(papszOpenOptions);
CSLDestroy( argv );
return 0;
}
QgsDataItem *QgsOgrDataItemProvider::createDataItem( const QString &pathIn, QgsDataItem *parentItem )
{
QString path( pathIn );
if ( path.isEmpty() )
return nullptr;
QgsDebugMsgLevel( "thePath: " + path, 2 );
// zip settings + info
QgsSettings settings;
QString scanZipSetting = settings.value( QStringLiteral( "qgis/scanZipInBrowser2" ), "basic" ).toString();
QString vsiPrefix = QgsZipItem::vsiPrefix( path );
bool is_vsizip = ( vsiPrefix == QLatin1String( "/vsizip/" ) );
bool is_vsigzip = ( vsiPrefix == QLatin1String( "/vsigzip/" ) );
bool is_vsitar = ( vsiPrefix == QLatin1String( "/vsitar/" ) );
// should we check ext. only?
// check if scanItemsInBrowser2 == extension or parent dir in scanItemsFastScanUris
// TODO - do this in dir item, but this requires a way to inform which extensions are supported by provider
// maybe a callback function or in the provider registry?
bool scanExtSetting = false;
if ( ( settings.value( QStringLiteral( "qgis/scanItemsInBrowser2" ),
"extension" ).toString() == QLatin1String( "extension" ) ) ||
( parentItem && settings.value( QStringLiteral( "qgis/scanItemsFastScanUris" ),
QStringList() ).toStringList().contains( parentItem->path() ) ) ||
( ( is_vsizip || is_vsitar ) && parentItem && parentItem->parent() &&
settings.value( QStringLiteral( "qgis/scanItemsFastScanUris" ),
QStringList() ).toStringList().contains( parentItem->parent()->path() ) ) )
{
scanExtSetting = true;
}
// get suffix, removing .gz if present
QString tmpPath = path; //path used for testing, not for layer creation
if ( is_vsigzip )
tmpPath.chop( 3 );
QFileInfo info( tmpPath );
QString suffix = info.suffix().toLower();
// extract basename with extension
info.setFile( path );
QString name = info.fileName();
// If a .tab exists, then the corresponding .map/.dat is very likely a
// side-car file of the .tab
if ( suffix == QLatin1String( "map" ) || suffix == QLatin1String( "dat" ) )
{
if ( QFileInfo( QDir( info.path() ), info.baseName() + ".tab" ).exists() )
return nullptr;
}
QgsDebugMsgLevel( "thePath= " + path + " tmpPath= " + tmpPath + " name= " + name
+ " suffix= " + suffix + " vsiPrefix= " + vsiPrefix, 3 );
QStringList myExtensions = fileExtensions();
QStringList dirExtensions = directoryExtensions();
// allow only normal files, supported directories, or VSIFILE items to continue
bool isOgrSupportedDirectory = info.isDir() && dirExtensions.contains( suffix );
if ( !isOgrSupportedDirectory && !info.isFile() && vsiPrefix.isEmpty() )
return nullptr;
// skip *.aux.xml files (GDAL auxiliary metadata files),
// *.shp.xml files (ESRI metadata) and *.tif.xml files (TIFF metadata)
// unless that extension is in the list (*.xml might be though)
if ( path.endsWith( QLatin1String( ".aux.xml" ), Qt::CaseInsensitive ) &&
!myExtensions.contains( QStringLiteral( "aux.xml" ) ) )
return nullptr;
if ( path.endsWith( QLatin1String( ".shp.xml" ), Qt::CaseInsensitive ) &&
!myExtensions.contains( QStringLiteral( "shp.xml" ) ) )
return nullptr;
if ( path.endsWith( QLatin1String( ".tif.xml" ), Qt::CaseInsensitive ) &&
!myExtensions.contains( QStringLiteral( "tif.xml" ) ) )
return nullptr;
// skip QGIS style xml files
if ( path.endsWith( QLatin1String( ".xml" ), Qt::CaseInsensitive ) &&
QgsStyle::isXmlStyleFile( path ) )
return nullptr;
// We have to filter by extensions, otherwise e.g. all Shapefile files are displayed
// because OGR drive can open also .dbf, .shx.
if ( myExtensions.indexOf( suffix ) < 0 && !dirExtensions.contains( suffix ) )
{
bool matches = false;
const auto constWildcards = wildcards();
for ( const QString &wildcard : constWildcards )
{
QRegExp rx( wildcard, Qt::CaseInsensitive, QRegExp::Wildcard );
if ( rx.exactMatch( info.fileName() ) )
{
matches = true;
break;
}
}
if ( !matches )
return nullptr;
}
// .dbf should probably appear if .shp is not present
if ( suffix == QLatin1String( "dbf" ) )
{
QString pathShp = path.left( path.count() - 4 ) + ".shp";
if ( QFileInfo::exists( pathShp ) )
return nullptr;
}
// fix vsifile path and name
if ( !vsiPrefix.isEmpty() )
{
// add vsiPrefix to path if needed
if ( !path.startsWith( vsiPrefix ) )
path = vsiPrefix + path;
// if this is a /vsigzip/path_to_zip.zip/file_inside_zip remove the full path from the name
// no need to change the name I believe
#if 0
if ( ( is_vsizip || is_vsitar ) && ( path != vsiPrefix + parentItem->path() ) )
{
name = path;
name = name.replace( vsiPrefix + parentItem->path() + '/', "" );
}
#endif
}
// Filters out the OGR/GDAL supported formats that can contain multiple layers
// and should be treated like a DB: GeoPackage and SQLite
// NOTE: this formats are scanned for rasters too and they must
// be skipped by "gdal" provider or the rasters will be listed
// twice. ogrSupportedDbLayersExtensions must be kept in sync
// with the companion variable (same name) in the gdal provider
// class
// TODO: add more OGR supported multiple layers formats here!
static QStringList sOgrSupportedDbLayersExtensions { QStringLiteral( "gpkg" ),
QStringLiteral( "sqlite" ),
QStringLiteral( "db" ),
QStringLiteral( "gdb" ),
QStringLiteral( "kml" ) };
static QStringList sOgrSupportedDbDriverNames { QStringLiteral( "GPKG" ),
QStringLiteral( "db" ),
QStringLiteral( "gdb" ) };
// these extensions are trivial to read, so there's no need to rely on
// the extension only scan here -- avoiding it always gives us the correct data type
// and sublayer visiblity
static QStringList sSkipFastTrackExtensions { QStringLiteral( "xlsx" ),
QStringLiteral( "ods" ),
QStringLiteral( "csv" ),
QStringLiteral( "nc" ) };
// Fast track: return item without testing if:
// scanExtSetting or zipfile and scan zip == "Basic scan"
// netCDF files can be both raster or vector, so fallback to opening
if ( ( scanExtSetting ||
( ( is_vsizip || is_vsitar ) && scanZipSetting == QLatin1String( "basic" ) ) ) &&
!sSkipFastTrackExtensions.contains( suffix ) )
{
// if this is a VRT file make sure it is vector VRT to avoid duplicates
if ( suffix == QLatin1String( "vrt" ) )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
CPLErrorReset();
GDALDriverH hDriver = GDALIdentifyDriver( path.toUtf8().constData(), nullptr );
CPLPopErrorHandler();
if ( !hDriver || GDALGetDriverShortName( hDriver ) == QLatin1String( "VRT" ) )
{
QgsDebugMsgLevel( QStringLiteral( "Skipping VRT file because root is not a OGR VRT" ), 2 );
return nullptr;
}
}
// Handle collections
// Check if the layer has sublayers by comparing the extension
QgsDataItem *item = nullptr;
if ( ! sOgrSupportedDbLayersExtensions.contains( suffix ) )
{
item = new QgsOgrLayerItem( parentItem, name, path, path, QgsLayerItem::Vector );
}
else if ( suffix.compare( QLatin1String( "gpkg" ), Qt::CaseInsensitive ) == 0 )
{
item = new QgsGeoPackageCollectionItem( parentItem, name, path );
}
else
{
item = new QgsOgrDataCollectionItem( parentItem, name, path );
}
if ( item )
return item;
}
// Slow track: scan file contents
QgsDataItem *item = nullptr;
// test that file is valid with OGR
if ( OGRGetDriverCount() == 0 )
{
OGRRegisterAll();
}
// do not print errors, but write to debug
CPLPushErrorHandler( CPLQuietErrorHandler );
CPLErrorReset();
gdal::dataset_unique_ptr hDS( GDALOpenEx( path.toUtf8().constData(), GDAL_OF_VECTOR, nullptr, nullptr, nullptr ) );
CPLPopErrorHandler();
if ( ! hDS )
{
QgsDebugMsg( QStringLiteral( "GDALOpen error # %1 : %2 on %3" ).arg( CPLGetLastErrorNo() ).arg( CPLGetLastErrorMsg() ).arg( path ) );
return nullptr;
}
GDALDriverH hDriver = GDALGetDatasetDriver( hDS.get() );
QString driverName = GDALGetDriverShortName( hDriver );
QgsDebugMsgLevel( QStringLiteral( "GDAL Driver : %1" ).arg( driverName ), 2 );
int numLayers = GDALDatasetGetLayerCount( hDS.get() );
// GeoPackage needs a specialized data item, mainly because of raster deletion not
// yet implemented in GDAL (2.2.1)
if ( driverName == QLatin1String( "GPKG" ) )
{
item = new QgsGeoPackageCollectionItem( parentItem, name, path );
}
else if ( numLayers > 1 || sOgrSupportedDbDriverNames.contains( driverName ) )
{
item = new QgsOgrDataCollectionItem( parentItem, name, path );
}
else
{
item = dataItemForLayer( parentItem, name, path, hDS.get(), 0, false, true );
}
return item;
}
void GDALDefaultOverviews::OverviewScan()
{
if( bCheckedForOverviews || poDS == NULL )
return;
bCheckedForOverviews = true;
CPLDebug( "GDAL", "GDALDefaultOverviews::OverviewScan()" );
/* -------------------------------------------------------------------- */
/* Open overview dataset if it exists. */
/* -------------------------------------------------------------------- */
if( pszInitName == NULL )
pszInitName = CPLStrdup(poDS->GetDescription());
if( !EQUAL(pszInitName,":::VIRTUAL:::") &&
GDALCanFileAcceptSidecarFile(pszInitName) )
{
if( bInitNameIsOVR )
osOvrFilename = pszInitName;
else
osOvrFilename.Printf( "%s.ovr", pszInitName );
std::vector<char> achOvrFilename;
achOvrFilename.resize(osOvrFilename.size() + 1);
memcpy(&(achOvrFilename[0]),
osOvrFilename.c_str(),
osOvrFilename.size() + 1);
bool bExists = CPL_TO_BOOL(
CPLCheckForFile( &achOvrFilename[0], papszInitSiblingFiles ) );
osOvrFilename = &achOvrFilename[0];
#if !defined(WIN32)
if( !bInitNameIsOVR && !bExists && !papszInitSiblingFiles )
{
osOvrFilename.Printf( "%s.OVR", pszInitName );
memcpy(&(achOvrFilename[0]),
osOvrFilename.c_str(),
osOvrFilename.size() + 1);
bExists = CPL_TO_BOOL(
CPLCheckForFile( &achOvrFilename[0], papszInitSiblingFiles ) );
osOvrFilename = &achOvrFilename[0];
if( !bExists )
osOvrFilename.Printf( "%s.ovr", pszInitName );
}
#endif
if( bExists )
{
poODS = static_cast<GDALDataset *>( GDALOpenEx(
osOvrFilename,
GDAL_OF_RASTER |
(poDS->GetAccess() == GA_Update ? GDAL_OF_UPDATE : 0),
NULL, NULL, papszInitSiblingFiles ) );
}
}
/* -------------------------------------------------------------------- */
/* We didn't find that, so try and find a corresponding aux */
/* file. Check that we are the dependent file of the aux */
/* file. */
/* */
/* We only use the .aux file for overviews if they already have */
/* overviews existing, or if USE_RRD is set true. */
/* -------------------------------------------------------------------- */
if( !poODS && !EQUAL(pszInitName,":::VIRTUAL:::") &&
GDALCanFileAcceptSidecarFile(pszInitName) )
{
bool bTryFindAssociatedAuxFile = true;
if( papszInitSiblingFiles )
{
CPLString osAuxFilename = CPLResetExtension( pszInitName, "aux");
int iSibling = CSLFindString( papszInitSiblingFiles,
CPLGetFilename(osAuxFilename) );
if( iSibling < 0 )
{
osAuxFilename = pszInitName;
osAuxFilename += ".aux";
iSibling = CSLFindString( papszInitSiblingFiles,
CPLGetFilename(osAuxFilename) );
if( iSibling < 0 )
bTryFindAssociatedAuxFile = false;
}
}
if( bTryFindAssociatedAuxFile )
{
poODS = GDALFindAssociatedAuxFile( pszInitName, poDS->GetAccess(),
poDS );
}
if( poODS )
{
const bool bUseRRD = CPLTestBool(CPLGetConfigOption("USE_RRD","NO"));
bOvrIsAux = true;
if( GetOverviewCount(1) == 0 && !bUseRRD )
{
bOvrIsAux = false;
GDALClose( poODS );
poODS = NULL;
}
else
{
osOvrFilename = poODS->GetDescription();
}
}
}
/* -------------------------------------------------------------------- */
/* If we still don't have an overview, check to see if we have */
/* overview metadata referencing a remote (i.e. proxy) or local */
/* subdataset overview dataset. */
/* -------------------------------------------------------------------- */
if( poODS == NULL )
{
const char *pszProxyOvrFilename =
poDS->GetMetadataItem( "OVERVIEW_FILE", "OVERVIEWS" );
if( pszProxyOvrFilename != NULL )
{
if( STARTS_WITH_CI(pszProxyOvrFilename, ":::BASE:::") )
{
const CPLString osPath = CPLGetPath(poDS->GetDescription());
osOvrFilename =
CPLFormFilename( osPath, pszProxyOvrFilename+10, NULL );
}
else
{
osOvrFilename = pszProxyOvrFilename;
}
CPLPushErrorHandler(CPLQuietErrorHandler);
poODS = static_cast<GDALDataset *>(GDALOpen(osOvrFilename, poDS->GetAccess()));
CPLPopErrorHandler();
}
}
/* -------------------------------------------------------------------- */
/* If we have an overview dataset, then mark all the overviews */
/* with the base dataset Used later for finding overviews */
/* masks. Uggg. */
/* -------------------------------------------------------------------- */
if( poODS )
{
const int nOverviewCount = GetOverviewCount(1);
for( int iOver = 0; iOver < nOverviewCount; iOver++ )
{
GDALRasterBand * const poBand = GetOverview( 1, iOver );
GDALDataset * const poOverDS = poBand != NULL ?
poBand->GetDataset() : NULL;
if( poOverDS != NULL )
{
poOverDS->oOvManager.poBaseDS = poDS;
poOverDS->oOvManager.poDS = poOverDS;
}
}
}
}
int main( int nArgc, char ** papszArgv )
{
int bQuiet = FALSE;
const char *pszDataSource = NULL;
GNMGFID nFromFID = -1;
GNMGFID nToFID = -1;
int nK = 1;
const char *pszDataset = NULL;
const char *pszFormat = "ESRI Shapefile";
const char *pszLayer = NULL;
GNMNetwork *poDS = NULL;
OGRLayer* poResultLayer = NULL;
char **papszDSCO = NULL, **papszLCO = NULL, **papszALO = NULL;
operation stOper = op_unknown;
int nRet = 0;
// 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). */
/* -------------------------------------------------------------------- */
GDALAllRegister();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = GDALGeneralCmdLineProcessor( nArgc, &papszArgv, GDAL_OF_GNM );
if( nArgc < 1 )
{
exit( -nArgc );
}
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[1], "--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],"--help") )
{
Usage();
}
else if ( EQUAL(papszArgv[iArg], "--long-usage") )
{
Usage(FALSE);
}
else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet") )
{
bQuiet = TRUE;
}
else if( EQUAL(papszArgv[iArg],"dijkstra") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
stOper = op_dijkstra;
nFromFID = atoi(papszArgv[++iArg]);
nToFID = atoi(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg],"kpaths") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(3);
stOper = op_kpaths;
nFromFID = atoi(papszArgv[++iArg]);
nToFID = atoi(papszArgv[++iArg]);
nK = atoi(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg],"resource") )
{
stOper = op_resource;
}
else if( EQUAL(papszArgv[iArg],"-ds") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszDataset = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-f") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszFormat = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-l") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszLayer = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-dsco") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszDSCO = CSLAddString(papszDSCO, papszArgv[++iArg] );
}
else if( EQUAL(papszArgv[iArg],"-lco") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszLCO = CSLAddString(papszLCO, papszArgv[++iArg] );
}
else if( EQUAL(papszArgv[iArg],"-alo") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszALO = CSLAddString(papszALO, papszArgv[++iArg] );
}
else if( papszArgv[iArg][0] == '-' )
{
Usage(CPLSPrintf("Unknown option name '%s'", papszArgv[iArg]));
}
else if( pszDataSource == NULL )
pszDataSource = papszArgv[iArg];
}
// do the work ////////////////////////////////////////////////////////////////
if(stOper == op_dijkstra)
{
if(pszDataSource == NULL)
Usage("No network dataset provided");
if(nFromFID == -1 || nToFID == -1)
Usage("Invalid input from or to identificators");
// open
poDS = (GNMNetwork*) GDALOpenEx( pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_GNM, NULL, NULL, NULL );
if(NULL == poDS)
{
fprintf( stderr, "\nFailed to open network at %s\n", pszDataSource);
nRet = 1;
goto exit;
}
poResultLayer = poDS->GetPath(nFromFID, nToFID, GATDijkstraShortestPath,
papszALO);
if(NULL == pszDataset)
{
ReportOnLayer(poResultLayer, bQuiet == FALSE);
}
else
{
if(CreateAndFillOutputDataset(poResultLayer, pszDataset, pszFormat,
pszLayer, papszDSCO, papszLCO, bQuiet)
!= OGRERR_NONE)
{
nRet = 1;
goto exit;
}
}
}
else if(stOper == op_kpaths)
{
if(pszDataSource == NULL)
Usage("No network dataset provided");
if(nFromFID == -1 || nToFID == -1)
Usage("Invalid input from or to identificators");
// open
poDS = (GNMNetwork*) GDALOpenEx( pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_GNM, NULL, NULL, NULL );
if(NULL == poDS)
{
fprintf( stderr, "\nFailed to open network at %s\n", pszDataSource);
nRet = 1;
goto exit;
}
if(CSLFindName(papszALO, GNM_MD_NUM_PATHS) == -1)
{
CPLDebug("GNM", "No K in options, add %d value", nK);
papszALO = CSLAddNameValue(papszALO, GNM_MD_NUM_PATHS,
CPLSPrintf("%d", nK));
}
poResultLayer = poDS->GetPath(nFromFID, nToFID, GATKShortestPath,
papszALO);
if(NULL == pszDataset)
{
ReportOnLayer(poResultLayer, bQuiet == FALSE);
}
else
{
if(CreateAndFillOutputDataset(poResultLayer, pszDataset, pszFormat,
pszLayer, papszDSCO, papszLCO, bQuiet)
!= OGRERR_NONE)
{
nRet = 1;
goto exit;
}
}
}
else if(stOper == op_resource)
{
if(pszDataSource == NULL)
Usage("No network dataset provided");
// open
poDS = (GNMNetwork*) GDALOpenEx( pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_GNM, NULL, NULL, NULL );
if(NULL == poDS)
{
fprintf( stderr, "\nFailed to open network at %s\n", pszDataSource);
nRet = 1;
goto exit;
}
poResultLayer = poDS->GetPath(nFromFID, nToFID, GATConnectedComponents,
papszALO);
if(NULL == pszDataset)
{
ReportOnLayer(poResultLayer, bQuiet == FALSE);
}
else
{
if(CreateAndFillOutputDataset(poResultLayer, pszDataset, pszFormat,
pszLayer, papszDSCO, papszLCO, bQuiet)
!= OGRERR_NONE)
{
nRet = 1;
goto exit;
}
}
}
else
{
printf("\nNeed an operation. See help what you can do with gnmanalyse:\n");
Usage();
}
exit:
CSLDestroy(papszDSCO);
CSLDestroy(papszLCO);
CSLDestroy(papszALO);
if(poResultLayer != NULL)
poDS->ReleaseResultSet(poResultLayer);
if( poDS != NULL )
GDALClose( (GDALDatasetH)poDS );
GDALDestroyDriverManager();
return nRet;
}
void GDALJP2AbstractDataset::LoadVectorLayers(int bOpenRemoteResources)
{
char** papszGMLJP2 = GetMetadata("xml:gml.root-instance");
if( papszGMLJP2 == NULL )
return;
GDALDriver* poMemDriver = (GDALDriver*)GDALGetDriverByName("Memory");
if( poMemDriver == NULL )
return;
CPLXMLNode* psRoot = CPLParseXMLString(papszGMLJP2[0]);
if( psRoot == NULL )
return;
CPLXMLNode* psCC = CPLGetXMLNode(psRoot, "=gmljp2:GMLJP2CoverageCollection");
if( psCC == NULL )
{
CPLDestroyXMLNode(psRoot);
return;
}
// Find feature collections
CPLXMLNode* psCCChildIter = psCC->psChild;
int nLayersAtCC = 0;
int nLayersAtGC = 0;
for( ; psCCChildIter != NULL; psCCChildIter = psCCChildIter->psNext )
{
if( psCCChildIter->eType != CXT_Element ||
strcmp(psCCChildIter->pszValue, "gmljp2:featureMember") != 0 ||
psCCChildIter->psChild == NULL ||
psCCChildIter->psChild->eType != CXT_Element )
continue;
CPLXMLNode* psGCorGMLJP2Features = psCCChildIter->psChild;
int bIsGC = ( strstr(psGCorGMLJP2Features->pszValue, "GridCoverage") != NULL );
CPLXMLNode* psGCorGMLJP2FeaturesChildIter = psGCorGMLJP2Features->psChild;
for( ; psGCorGMLJP2FeaturesChildIter != NULL;
psGCorGMLJP2FeaturesChildIter = psGCorGMLJP2FeaturesChildIter->psNext )
{
if( psGCorGMLJP2FeaturesChildIter->eType != CXT_Element ||
strcmp(psGCorGMLJP2FeaturesChildIter->pszValue, "gmljp2:feature") != 0 ||
psGCorGMLJP2FeaturesChildIter->psChild == NULL )
continue;
CPLXMLNode* psFC = NULL;
int bFreeFC = FALSE;
CPLString osGMLTmpFile;
CPLXMLNode* psChild = psGCorGMLJP2FeaturesChildIter->psChild;
if( psChild->eType == CXT_Attribute &&
strcmp(psChild->pszValue, "xlink:href") == 0 &&
strncmp(psChild->psChild->pszValue,
"gmljp2://xml/", strlen("gmljp2://xml/")) == 0 )
{
const char* pszBoxName = psChild->psChild->pszValue + strlen("gmljp2://xml/");
char** papszBoxData = GetMetadata(CPLSPrintf("xml:%s", pszBoxName));
if( papszBoxData != NULL )
{
psFC = CPLParseXMLString(papszBoxData[0]);
bFreeFC = TRUE;
}
else
{
CPLDebug("GMLJP2",
"gmljp2:feature references %s, but no corresponding box found",
psChild->psChild->pszValue);
}
}
if( psChild->eType == CXT_Attribute &&
strcmp(psChild->pszValue, "xlink:href") == 0 &&
(strncmp(psChild->psChild->pszValue, "http://", strlen("http://")) == 0 ||
strncmp(psChild->psChild->pszValue, "https://", strlen("https://")) == 0) )
{
if( !bOpenRemoteResources )
CPLDebug("GMLJP2", "Remote feature collection %s mentionned in GMLJP2 box",
psChild->psChild->pszValue);
else
osGMLTmpFile = "/vsicurl/" + CPLString(psChild->psChild->pszValue);
}
else if( psChild->eType == CXT_Element &&
strstr(psChild->pszValue, "FeatureCollection") != NULL )
{
psFC = psChild;
}
if( psFC == NULL && osGMLTmpFile.size() == 0 )
continue;
if( psFC != NULL )
{
osGMLTmpFile = CPLSPrintf("/vsimem/gmljp2/%p/my.gml", this);
// Create temporary .gml file
CPLSerializeXMLTreeToFile(psFC, osGMLTmpFile);
}
CPLDebug("GMLJP2", "Found a FeatureCollection at %s level",
(bIsGC) ? "GridCoverage" : "CoverageCollection");
CPLString osXSDTmpFile;
if( psFC )
{
// Try to localize its .xsd schema in a GMLJP2 auxiliary box
const char* pszSchemaLocation = CPLGetXMLValue(psFC, "xsi:schemaLocation", NULL);
if( pszSchemaLocation )
{
char **papszTokens = CSLTokenizeString2(
pszSchemaLocation, " \t\n",
CSLT_HONOURSTRINGS | CSLT_STRIPLEADSPACES | CSLT_STRIPENDSPACES);
if( (CSLCount(papszTokens) % 2) == 0 )
{
for(char** papszIter = papszTokens; *papszIter; papszIter += 2 )
{
if( strncmp(papszIter[1], "gmljp2://xml/", strlen("gmljp2://xml/")) == 0 )
{
const char* pszBoxName = papszIter[1] + strlen("gmljp2://xml/");
char** papszBoxData = GetMetadata(CPLSPrintf("xml:%s", pszBoxName));
if( papszBoxData != NULL )
{
osXSDTmpFile = CPLSPrintf("/vsimem/gmljp2/%p/my.xsd", this);
VSIFCloseL(VSIFileFromMemBuffer(osXSDTmpFile,
(GByte*)papszBoxData[0],
strlen(papszBoxData[0]),
FALSE));
}
else
{
CPLDebug("GMLJP2",
"Feature collection references %s, but no corresponding box found",
papszIter[1]);
}
break;
}
}
}
CSLDestroy(papszTokens);
}
if( bFreeFC )
{
CPLDestroyXMLNode(psFC);
psFC = NULL;
}
}
GDALDriverH hDrv = GDALIdentifyDriver(osGMLTmpFile, NULL);
GDALDriverH hGMLDrv = GDALGetDriverByName("GML");
if( hDrv != NULL && hDrv == hGMLDrv )
{
char* apszOpenOptions[2];
apszOpenOptions[0] = (char*) "FORCE_SRS_DETECTION=YES";
apszOpenOptions[1] = NULL;
GDALDataset* poTmpDS = (GDALDataset*)GDALOpenEx( osGMLTmpFile,
GDAL_OF_VECTOR, NULL, apszOpenOptions, NULL );
if( poTmpDS )
{
int nLayers = poTmpDS->GetLayerCount();
for(int i=0;i<nLayers;i++)
{
if( poMemDS == NULL )
poMemDS = poMemDriver->Create("", 0, 0, 0, GDT_Unknown, NULL);
OGRLayer* poSrcLyr = poTmpDS->GetLayer(i);
const char* pszLayerName;
if( bIsGC )
pszLayerName = CPLSPrintf("FC_GridCoverage_%d_%s",
++nLayersAtGC, poSrcLyr->GetName());
else
pszLayerName = CPLSPrintf("FC_CoverageCollection_%d_%s",
++nLayersAtCC, poSrcLyr->GetName());
poMemDS->CopyLayer(poSrcLyr, pszLayerName, NULL);
}
GDALClose(poTmpDS);
// In case we don't have a schema, a .gfs might have been generated
VSIUnlink(CPLSPrintf("/vsimem/gmljp2/%p/my.gfs", this));
}
}
else
{
CPLDebug("GMLJP2", "No GML driver found to read feature collection");
}
if( strncmp(osGMLTmpFile, "/vsicurl/", strlen("/vsicurl/")) != 0 )
VSIUnlink(osGMLTmpFile);
if( osXSDTmpFile.size() )
VSIUnlink(osXSDTmpFile);
}
}
// Find annotations
psCCChildIter = psCC->psChild;
int nAnnotations = 0;
for( ; psCCChildIter != NULL; psCCChildIter = psCCChildIter->psNext )
{
if( psCCChildIter->eType != CXT_Element ||
strcmp(psCCChildIter->pszValue, "gmljp2:featureMember") != 0 ||
psCCChildIter->psChild == NULL ||
psCCChildIter->psChild->eType != CXT_Element )
continue;
CPLXMLNode* psGCorGMLJP2Features = psCCChildIter->psChild;
int bIsGC = ( strstr(psGCorGMLJP2Features->pszValue, "GridCoverage") != NULL );
if( !bIsGC )
continue;
CPLXMLNode* psGCorGMLJP2FeaturesChildIter = psGCorGMLJP2Features->psChild;
for( ; psGCorGMLJP2FeaturesChildIter != NULL;
psGCorGMLJP2FeaturesChildIter = psGCorGMLJP2FeaturesChildIter->psNext )
{
if( psGCorGMLJP2FeaturesChildIter->eType != CXT_Element ||
strcmp(psGCorGMLJP2FeaturesChildIter->pszValue, "gmljp2:annotation") != 0 ||
psGCorGMLJP2FeaturesChildIter->psChild == NULL ||
psGCorGMLJP2FeaturesChildIter->psChild->eType != CXT_Element ||
strstr(psGCorGMLJP2FeaturesChildIter->psChild->pszValue, "kml") == NULL )
continue;
CPLDebug("GMLJP2", "Found a KML annotation");
// Create temporary .kml file
CPLXMLNode* psKML = psGCorGMLJP2FeaturesChildIter->psChild;
CPLString osKMLTmpFile(CPLSPrintf("/vsimem/gmljp2/%p/my.kml", this));
CPLSerializeXMLTreeToFile(psKML, osKMLTmpFile);
GDALDataset* poTmpDS = (GDALDataset*)GDALOpenEx( osKMLTmpFile,
GDAL_OF_VECTOR, NULL, NULL, NULL );
if( poTmpDS )
{
int nLayers = poTmpDS->GetLayerCount();
for(int i=0;i<nLayers;i++)
{
if( poMemDS == NULL )
poMemDS = poMemDriver->Create("", 0, 0, 0, GDT_Unknown, NULL);
OGRLayer* poSrcLyr = poTmpDS->GetLayer(i);
const char* pszLayerName;
pszLayerName = CPLSPrintf("Annotation_%d_%s",
++nAnnotations, poSrcLyr->GetName());
poMemDS->CopyLayer(poSrcLyr, pszLayerName, NULL);
}
GDALClose(poTmpDS);
}
else
{
CPLDebug("GMLJP2", "No KML/LIBKML driver found to read annotation");
}
VSIUnlink(osKMLTmpFile);
}
}
CPLDestroyXMLNode(psRoot);
}
int main( int argc, char ** argv )
{
EarlySetConfigOptions(argc, argv);
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
for( int i = 0; argv != NULL && argv[i] != NULL; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
CSLDestroy( argv );
return 0;
}
else if( EQUAL(argv[i],"--help") )
{
Usage();
}
}
GDALInfoOptionsForBinary* psOptionsForBinary = GDALInfoOptionsForBinaryNew();
GDALInfoOptions *psOptions
= GDALInfoOptionsNew(argv + 1, psOptionsForBinary);
if( psOptions == NULL )
Usage();
if( psOptionsForBinary->pszFilename == NULL )
Usage("No datasource specified.");
/* -------------------------------------------------------------------- */
/* Open dataset. */
/* -------------------------------------------------------------------- */
GDALDatasetH hDataset
= GDALOpenEx( psOptionsForBinary->pszFilename, GDAL_OF_READONLY | GDAL_OF_RASTER, NULL,
(const char* const* )psOptionsForBinary->papszOpenOptions, NULL );
if( hDataset == NULL )
{
fprintf( stderr,
"gdalinfo failed - unable to open '%s'.\n",
psOptionsForBinary->pszFilename );
/* -------------------------------------------------------------------- */
/* If argument is a VSIFILE, then print its contents */
/* -------------------------------------------------------------------- */
if ( STARTS_WITH(psOptionsForBinary->pszFilename, "/vsizip/") ||
STARTS_WITH(psOptionsForBinary->pszFilename, "/vsitar/") )
{
char** papszFileList = VSIReadDirRecursive( psOptionsForBinary->pszFilename );
if ( papszFileList )
{
int nCount = CSLCount( papszFileList );
fprintf( stdout,
"Unable to open source `%s' directly.\n"
"The archive contains %d files:\n",
psOptionsForBinary->pszFilename, nCount );
for ( int i = 0; i < nCount; i++ )
{
fprintf( stdout, " %s/%s\n", psOptionsForBinary->pszFilename, papszFileList[i] );
}
CSLDestroy( papszFileList );
}
}
CSLDestroy( argv );
GDALInfoOptionsForBinaryFree(psOptionsForBinary);
GDALInfoOptionsFree( psOptions );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLDumpSharedList( NULL );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Read specified subdataset if requested. */
/* -------------------------------------------------------------------- */
if ( psOptionsForBinary->nSubdataset > 0 )
{
char **papszSubdatasets = GDALGetMetadata( hDataset, "SUBDATASETS" );
int nSubdatasets = CSLCount( papszSubdatasets );
if ( nSubdatasets > 0 && psOptionsForBinary->nSubdataset <= nSubdatasets )
{
char szKeyName[1024];
char *pszSubdatasetName;
snprintf( szKeyName, sizeof(szKeyName),
"SUBDATASET_%d_NAME", psOptionsForBinary->nSubdataset );
szKeyName[sizeof(szKeyName) - 1] = '\0';
pszSubdatasetName =
CPLStrdup( CSLFetchNameValue( papszSubdatasets, szKeyName ) );
GDALClose( hDataset );
hDataset = GDALOpen( pszSubdatasetName, GA_ReadOnly );
CPLFree( pszSubdatasetName );
}
else
{
fprintf( stderr,
"gdalinfo warning: subdataset %d of %d requested. "
"Reading the main dataset.\n",
psOptionsForBinary->nSubdataset, nSubdatasets );
}
}
GDALInfoOptionsForBinaryFree(psOptionsForBinary);
char* pszGDALInfoOutput = GDALInfo( hDataset, psOptions );
printf( "%s", pszGDALInfoOutput );
CPLFree( pszGDALInfoOutput );
GDALInfoOptionsFree( psOptions );
GDALClose( hDataset );
CSLDestroy( argv );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLDumpSharedList( NULL );
CPLCleanupTLS();
exit( 0 );
}
int HDF5Dataset::Identify( GDALOpenInfo * poOpenInfo )
{
// Is it an HDF5 file?
constexpr char achSignature[] = "\211HDF\r\n\032\n";
if( !poOpenInfo->pabyHeader )
return FALSE;
if( memcmp(poOpenInfo->pabyHeader, achSignature, 8) == 0 )
{
CPLString osExt(CPLGetExtension(poOpenInfo->pszFilename));
// The tests to avoid opening KEA and BAG drivers are not
// necessary when drivers are built in the core lib, as they
// are registered after HDF5, but in the case of plugins, we
// cannot do assumptions about the registration order.
// Avoid opening kea files if the kea driver is available.
if( EQUAL(osExt, "KEA") && GDALGetDriverByName("KEA") != nullptr )
{
return FALSE;
}
// Avoid opening BAG files if the bag driver is available.
if( EQUAL(osExt, "BAG") && GDALGetDriverByName("BAG") != nullptr )
{
return FALSE;
}
// Avoid opening NC files if the netCDF driver is available and
// they are recognized by it.
if( (EQUAL(osExt, "NC") ||
EQUAL(osExt, "CDF") ||
EQUAL(osExt, "NC4")) &&
GDALGetDriverByName("netCDF") != nullptr )
{
const char *const apszAllowedDriver[] = { "netCDF", nullptr };
CPLPushErrorHandler(CPLQuietErrorHandler);
GDALDatasetH hDS = GDALOpenEx(poOpenInfo->pszFilename,
GDAL_OF_RASTER | GDAL_OF_VECTOR,
apszAllowedDriver, nullptr, nullptr);
CPLPopErrorHandler();
if( hDS )
{
GDALClose(hDS);
return FALSE;
}
}
return TRUE;
}
if( memcmp(poOpenInfo->pabyHeader, "<HDF_UserBlock>", 15) == 0)
{
if( H5Fis_hdf5(poOpenInfo->pszFilename) )
return TRUE;
}
return FALSE;
}
int main( int nArgc, char ** papszArgv )
{
GDALDatasetH hDataset;
const char *pszResampling = "nearest";
const char *pszFilename = NULL;
int anLevels[1024];
int nLevelCount = 0;
int nResultStatus = 0;
int bReadOnly = FALSE;
int bClean = FALSE;
GDALProgressFunc pfnProgress = GDALTermProgress;
int *panBandList = NULL;
int nBandCount = 0;
char **papszOpenOptions = NULL;
/* Check that we are running against at least GDAL 1.7 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1700)
{
fprintf(stderr, "At least, GDAL >= 1.7.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", papszArgv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
nArgc = GDALGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 1 )
exit( -nArgc );
/* -------------------------------------------------------------------- */
/* Parse commandline. */
/* -------------------------------------------------------------------- */
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],"-r") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszResampling = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-ro"))
bReadOnly = TRUE;
else if( EQUAL(papszArgv[iArg],"-clean"))
bClean = TRUE;
else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet") )
pfnProgress = GDALDummyProgress;
else if( EQUAL(papszArgv[iArg],"-b"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
const char* pszBand = papszArgv[iArg+1];
int nBand = atoi(pszBand);
if( nBand < 1 )
{
printf( "Unrecognizable band number (%s).\n", papszArgv[iArg+1] );
Usage();
GDALDestroyDriverManager();
exit( 2 );
}
iArg++;
nBandCount++;
panBandList = (int *)
CPLRealloc(panBandList, sizeof(int) * nBandCount);
panBandList[nBandCount-1] = nBand;
}
else if( EQUAL(papszArgv[iArg], "-oo") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszOpenOptions = CSLAddString( papszOpenOptions,
papszArgv[++iArg] );
}
else if( papszArgv[iArg][0] == '-' )
Usage(CPLSPrintf("Unknown option name '%s'", papszArgv[iArg]));
else if( pszFilename == NULL )
pszFilename = papszArgv[iArg];
else if( atoi(papszArgv[iArg]) > 0 )
{
anLevels[nLevelCount++] = atoi(papszArgv[iArg]);
if( anLevels[nLevelCount-1] == 1 )
{
printf("Warning: Overview with subsampling factor of 1 requested. This will copy the full resolution dataset in the overview !\n");
}
}
else
Usage("Too many command options.");
}
if( pszFilename == NULL )
Usage("No datasource specified.");
if( nLevelCount == 0 && !bClean )
Usage("No overview level specified.");
/* -------------------------------------------------------------------- */
/* Open data file. */
/* -------------------------------------------------------------------- */
if (bReadOnly)
hDataset = NULL;
else
{
CPLPushErrorHandler( CPLQuietErrorHandler );
hDataset = GDALOpenEx( pszFilename, GDAL_OF_RASTER | GDAL_OF_UPDATE, NULL, papszOpenOptions, NULL );
CPLPopErrorHandler();
}
if( hDataset == NULL )
hDataset = GDALOpenEx( pszFilename, GDAL_OF_RASTER, NULL, papszOpenOptions, NULL );
CSLDestroy(papszOpenOptions);
papszOpenOptions = NULL;
if( hDataset == NULL )
exit( 2 );
/* -------------------------------------------------------------------- */
/* Clean overviews. */
/* -------------------------------------------------------------------- */
if ( bClean &&
GDALBuildOverviews( hDataset,pszResampling, 0, 0,
0, NULL, pfnProgress, NULL ) != CE_None )
{
printf( "Cleaning overviews failed.\n" );
nResultStatus = 200;
}
/* -------------------------------------------------------------------- */
/* Generate overviews. */
/* -------------------------------------------------------------------- */
//Only HFA support selected layers
if(nBandCount > 0)
CPLSetConfigOption( "USE_RRD", "YES" );
if (nLevelCount > 0 && nResultStatus == 0 &&
GDALBuildOverviews( hDataset,pszResampling, nLevelCount, anLevels,
nBandCount, panBandList, pfnProgress, NULL ) != CE_None )
{
printf( "Overview building failed.\n" );
nResultStatus = 100;
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
GDALClose(hDataset);
CSLDestroy( papszArgv );
CPLFree(panBandList);
GDALDestroyDriverManager();
return nResultStatus;
}
SEXP ogrP4S(SEXP ogrsourcename, SEXP Layer) {
#ifdef GDALV2
// GDALDriver *poDriver;
GDALDataset *poDS;
#else
OGRSFDriver *poDriver;
OGRDataSource *poDS;
#endif
OGRLayer *poLayer;
OGRSpatialReference *hSRS = NULL;
char *pszProj4 = NULL;
SEXP ans;
installErrorHandler();
#ifdef GDALV2
poDS=(GDALDataset*) GDALOpenEx(CHAR(STRING_ELT(ogrsourcename, 0)), GDAL_OF_VECTOR, NULL, NULL, NULL);
#else
poDS=OGRSFDriverRegistrar::Open(CHAR(STRING_ELT(ogrsourcename, 0)),
FALSE, &poDriver);
#endif
uninstallErrorHandlerAndTriggerError();
if(poDS==NULL){
error("Cannot open file");
}
installErrorHandler();
poLayer = poDS->GetLayerByName(CHAR(STRING_ELT(Layer, 0)));
uninstallErrorHandlerAndTriggerError();
if(poLayer == NULL){
error("Cannot open layer");
}
PROTECT(ans=NEW_CHARACTER(1));
installErrorHandler();
hSRS = poLayer->GetSpatialRef();
uninstallErrorHandlerAndTriggerError();
if (hSRS != NULL) {
installErrorHandler();
hSRS->morphFromESRI();
if (hSRS->exportToProj4(&pszProj4) != OGRERR_NONE) {
// SET_VECTOR_ELT(ans, 0, NA_STRING);
SET_STRING_ELT(ans, 0, NA_STRING);
} else {
// SET_VECTOR_ELT(ans, 0, COPY_TO_USER_STRING(pszProj4));
SET_STRING_ELT(ans, 0, COPY_TO_USER_STRING(pszProj4));
}
uninstallErrorHandlerAndTriggerError();
// } else SET_VECTOR_ELT(ans, 0, NA_STRING);
} else SET_STRING_ELT(ans, 0, NA_STRING);
installErrorHandler();
delete poDS;
uninstallErrorHandlerAndTriggerError();
UNPROTECT(1);
return(ans);
}