virtual ReadResult readFile(const std::string& fileName, const osgDB::ReaderWriter::Options* options) const { if (OGRSFDriverRegistrar::GetRegistrar()->GetDriverCount() == 0) OGRRegisterAll(); // Try to open data source OGRDataSource* file = OGRSFDriverRegistrar::Open(fileName.c_str()); if (!file) return 0; bool useRandomColorByFeature = false; bool addGroupPerFeature = false; if (options) { if (options->getOptionString().find("UseRandomColorByFeature") != std::string::npos) useRandomColorByFeature = true; if (options->getOptionString().find("useRandomColorByFeature") != std::string::npos) useRandomColorByFeature = true; if (options->getOptionString().find("addGroupPerFeature") != std::string::npos) addGroupPerFeature = true; } osg::Group* group = new osg::Group; for (int i = 0; i < file->GetLayerCount(); i++) { osg::Group* node = readLayer(file->GetLayer(i), file->GetName(), useRandomColorByFeature, addGroupPerFeature); if (node) group->addChild( node ); } OGRDataSource::DestroyDataSource( file ); return group; }
//#include "s57.h" int main(int argc, char **argv) { OGRRegisterAll(); OGRDataSource *poDS; printf("Opening %s\n",argv[1]); poDS = OGRSFDriverRegistrar::Open( argv[1], FALSE ); if( poDS == NULL ) { printf( "Open failed.\n" ); exit( 1 ); } OGRLayer *poLayer; int layers = poDS->GetLayerCount(); for (int layer =0 ; layer< layers; layer++) { poLayer = poDS->GetLayer(layer); if (poLayer == NULL) continue; printf("%d, %s, %s",layer, poLayer->GetName(), OGRGeometryTypeToName(poLayer->GetGeomType())); poLayer->ResetReading(); OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn(); int iField; for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ ) { OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( iField ); printf(", %s",poFieldDefn->GetNameRef()); } printf("\n"); } }
int OGRDataSource::GetSummaryRefCount() const { int nSummaryCount = m_nRefCount; int iLayer; OGRDataSource *poUseThis = (OGRDataSource *) this; for( iLayer=0; iLayer < poUseThis->GetLayerCount(); iLayer++ ) nSummaryCount += poUseThis->GetLayer( iLayer )->GetRefCount(); return nSummaryCount; }
int OGRDataSource::GetSummaryRefCount() const { CPLMutexHolderD( (void **) &m_hMutex ); int nSummaryCount = m_nRefCount; int iLayer; OGRDataSource *poUseThis = (OGRDataSource *) this; for( iLayer=0; iLayer < poUseThis->GetLayerCount(); iLayer++ ) nSummaryCount += poUseThis->GetLayer( iLayer )->GetRefCount(); return nSummaryCount; }
JNIEXPORT jlong JNICALL Java_es_gva_cit_jogr_OGRDataSource_getLayerNat (JNIEnv *env, jobject obj, jlong cPtr, jint iLayer){ OGRDataSource *ds = (OGRDataSource *) 0 ; OGRLayer *capa; long layer=-1; ds = *(OGRDataSource **)&cPtr; if(ds!=NULL){ capa = ds->GetLayer(iLayer); if(capa!=NULL)layer = (long)&(*capa); } return (jlong)layer; }
OGRLayer* import_shapefile(string shapefile_name, int layer_number) { OGRRegisterAll(); OGRDataSource *poDS; poDS = OGRSFDriverRegistrar::Open( shapefile_name.c_str(), FALSE ); if( poDS == NULL ) { cerr << "Failed to open shapefile" << endl; exit( 1 ); } OGRLayer* poLayer = poDS->GetLayer(layer_number); cerr << "Shapefile layer name: " << poLayer->GetName() << endl; // char* proj[255]; // poLayer->GetSpatialRef()->exportToWkt(proj); // cerr << "Shapefile projection: " << *proj << endl; return poLayer; }
/** @brief Get list of shapes from file, optional search by name * * read in shape file, extract shapes return as list * optional string argument returns only matching shapes (by string.find) * (!case sensitive!) */ void getAvailShapes(vector<OGRFeature*>* availShapes_p, const string selected = "") { OGRRegisterAll(); OGRDataSource * poDS; string path = "../admin_level_6/shape_al6/admin_level_6.shp"; if (exists(path)) { poDS = OGRSFDriverRegistrar::Open(path.c_str()); if (poDS == NULL) { cout << "Data read error" << endl; exit (1); } } else { cout << "File not found" << endl; exit(1); } // cout << "Found " << poDS->GetLayerCount() << "Layers in File" << endl; OGRLayer *poLayer; OGRFeature *poFeature; poLayer = poDS->GetLayer(0); poLayer->ResetReading(); while ( (poFeature = poLayer->GetNextFeature()) != NULL) { if (selected.empty()) { availShapes_p->push_back(poFeature); } else { if (string(poFeature->GetFieldAsString(1)).find(selected) != string::npos) availShapes_p->push_back(poFeature); else OGRFeature::DestroyFeature(poFeature); } } OGRDataSource::DestroyDataSource(poDS); }
int Raster::VectortoRaster(const char * sVectorSourcePath, const char * sRasterOutputPath, double dCellWidth, const char * psFieldName){ OGRRegisterAll(); OGRDataSource * pDSVectorInput; pDSVectorInput = OGRSFDriverRegistrar::Open( sVectorSourcePath, FALSE ); if (pDSVectorInput == NULL) return INPUT_FILE_ERROR; // Get the extents of the file before passing it off to the function that actually burns // the geometries // ------------------------------------------------------- // Note: we're just grabbing the first layer here. If we get into needing multiple layers // Then we'll need to re-think this. OGRLayer * poLayer = pDSVectorInput->GetLayer(0); if (poLayer == NULL) return VECTOR_LAYER_NOT_FOUND; OGREnvelope psExtent; poLayer->GetExtent(&psExtent, TRUE); double dMaxY, dMaxX, dMinY, dMinX; double cellWidth = fabs(dCellWidth); dMaxY = ceil(psExtent.MaxY / cellWidth) * cellWidth; dMaxX = ceil(psExtent.MaxX / cellWidth) * cellWidth; dMinY = floor(psExtent.MinY / cellWidth) * cellWidth; dMinX = floor(psExtent.MinX / cellWidth) * cellWidth; int nRows = (int)((dMaxY - dMinY) / cellWidth); int nCols = (int)((dMaxX - dMinX) / cellWidth); \ // We're going to create them without projections. The projections get set later. double fNoDataValue = (double) -std::numeric_limits<float>::max(); GDALDataType nDType = GDT_Float32; double dCellHeight = -dCellWidth; RasterMeta TemplateRaster(psExtent.MaxY, psExtent.MinX, nRows, nCols, &dCellHeight, &dCellWidth, &fNoDataValue, "GTiff", &nDType, ""); pDSVectorInput->Release(); return VectortoRaster(sVectorSourcePath, sRasterOutputPath, psFieldName, &TemplateRaster); }
MapExtruder::MapExtruder(const char* map2dFile,double height) { _map2dFile = map2dFile; _height = height; OGRRegisterAll(); OGRDataSource *poDS = OGRSFDriverRegistrar::Open(_map2dFile,FALSE); if( poDS == NULL) { printf("Open failed.\n"); exit(1); } _map2d = new OGRMultiPolygon(); OGRLayer *poLayer; poLayer = poDS->GetLayer(0); OGRFeature *poFeature; poLayer->ResetReading(); while((poFeature = poLayer->GetNextFeature())!=NULL) { OGRGeometry *poGeometry; poGeometry = poFeature ->GetGeometryRef(); if(poGeometry!=NULL) { if(poGeometry ->getGeometryType()==wkbPolygon) _map2d->addGeometry((OGRPolygon*) poGeometry); if(poGeometry ->getGeometryType()==wkbMultiPolygon) { int nPolygons = ((OGRMultiPolygon*)poGeometry)->getNumGeometries(); for(int i=0;i<nPolygons;i++) _map2d->addGeometry((OGRPolygon*)(((OGRMultiPolygon*)poGeometry)->getGeometryRef(i))); } } } extrusion(); }
static void OGR2SQLITE_ogr_datasource_load_layers(sqlite3_context* pContext, int argc, sqlite3_value** argv) { sqlite3* hDB = (sqlite3*) sqlite3_user_data(pContext); if( (argc < 1 || argc > 3) || sqlite3_value_type (argv[0]) != SQLITE_TEXT ) { sqlite3_result_int (pContext, 0); return; } const char* pszDataSource = (const char*) sqlite3_value_text(argv[0]); int bUpdate = FALSE; if( argc >= 2 ) { if( sqlite3_value_type(argv[1]) != SQLITE_INTEGER ) { sqlite3_result_int (pContext, 0); return; } bUpdate = sqlite3_value_int(argv[1]); } const char* pszPrefix = NULL; if( argc >= 3 ) { if( sqlite3_value_type(argv[2]) != SQLITE_TEXT ) { sqlite3_result_int (pContext, 0); return; } pszPrefix = (const char*) sqlite3_value_text(argv[2]); } OGRDataSource* poDS = (OGRDataSource*)OGROpenShared(pszDataSource, bUpdate, NULL); if( poDS == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot open %s", pszDataSource); sqlite3_result_int (pContext, 0); return; } CPLString osEscapedDataSource = OGRSQLiteEscape(pszDataSource); for(int i=0; i<poDS->GetLayerCount(); i++) { const char* pszLayerName = poDS->GetLayer(i)->GetName(); CPLString osEscapedLayerName = OGRSQLiteEscape(pszLayerName); CPLString osTableName; if( pszPrefix != NULL ) { osTableName = pszPrefix; osTableName += "_"; osTableName += OGRSQLiteEscapeName(pszLayerName); } else { osTableName = OGRSQLiteEscapeName(pszLayerName); } char* pszErrMsg = NULL; if( sqlite3_exec(hDB, CPLSPrintf( "CREATE VIRTUAL TABLE \"%s\" USING VirtualOGR('%s', %d, '%s')", osTableName.c_str(), osEscapedDataSource.c_str(), bUpdate, osEscapedLayerName.c_str()), NULL, NULL, &pszErrMsg) != SQLITE_OK ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot create table \"%s\" : %s", osTableName.c_str(), pszErrMsg); sqlite3_free(pszErrMsg); } } poDS->Release(); sqlite3_result_int (pContext, 1); }
int main( int argc, char ** argv ) { int i; int bGotSRS = FALSE; int bPretty = FALSE; int bOutputAll = FALSE; int bValidate = FALSE; const char *pszInput = NULL; const char *pszOutputType = "all"; char *pszOutput = NULL; OGRSpatialReference oSRS; VSILFILE *fp = NULL; GDALDataset *poGDALDS = NULL; OGRDataSource *poOGRDS = NULL; OGRLayer *poLayer = NULL; char *pszProjection = NULL; int bDebug = FALSE; CPLErrorHandler oErrorHandler = NULL; int bIsFile = FALSE; /* Check strict compilation and runtime library version as we use C++ API */ if (! GDAL_CHECK_VERSION(argv[0])) exit(1); /* Must process GDAL_SKIP before GDALAllRegister(), but we can't call */ /* GDALGeneralCmdLineProcessor before it needs the drivers to be registered */ /* for the --format or --formats options */ for( i = 1; i < argc; i++ ) { if( EQUAL(argv[i],"--config") && i + 2 < argc && EQUAL(argv[i + 1], "GDAL_SKIP") ) { CPLSetConfigOption( argv[i+1], argv[i+2] ); i += 2; } } argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 ); if( argc < 1 ) exit( -argc ); /* -------------------------------------------------------------------- */ /* Parse arguments. */ /* -------------------------------------------------------------------- */ for( i = 1; i < argc; i++ ) { CPLDebug( "gdalsrsinfo", "got arg #%d : [%s]", i, argv[i] ); if( EQUAL(argv[i], "--utility_version") ) { printf("%s was compiled against GDAL %s and is running against GDAL %s\n", argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME")); return 0; } else if( EQUAL(argv[i], "-h") ) Usage(); else if( EQUAL(argv[i], "-o") && i < argc - 1) pszOutputType = argv[++i]; else if( EQUAL(argv[i], "-p") ) bPretty = TRUE; else if( EQUAL(argv[i], "-V") ) bValidate = TRUE; else if( argv[i][0] == '-' ) { CSLDestroy( argv ); Usage(); } else pszInput = argv[i]; } if ( pszInput == NULL ) { CSLDestroy( argv ); Usage(); } /* Register drivers */ GDALAllRegister(); OGRRegisterAll(); /* Search for SRS */ /* temporarily supress error messages we may get from xOpen() */ bDebug = CSLTestBoolean(CPLGetConfigOption("CPL_DEBUG", "OFF")); if ( ! bDebug ) oErrorHandler = CPLSetErrorHandler ( CPLQuietErrorHandler ); /* If argument is a file, try to open it with GDALOpen() and get the projection */ fp = VSIFOpenL( pszInput, "r" ); if ( fp ) { bIsFile = TRUE; VSIFCloseL( fp ); /* try to open with GDAL */ CPLDebug( "gdalsrsinfo", "trying to open with GDAL" ); poGDALDS = (GDALDataset *) GDALOpen( pszInput, GA_ReadOnly ); if ( poGDALDS != NULL && poGDALDS->GetProjectionRef( ) != NULL ) { pszProjection = (char *) poGDALDS->GetProjectionRef( ); if( oSRS.importFromWkt( &pszProjection ) == CE_None ) { CPLDebug( "gdalsrsinfo", "got SRS from GDAL" ); bGotSRS = TRUE; } GDALClose( (GDALDatasetH) poGDALDS ); } if ( ! bGotSRS ) CPLDebug( "gdalsrsinfo", "did not open with GDAL" ); /* if unsuccessful, try to open with OGR */ if ( ! bGotSRS ) { CPLDebug( "gdalsrsinfo", "trying to open with OGR" ); poOGRDS = OGRSFDriverRegistrar::Open( pszInput, FALSE, NULL ); if( poOGRDS != NULL ) { poLayer = poOGRDS->GetLayer( 0 ); if ( poLayer != NULL ) { OGRSpatialReference *poSRS = poLayer->GetSpatialRef( ); if ( poSRS != NULL ) { CPLDebug( "gdalsrsinfo", "got SRS from OGR" ); bGotSRS = TRUE; OGRSpatialReference* poSRSClone = poSRS->Clone(); oSRS = *poSRSClone; OGRSpatialReference::DestroySpatialReference( poSRSClone ); } } OGRDataSource::DestroyDataSource( poOGRDS ); poOGRDS = NULL; } if ( ! bGotSRS ) CPLDebug( "gdalsrsinfo", "did not open with OGR" ); /* OGR_DS_Destroy( hOGRDS ); */ } } /* If didn't get the projection from the file, try OSRSetFromUserInput() */ /* File might not be a dataset, but contain projection info (e.g. .prf files) */ if ( ! bGotSRS ) { CPLDebug( "gdalsrsinfo", "trying to get SRS from user input [%s]", pszInput ); if( oSRS.SetFromUserInput( pszInput ) != OGRERR_NONE ) { CPLDebug( "gdalsrsinfo", "did not get SRS from user input" ); } else { CPLDebug( "gdalsrsinfo", "got SRS from user input" ); bGotSRS = TRUE; } } /* restore error messages */ if ( ! bDebug ) CPLSetErrorHandler ( oErrorHandler ); CPLDebug( "gdalsrsinfo", "bGotSRS: %d bValidate: %d pszOutputType: %s bPretty: %d", bGotSRS, bValidate, pszOutputType, bPretty ); /* Make sure we got a SRS */ if ( ! bGotSRS ) { CPLError( CE_Failure, CPLE_AppDefined, "ERROR - failed to load SRS definition from %s", pszInput ); } else { /* Validate - not well tested!*/ if ( bValidate ) { OGRErr eErr = oSRS.Validate( ); if ( eErr != OGRERR_NONE ) { printf( "\nValidate Fails" ); if ( eErr == OGRERR_CORRUPT_DATA ) printf( " - SRS is not well formed"); else if ( eErr == OGRERR_UNSUPPORTED_SRS ) printf(" - contains non-standard PROJECTION[] values"); printf("\n"); } else printf( "\nValidate Succeeds\n" ); } /* Output */ if ( EQUAL("all", pszOutputType ) ) { bOutputAll = TRUE; bPretty = TRUE; } printf("\n"); if ( bOutputAll || EQUAL("proj4", pszOutputType ) ) { if ( bOutputAll ) printf("PROJ.4 : "); oSRS.exportToProj4( &pszOutput ); printf("\'%s\'\n\n",pszOutput); CPLFree( pszOutput ); } if ( bOutputAll || EQUAL("wkt", pszOutputType ) ) { if ( bOutputAll ) printf("OGC WKT :\n"); if ( bPretty ) oSRS.exportToPrettyWkt( &pszOutput, FALSE ); else oSRS.exportToWkt( &pszOutput ); printf("%s\n\n",pszOutput); CPLFree( pszOutput ); } if ( bOutputAll || EQUAL("wkt_simple", pszOutputType ) ) { if ( bOutputAll ) printf("OGC WKT (simple) :\n"); oSRS.exportToPrettyWkt( &pszOutput, TRUE ); printf("%s\n\n",pszOutput); CPLFree( pszOutput ); } if ( EQUAL("wkt_old", pszOutputType ) ) { if ( bOutputAll ) printf("OGC WKT (old) :\n"); oSRS.StripCTParms( ); if ( bPretty ) oSRS.exportToPrettyWkt( &pszOutput, FALSE ); else oSRS.exportToWkt( &pszOutput ); printf("%s\n\n",pszOutput); CPLFree( pszOutput ); } if ( bOutputAll || EQUAL("wkt_esri", pszOutputType ) ) { if ( bOutputAll ) printf("ESRI WKT :\n"); OGRSpatialReference *poSRS = oSRS.Clone(); poSRS->morphToESRI( ); if ( bPretty ) poSRS->exportToPrettyWkt( &pszOutput, FALSE ); else poSRS->exportToWkt( &pszOutput ); printf("%s\n\n",pszOutput); CPLFree( pszOutput ); OGRSpatialReference::DestroySpatialReference( poSRS ); } /* mapinfo and xml are not output with "all" */ if ( EQUAL("mapinfo", pszOutputType ) ) { if ( bOutputAll ) printf("MAPINFO : "); oSRS.exportToMICoordSys( &pszOutput ); printf("\'%s\'\n\n",pszOutput); CPLFree( pszOutput ); } if ( EQUAL("xml", pszOutputType ) ) { if ( bOutputAll ) printf("XML :\n"); oSRS.exportToXML( &pszOutput, NULL ); printf("%s\n\n",pszOutput); CPLFree( pszOutput ); } } /* cleanup anything left */ GDALDestroyDriverManager(); OGRCleanupAll(); CSLDestroy( argv ); return 0; }
int NBHeightMapper::loadShapeFile(const std::string& file) { #ifdef HAVE_GDAL #if GDAL_VERSION_MAJOR < 2 OGRRegisterAll(); OGRDataSource* ds = OGRSFDriverRegistrar::Open(file.c_str(), FALSE); #else GDALAllRegister(); GDALDataset* ds = (GDALDataset*)GDALOpenEx(file.c_str(), GDAL_OF_VECTOR | GA_ReadOnly, NULL, NULL, NULL); #endif if (ds == NULL) { throw ProcessError("Could not open shape file '" + file + "'."); } // begin file parsing OGRLayer* layer = ds->GetLayer(0); layer->ResetReading(); // triangle coordinates are stored in WGS84 and later matched with network coordinates in WGS84 // build coordinate transformation OGRSpatialReference* sr_src = layer->GetSpatialRef(); OGRSpatialReference sr_dest; sr_dest.SetWellKnownGeogCS("WGS84"); OGRCoordinateTransformation* toWGS84 = OGRCreateCoordinateTransformation(sr_src, &sr_dest); if (toWGS84 == 0) { WRITE_WARNING("Could not create geocoordinates converter; check whether proj.4 is installed."); } int numFeatures = 0; OGRFeature* feature; layer->ResetReading(); while ((feature = layer->GetNextFeature()) != NULL) { OGRGeometry* geom = feature->GetGeometryRef(); assert(geom != 0); // @todo gracefull handling of shapefiles with unexpected contents or any error handling for that matter assert(std::string(geom->getGeometryName()) == std::string("POLYGON")); // try transform to wgs84 geom->transform(toWGS84); OGRLinearRing* cgeom = ((OGRPolygon*) geom)->getExteriorRing(); // assume TIN with with 4 points and point0 == point3 assert(cgeom->getNumPoints() == 4); PositionVector corners; for (int j = 0; j < 3; j++) { Position pos((double) cgeom->getX(j), (double) cgeom->getY(j), (double) cgeom->getZ(j)); corners.push_back(pos); myBoundary.add(pos); } addTriangle(corners); numFeatures++; /* OGRwkbGeometryType gtype = geom->getGeometryType(); switch (gtype) { case wkbPolygon: { break; } case wkbPoint: { WRITE_WARNING("got wkbPoint"); break; } case wkbLineString: { WRITE_WARNING("got wkbLineString"); break; } case wkbMultiPoint: { WRITE_WARNING("got wkbMultiPoint"); break; } case wkbMultiLineString: { WRITE_WARNING("got wkbMultiLineString"); break; } case wkbMultiPolygon: { WRITE_WARNING("got wkbMultiPolygon"); break; } default: WRITE_WARNING("Unsupported shape type occurred"); break; } */ OGRFeature::DestroyFeature(feature); } #if GDAL_VERSION_MAJOR < 2 OGRDataSource::DestroyDataSource(ds); #else GDALClose(ds); #endif OCTDestroyCoordinateTransformation(toWGS84); OGRCleanupAll(); return numFeatures; #else UNUSED_PARAMETER(file); WRITE_ERROR("Cannot load shape file since SUMO was compiled without GDAL support."); return 0; #endif }
int main( int nArgc, char ** papszArgv ) { const char *pszWHERE = NULL; const char *pszDataSource = NULL; char **papszLayers = NULL; OGRGeometry *poSpatialFilter = NULL; int nRepeatCount = 1, bAllLayers = FALSE; const char *pszSQLStatement = NULL; const char *pszDialect = NULL; /* Check strict compilation and runtime library version as we use C++ API */ if (! GDAL_CHECK_VERSION(papszArgv[0])) exit(1); /* -------------------------------------------------------------------- */ /* Register format(s). */ /* -------------------------------------------------------------------- */ OGRRegisterAll(); /* -------------------------------------------------------------------- */ /* Processing command line arguments. */ /* -------------------------------------------------------------------- */ nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 ); if( nArgc < 1 ) exit( -nArgc ); for( int iArg = 1; iArg < nArgc; iArg++ ) { if( EQUAL(papszArgv[iArg], "--utility_version") ) { printf("%s was compiled against GDAL %s and is running against GDAL %s\n", papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME")); return 0; } else if( EQUAL(papszArgv[iArg],"-ro") ) bReadOnly = TRUE; else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet")) bVerbose = FALSE; else if( EQUAL(papszArgv[iArg],"-fid") && iArg < nArgc-1 ) nFetchFID = atoi(papszArgv[++iArg]); else if( EQUAL(papszArgv[iArg],"-spat") && papszArgv[iArg+1] != NULL && papszArgv[iArg+2] != NULL && papszArgv[iArg+3] != NULL && papszArgv[iArg+4] != NULL ) { OGRLinearRing oRing; oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) ); oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+4]) ); oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+4]) ); oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+2]) ); oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) ); poSpatialFilter = new OGRPolygon(); ((OGRPolygon *) poSpatialFilter)->addRing( &oRing ); iArg += 4; } else if( EQUAL(papszArgv[iArg],"-where") && papszArgv[iArg+1] != NULL ) { pszWHERE = papszArgv[++iArg]; } else if( EQUAL(papszArgv[iArg],"-sql") && papszArgv[iArg+1] != NULL ) { pszSQLStatement = papszArgv[++iArg]; } else if( EQUAL(papszArgv[iArg],"-dialect") && papszArgv[iArg+1] != NULL ) { pszDialect = papszArgv[++iArg]; } else if( EQUAL(papszArgv[iArg],"-rc") && papszArgv[iArg+1] != NULL ) { nRepeatCount = atoi(papszArgv[++iArg]); } else if( EQUAL(papszArgv[iArg],"-al") ) { bAllLayers = TRUE; } else if( EQUAL(papszArgv[iArg],"-so") || EQUAL(papszArgv[iArg],"-summary") ) { bSummaryOnly = TRUE; } else if( EQUALN(papszArgv[iArg],"-fields=", strlen("-fields=")) ) { char* pszTemp = (char*)CPLMalloc(32 + strlen(papszArgv[iArg])); sprintf(pszTemp, "DISPLAY_FIELDS=%s", papszArgv[iArg] + strlen("-fields=")); papszOptions = CSLAddString(papszOptions, pszTemp); CPLFree(pszTemp); } else if( EQUALN(papszArgv[iArg],"-geom=", strlen("-geom=")) ) { char* pszTemp = (char*)CPLMalloc(32 + strlen(papszArgv[iArg])); sprintf(pszTemp, "DISPLAY_GEOMETRY=%s", papszArgv[iArg] + strlen("-geom=")); papszOptions = CSLAddString(papszOptions, pszTemp); CPLFree(pszTemp); } else if( papszArgv[iArg][0] == '-' ) { Usage(); } else if( pszDataSource == NULL ) pszDataSource = papszArgv[iArg]; else { papszLayers = CSLAddString( papszLayers, papszArgv[iArg] ); bAllLayers = FALSE; } } if( pszDataSource == NULL ) Usage(); /* -------------------------------------------------------------------- */ /* Open data source. */ /* -------------------------------------------------------------------- */ OGRDataSource *poDS = NULL; OGRSFDriver *poDriver = NULL; poDS = OGRSFDriverRegistrar::Open( pszDataSource, !bReadOnly, &poDriver ); if( poDS == NULL && !bReadOnly ) { poDS = OGRSFDriverRegistrar::Open( pszDataSource, FALSE, &poDriver ); if( poDS != NULL && bVerbose ) { printf( "Had to open data source read-only.\n" ); bReadOnly = TRUE; } } /* -------------------------------------------------------------------- */ /* Report failure */ /* -------------------------------------------------------------------- */ if( poDS == NULL ) { OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar(); printf( "FAILURE:\n" "Unable to open datasource `%s' with the following drivers.\n", pszDataSource ); for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ ) { printf( " -> %s\n", poR->GetDriver(iDriver)->GetName() ); } exit( 1 ); } CPLAssert( poDriver != NULL); /* -------------------------------------------------------------------- */ /* Some information messages. */ /* -------------------------------------------------------------------- */ if( bVerbose ) printf( "INFO: Open of `%s'\n" " using driver `%s' successful.\n", pszDataSource, poDriver->GetName() ); if( bVerbose && !EQUAL(pszDataSource,poDS->GetName()) ) { printf( "INFO: Internal data source name `%s'\n" " different from user name `%s'.\n", poDS->GetName(), pszDataSource ); } /* -------------------------------------------------------------------- */ /* Special case for -sql clause. No source layers required. */ /* -------------------------------------------------------------------- */ if( pszSQLStatement != NULL ) { OGRLayer *poResultSet = NULL; nRepeatCount = 0; // skip layer reporting. if( CSLCount(papszLayers) > 0 ) printf( "layer names ignored in combination with -sql.\n" ); poResultSet = poDS->ExecuteSQL( pszSQLStatement, poSpatialFilter, pszDialect ); if( poResultSet != NULL ) { if( pszWHERE != NULL ) poResultSet->SetAttributeFilter( pszWHERE ); ReportOnLayer( poResultSet, NULL, NULL ); poDS->ReleaseResultSet( poResultSet ); } } CPLDebug( "OGR", "GetLayerCount() = %d\n", poDS->GetLayerCount() ); for( int iRepeat = 0; iRepeat < nRepeatCount; iRepeat++ ) { if ( CSLCount(papszLayers) == 0 ) { /* -------------------------------------------------------------------- */ /* Process each data source layer. */ /* -------------------------------------------------------------------- */ for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ ) { OGRLayer *poLayer = poDS->GetLayer(iLayer); if( poLayer == NULL ) { printf( "FAILURE: Couldn't fetch advertised layer %d!\n", iLayer ); exit( 1 ); } if (!bAllLayers) { printf( "%d: %s", iLayer+1, poLayer->GetLayerDefn()->GetName() ); if( poLayer->GetLayerDefn()->GetGeomType() != wkbUnknown ) printf( " (%s)", OGRGeometryTypeToName( poLayer->GetLayerDefn()->GetGeomType() ) ); printf( "\n" ); } else { if( iRepeat != 0 ) poLayer->ResetReading(); ReportOnLayer( poLayer, pszWHERE, poSpatialFilter ); } } } else { /* -------------------------------------------------------------------- */ /* Process specified data source layers. */ /* -------------------------------------------------------------------- */ char** papszIter = papszLayers; for( ; *papszIter != NULL; papszIter++ ) { OGRLayer *poLayer = poDS->GetLayerByName(*papszIter); if( poLayer == NULL ) { printf( "FAILURE: Couldn't fetch requested layer %s!\n", *papszIter ); exit( 1 ); } if( iRepeat != 0 ) poLayer->ResetReading(); ReportOnLayer( poLayer, pszWHERE, poSpatialFilter ); } } } /* -------------------------------------------------------------------- */ /* Close down. */ /* -------------------------------------------------------------------- */ CSLDestroy( papszArgv ); CSLDestroy( papszLayers ); CSLDestroy( papszOptions ); OGRDataSource::DestroyDataSource( poDS ); if (poSpatialFilter) OGRGeometryFactory::destroyGeometry( poSpatialFilter ); OGRCleanupAll(); return 0; }
static OGRGeometryCollection* LoadGeometry( const char* pszDS, const char* pszSQL, const char* pszLyr, const char* pszWhere ) { OGRDataSource *poDS; OGRLayer *poLyr; OGRFeature *poFeat; OGRGeometryCollection *poGeom = NULL; poDS = OGRSFDriverRegistrar::Open( pszDS, FALSE ); if ( poDS == NULL ) return NULL; if ( pszSQL != NULL ) poLyr = poDS->ExecuteSQL( pszSQL, NULL, NULL ); else if ( pszLyr != NULL ) poLyr = poDS->GetLayerByName( pszLyr ); else poLyr = poDS->GetLayer(0); if ( poLyr == NULL ) { fprintf( stderr, "FAILURE: Failed to identify source layer from datasource.\n" ); OGRDataSource::DestroyDataSource( poDS ); return NULL; } if ( pszWhere ) poLyr->SetAttributeFilter( pszWhere ); while ( (poFeat = poLyr->GetNextFeature()) != NULL ) { OGRGeometry* poSrcGeom = poFeat->GetGeometryRef(); if ( poSrcGeom ) { OGRwkbGeometryType eType = wkbFlatten( poSrcGeom->getGeometryType() ); if ( poGeom == NULL ) poGeom = new OGRMultiPolygon(); if ( eType == wkbPolygon ) poGeom->addGeometry( poSrcGeom ); else if ( eType == wkbMultiPolygon ) { int iGeom; int nGeomCount = ((OGRMultiPolygon *)poSrcGeom)->getNumGeometries(); for ( iGeom = 0; iGeom < nGeomCount; iGeom++ ) { poGeom->addGeometry( ((OGRMultiPolygon *)poSrcGeom)->getGeometryRef(iGeom) ); } } else { fprintf( stderr, "FAILURE: Geometry not of polygon type.\n" ); OGRGeometryFactory::destroyGeometry( poGeom ); OGRFeature::DestroyFeature( poFeat ); if ( pszSQL != NULL ) poDS->ReleaseResultSet( poLyr ); OGRDataSource::DestroyDataSource( poDS ); return NULL; } } OGRFeature::DestroyFeature( poFeat ); } if( pszSQL != NULL ) poDS->ReleaseResultSet( poLyr ); OGRDataSource::DestroyDataSource( poDS ); return poGeom; }
void PCLoaderArcView::load(const std::string& file, OptionsCont& oc, PCPolyContainer& toFill, PCTypeMap&) { #ifdef HAVE_GDAL GeoConvHelper& geoConvHelper = GeoConvHelper::getProcessing(); // get defaults std::string prefix = oc.getString("prefix"); std::string type = oc.getString("type"); RGBColor color = RGBColor::parseColor(oc.getString("color")); int layer = oc.getInt("layer"); std::string idField = oc.getString("shapefile.id-column"); bool useRunningID = oc.getBool("shapefile.use-running-id"); // start parsing std::string shpName = file + ".shp"; OGRRegisterAll(); OGRDataSource* poDS = OGRSFDriverRegistrar::Open(shpName.c_str(), FALSE); if (poDS == NULL) { throw ProcessError("Could not open shape description '" + shpName + "'."); } // 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 (oc.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(); unsigned int runningID = 0; while ((poFeature = poLayer->GetNextFeature()) != NULL) { // read in edge attributes std::string id = useRunningID ? toString(runningID) : poFeature->GetFieldAsString(idField.c_str()); ++runningID; id = StringUtils::prune(id); if (id == "") { throw ProcessError("Missing id under '" + idField + "'"); } id = prefix + id; // read in the geometry OGRGeometry* poGeometry = poFeature->GetGeometryRef(); if (poGeometry == 0) { OGRFeature::DestroyFeature(poFeature); continue; } // try transform to wgs84 poGeometry->transform(poCT); OGRwkbGeometryType gtype = poGeometry->getGeometryType(); switch (gtype) { case wkbPoint: { OGRPoint* cgeom = (OGRPoint*) poGeometry; Position pos((SUMOReal) cgeom->getX(), (SUMOReal) cgeom->getY()); if (!geoConvHelper.x2cartesian(pos)) { WRITE_ERROR("Unable to project coordinates for POI '" + id + "'."); } PointOfInterest* poi = new PointOfInterest(id, type, color, pos, (SUMOReal)layer); if (!toFill.insert(id, poi, layer)) { WRITE_ERROR("POI '" + id + "' could not be added."); delete poi; } } break; case wkbLineString: { OGRLineString* cgeom = (OGRLineString*) poGeometry; PositionVector shape; for (int j = 0; j < cgeom->getNumPoints(); j++) { Position pos((SUMOReal) cgeom->getX(j), (SUMOReal) cgeom->getY(j)); if (!geoConvHelper.x2cartesian(pos)) { WRITE_ERROR("Unable to project coordinates for polygon '" + id + "'."); } shape.push_back_noDoublePos(pos); } Polygon* poly = new Polygon(id, type, color, shape, false, (SUMOReal)layer); if (!toFill.insert(id, poly, layer)) { WRITE_ERROR("Polygon '" + id + "' could not be added."); delete poly; } } break; case wkbPolygon: { OGRLinearRing* cgeom = ((OGRPolygon*) poGeometry)->getExteriorRing(); PositionVector shape; for (int j = 0; j < cgeom->getNumPoints(); j++) { Position pos((SUMOReal) cgeom->getX(j), (SUMOReal) cgeom->getY(j)); if (!geoConvHelper.x2cartesian(pos)) { WRITE_ERROR("Unable to project coordinates for polygon '" + id + "'."); } shape.push_back_noDoublePos(pos); } Polygon* poly = new Polygon(id, type, color, shape, true, (SUMOReal)layer); if (!toFill.insert(id, poly, layer)) { WRITE_ERROR("Polygon '" + id + "' could not be added."); delete poly; } } break; case wkbMultiPoint: { OGRMultiPoint* cgeom = (OGRMultiPoint*) poGeometry; for (int i = 0; i < cgeom->getNumGeometries(); ++i) { OGRPoint* cgeom2 = (OGRPoint*) cgeom->getGeometryRef(i); Position pos((SUMOReal) cgeom2->getX(), (SUMOReal) cgeom2->getY()); std::string tid = id + "#" + toString(i); if (!geoConvHelper.x2cartesian(pos)) { WRITE_ERROR("Unable to project coordinates for POI '" + tid + "'."); } PointOfInterest* poi = new PointOfInterest(tid, type, color, pos, (SUMOReal)layer); if (!toFill.insert(tid, poi, layer)) { WRITE_ERROR("POI '" + tid + "' could not be added."); delete poi; } } } break; case wkbMultiLineString: { OGRMultiLineString* cgeom = (OGRMultiLineString*) poGeometry; for (int i = 0; i < cgeom->getNumGeometries(); ++i) { OGRLineString* cgeom2 = (OGRLineString*) cgeom->getGeometryRef(i); PositionVector shape; std::string tid = id + "#" + toString(i); for (int j = 0; j < cgeom2->getNumPoints(); j++) { Position pos((SUMOReal) cgeom2->getX(j), (SUMOReal) cgeom2->getY(j)); if (!geoConvHelper.x2cartesian(pos)) { WRITE_ERROR("Unable to project coordinates for polygon '" + tid + "'."); } shape.push_back_noDoublePos(pos); } Polygon* poly = new Polygon(tid, type, color, shape, false, (SUMOReal)layer); if (!toFill.insert(tid, poly, layer)) { WRITE_ERROR("Polygon '" + tid + "' could not be added."); delete poly; } } } break; case wkbMultiPolygon: { OGRMultiPolygon* cgeom = (OGRMultiPolygon*) poGeometry; for (int i = 0; i < cgeom->getNumGeometries(); ++i) { OGRLinearRing* cgeom2 = ((OGRPolygon*) cgeom->getGeometryRef(i))->getExteriorRing(); PositionVector shape; std::string tid = id + "#" + toString(i); for (int j = 0; j < cgeom2->getNumPoints(); j++) { Position pos((SUMOReal) cgeom2->getX(j), (SUMOReal) cgeom2->getY(j)); if (!geoConvHelper.x2cartesian(pos)) { WRITE_ERROR("Unable to project coordinates for polygon '" + tid + "'."); } shape.push_back_noDoublePos(pos); } Polygon* poly = new Polygon(tid, type, color, shape, true, (SUMOReal)layer); if (!toFill.insert(tid, poly, layer)) { WRITE_ERROR("Polygon '" + tid + "' could not be added."); delete poly; } } } break; default: WRITE_WARNING("Unsupported shape type occured (id='" + id + "')."); break; } OGRFeature::DestroyFeature(poFeature); } PROGRESS_DONE_MESSAGE(); #else WRITE_ERROR("SUMO was compiled without GDAL support."); #endif }
OGRLayer *OGRDataSourceWithTransaction::GetLayer(int iIndex) { if( !m_poBaseDataSource ) return NULL; return WrapLayer(m_poBaseDataSource->GetLayer(iIndex)); }
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 nArgc, char ** papszArgv ) { const char *pszWHERE = NULL; const char *pszDataSource = NULL; char **papszLayers = NULL; OGRGeometry *poSpatialFilter = NULL; /* -------------------------------------------------------------------- */ /* Register format(s). */ /* -------------------------------------------------------------------- */ RegisterOGRTAB(); /* -------------------------------------------------------------------- */ /* Processing command line arguments. */ /* -------------------------------------------------------------------- */ for( int iArg = 1; iArg < nArgc; iArg++ ) { if( EQUAL(papszArgv[iArg],"-ro") ) bReadOnly = TRUE; else if( EQUAL(papszArgv[iArg],"-q") ) bVerbose = FALSE; else if( EQUAL(papszArgv[iArg],"-spat") && papszArgv[iArg+1] != NULL && papszArgv[iArg+2] != NULL && papszArgv[iArg+3] != NULL && papszArgv[iArg+4] != NULL ) { OGRLinearRing oRing; oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) ); oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+4]) ); oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+4]) ); oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+2]) ); oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) ); poSpatialFilter = new OGRPolygon(); ((OGRPolygon *) poSpatialFilter)->addRing( &oRing ); iArg += 4; } else if( EQUAL(papszArgv[iArg],"-where") && papszArgv[iArg+1] != NULL ) { pszWHERE = papszArgv[++iArg]; } else if( papszArgv[iArg][0] == '-' ) { Usage(); } else if( pszDataSource == NULL ) pszDataSource = papszArgv[iArg]; else papszLayers = CSLAddString( papszLayers, papszArgv[iArg] ); } if( pszDataSource == NULL ) Usage(); /* -------------------------------------------------------------------- */ /* Open data source. */ /* -------------------------------------------------------------------- */ OGRDataSource *poDS; OGRSFDriver *poDriver; poDS = OGRSFDriverRegistrar::Open( pszDataSource, !bReadOnly, &poDriver ); if( poDS == NULL && !bReadOnly ) { poDS = OGRSFDriverRegistrar::Open( pszDataSource, FALSE, &poDriver ); if( poDS != NULL && bVerbose ) { printf( "Had to open data source read-only.\n" ); bReadOnly = TRUE; } } /* -------------------------------------------------------------------- */ /* Report failure */ /* -------------------------------------------------------------------- */ if( poDS == NULL ) { OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar(); printf( "FAILURE:\n" "Unable to open datasource `%s' with the following drivers.\n", pszDataSource ); for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ ) { printf( " -> %s\n", poR->GetDriver(iDriver)->GetName() ); } exit( 1 ); } /* -------------------------------------------------------------------- */ /* Some information messages. */ /* -------------------------------------------------------------------- */ if( bVerbose ) printf( "INFO: Open of `%s'\n" "using driver `%s' successful.\n", pszDataSource, poDriver->GetName() ); if( bVerbose && !EQUAL(pszDataSource,poDS->GetName()) ) { printf( "INFO: Internal data source name `%s'\n" " different from user name `%s'.\n", poDS->GetName(), pszDataSource ); } /* -------------------------------------------------------------------- */ /* Process each data source layer. */ /* -------------------------------------------------------------------- */ for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ ) { OGRLayer *poLayer = poDS->GetLayer(iLayer); if( poLayer == NULL ) { printf( "FAILURE: Couldn't fetch advertised layer %d!\n", iLayer ); exit( 1 ); } if( CSLCount(papszLayers) == 0 ) { printf( "%d: %s", iLayer+1, poLayer->GetLayerDefn()->GetName() ); if( poLayer->GetLayerDefn()->GetGeomType() != wkbUnknown ) printf( " (%s)", OGRGeometryTypeToName( poLayer->GetLayerDefn()->GetGeomType() ) ); printf( "\n" ); } else if( CSLFindString( papszLayers, poLayer->GetLayerDefn()->GetName() ) != -1 ) { ReportOnLayer( poLayer, pszWHERE, poSpatialFilter ); } } /* -------------------------------------------------------------------- */ /* Close down. */ /* -------------------------------------------------------------------- */ delete poDS; #ifdef DBMALLOC malloc_dump(1); #endif return 0; }
//coordinate;//(double x, double y); //contains the baseline/collection of baselines for the shoreline void ShoreLine::getShapePoints(string filename){ RegisterOGRShape(); // OGR Drivers for reading shapefiles only OGRDataSource *poDS; cout<<"Reading in file shapefile"<<filename<<endl; poDS = OGRSFDriverRegistrar::Open( filename.c_str(), FALSE ); if ( poDS == NULL ){ printf("Open fail"); exit(1); } OGRLayer *poLayer; poLayer = poDS->GetLayer(0); OGRGeometry *poGeometry; //poGeometry = poLayer-> OGRFeature *poFeature; poFeature= poLayer->GetNextFeature(); poLayer->ResetReading(); if (poGeometry==NULL){ return; } switch(wkbFlatten(poGeometry->getGeometryType())) { case wkbPoint: { ((OGRPoint*)poGeometry);///////////////////////// break; } case wkbLineString: case wkbLinearRing: { OGRLineString* poLS = (OGRLineString*) poGeometry; for(int i=0;i<poLS->getNumPoints();i++) shoreLinePoints.push_back(coordinate(poLS->getX(i),poLS->getY(i))); break; } case wkbPolygon: { int i; OGRPolygon* poPoly = (OGRPolygon*) poGeometry; //SetZ(poPoly->getExteriorRing(), dfZ); for(i=0;i<poPoly->getNumInteriorRings();i++) // SetZ(poPoly->getInteriorRing(i), dfZ); break; } case wkbMultiPoint: case wkbMultiLineString: case wkbMultiPolygon: case wkbGeometryCollection: { int i; OGRGeometryCollection* poGeometryColl = (OGRGeometryCollection*) poGeometry; for(i=0;i<poGeometryColl->getNumGeometries();i++) // SetZ(poGeometryColl->getGeometryRef(i), dfZ); break; } default: printf( "no readable geometry\n" ); break; } OGRFeature::DestroyFeature( poFeature ); OGRDataSource::DestroyDataSource( poDS ); return; }
bool ShpReader::Open(std::wstring fullPath, StudyControllerPtr studyController, VectorMapControllerPtr vectorMapController, ProgressDlgPtr progressDlg) { // Registers all format drivers built into GDAL/OGR. OGRRegisterAll(); OGRDataSource *OGRDataset; // Open vector file path std::string tempStr( fullPath.begin(), fullPath.end() ); OGRDataset = OGRSFDriverRegistrar::Open( tempStr.c_str(), FALSE ); // Return if no vector files are found if( OGRDataset == NULL ) { Log::Inst().Warning("(Warning) Failed to open file at " + tempStr + "."); return false; } if ( App::Inst().GetLayerTreeController()->GetNumMapLayers() >0 ) MapControllerPtr mapController= App::Inst().GetLayerTreeController()->GetLayerTreeModel()->GetStudy(0)->GetMapLayer(0)->GetMapController(); // It appears that shapefiles (*.SHP) only support up to one layer per file // This will need to be further investigated for other vector filetypes (e.g., KML) // For now just grab layer at position 0 OGRLayer *poLayer = OGRDataset->GetLayer( 0 ); // Determine the XY boundaries for the entire vector dataset OGREnvelope psEnvelope; VectorMapModelPtr vectorMapModel = vectorMapController->GetVectorMapModel(); poLayer->GetExtent( &psEnvelope ); vectorMapModel->SetVectorBoundary(psEnvelope); if(!SetupVectorProjection(OGRDataset,studyController,poLayer,vectorMapController )) { OGRDataset->DestroyDataSource(OGRDataset); return false; } if(progressDlg) { if(!progressDlg->Update(0, _T("Reading Vector Map Information..."))) { OGRDataset->DestroyDataSource(OGRDataset); return false; } } GLdouble minX, minY, maxX, maxY; minX = minY = std::numeric_limits<float>::max(); maxX = maxY = -std::numeric_limits<float>::max(); // Retrieve features from the dataset OGRFeature *poFeature; poLayer->ResetReading(); int numFeatures = poLayer->GetFeatureCount(); int count=0; //Log::Inst().Write("Loading shapefile with the following meta data:"); while ( ( poFeature = poLayer->GetNextFeature() ) != NULL ) { ///////////////////////////////////////////////// // PHASE 1: Retrieve METADATA from the dataset // ///////////////////////////////////////////////// OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn(); int iField; for( iField = 0; iField < poFDefn->GetFieldCount(); iField++ ) { OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( iField ); //if( poFieldDefn->GetType() == OFTInteger ) // printf( "%d,", poFeature->GetFieldAsInteger( iField ) ); //else if( poFieldDefn->GetType() == OFTReal ) // printf( "%.3f,", poFeature->GetFieldAsDouble(iField) ); //else if( poFieldDefn->GetType() == OFTString ) // printf( "%s,", poFeature->GetFieldAsString(iField) ); //else // printf( "%s,", poFeature->GetFieldAsString(iField) ); //ofs << poFeature->GetFieldAsString(iField) << ","; std::string metaData = poFeature->GetFieldAsString(iField); // do something with the meta data... //Log::Inst().Write(metaData); } count++; if(progressDlg) { if(!progressDlg->Update(int(50 + (float(count)/numFeatures)*50))) return false; } /////////////////////////////////////////////////// // PHASE 2: Retrieve GEOMETRIES from the dataset // /////////////////////////////////////////////////// OGRGeometry *poGeometry; poGeometry = poFeature->GetGeometryRef(); // Move to the next feature in the set if no geometry present if( poGeometry == NULL ) { OGRFeature::DestroyFeature( poFeature ); continue; } OGRwkbGeometryType whatisit = poGeometry->getGeometryType(); // Handle POINTS if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbPoint ) { GeoVector* geoVector = new GeoVector(); OGRPoint *poPoint = (OGRPoint *) poGeometry; geoVector->SetGeometryType( wkbPoint ); geoVector->SetNumberOfPoints( 1 ); if(needProjection) { double x,y; x= poPoint->getX(); y= poPoint->getY(); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[0] = x; geoVector->pointY[0] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[0] = poPoint->getX(); geoVector->pointY[0] = poPoint->getY(); } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } //Handle MultiPoint else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbMultiPoint ) { OGRMultiPoint *poMultiPoint = (OGRMultiPoint *) poGeometry; for ( int currGeometry = 0; currGeometry < poMultiPoint->getNumGeometries(); currGeometry++ ) { GeoVector* geoVector = new GeoVector(); OGRPoint *poPoint = ( OGRPoint* )poMultiPoint->getGeometryRef( currGeometry ); geoVector->SetGeometryType( wkbPoint ); geoVector->SetNumberOfPoints( 1 ); if(needProjection) { double x,y; x= poPoint->getX(); y= poPoint->getY(); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[0] = x; geoVector->pointY[0] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[0] = poPoint->getX(); geoVector->pointY[0] = poPoint->getY(); } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } } //Handle Polylines else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbLineString ) { GeoVector* geoVector = new GeoVector(); OGRLineString *poLine = (OGRLineString *) poGeometry; geoVector->SetGeometryType( wkbLineString ); geoVector->SetNumberOfPoints( poLine->getNumPoints() ); // Convert and store the points for ( int currentPoint = 0; currentPoint < poLine->getNumPoints(); currentPoint++ ) { // Convert and store the points if(needProjection) { double x,y; x= poLine->getX( currentPoint ); y= poLine->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[currentPoint] = x; geoVector->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[currentPoint] = poLine->getX( currentPoint ); geoVector->pointY[currentPoint] = poLine->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } // Handle MultiPolyLine else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbMultiLineString ) { OGRMultiLineString *poMultiLine = (OGRMultiLineString *) poGeometry; for ( int currGeometry = 0; currGeometry < poMultiLine->getNumGeometries(); currGeometry++ ) { GeoVector* geoVector = new GeoVector(); OGRLineString *poLine = ( OGRLineString* )poMultiLine->getGeometryRef( currGeometry ); geoVector->SetGeometryType( wkbLineString ); geoVector->SetNumberOfPoints( poLine->getNumPoints() ); for ( int currentPoint = 0; currentPoint < poLine ->getNumPoints(); currentPoint++ ) { if(needProjection) { double x,y; x= poLine->getX( currentPoint ); y= poLine->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[currentPoint] = x; geoVector->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[currentPoint] = poLine->getX( currentPoint ); geoVector->pointY[currentPoint] = poLine->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } } // Handle POLYGONS else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbPolygon ) { GeoVector* geoVector = new GeoVector(); OGRPolygon *poPolygon = ( OGRPolygon* )poGeometry; OGRLinearRing *poLinearRing = poPolygon->getExteriorRing(); geoVector->SetGeometryType( wkbLinearRing ); geoVector->SetNumberOfPoints( poLinearRing->getNumPoints() ); for ( int currentPoint = 0; currentPoint < poLinearRing->getNumPoints(); currentPoint++ ) { if(needProjection) { double x,y; x= poLinearRing->getX( currentPoint ); y= poLinearRing->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[currentPoint] = x; geoVector->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[currentPoint] = poLinearRing->getX( currentPoint ); geoVector->pointY[currentPoint] = poLinearRing->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); } // Handle MULTIPOLYGONS else if ( wkbFlatten( poGeometry->getGeometryType() ) == wkbMultiPolygon ) { OGRMultiPolygon *poMultiPolygon = (OGRMultiPolygon *) poGeometry; for ( int currGeometry = 0; currGeometry < poMultiPolygon->getNumGeometries(); currGeometry++ ) { GeoVector* geoVector = new GeoVector(); // OGRPolygon http://www.gdal.org/ogr/classOGRPolygon.html OGRPolygon *poPolygon = ( OGRPolygon* )poMultiPolygon->getGeometryRef( currGeometry ); // Retrieve the EXTERNAL ring of the multipolygon OGRLinearRing *poLinearRing = poPolygon->getExteriorRing(); geoVector->SetGeometryType( wkbLinearRing ); geoVector->SetNumberOfPoints( poLinearRing->getNumPoints() ); for ( int currentPoint = 0; currentPoint < poLinearRing->getNumPoints(); currentPoint++ ) { if(needProjection) { double x,y; x= poLinearRing->getX( currentPoint ); y= poLinearRing->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector->pointX[currentPoint] = x; geoVector->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector->pointX[currentPoint] = poLinearRing->getX( currentPoint ); geoVector->pointY[currentPoint] = poLinearRing->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector ); // Retrieve all the INTERNAL rings of the multipolygon for ( int currentRing = 0; currentRing < poPolygon->getNumInteriorRings(); currentRing++ ) { GeoVector* geoVector2 = new GeoVector(); poLinearRing = poPolygon->getInteriorRing( currentRing ); geoVector2->SetGeometryType( wkbLinearRing ); geoVector2->SetNumberOfPoints( poLinearRing->getNumPoints() ); for ( int currentPoint = 0; currentPoint < poLinearRing->getNumPoints(); currentPoint++ ) { if(needProjection) { double x,y; x= poLinearRing->getX( currentPoint ); y= poLinearRing->getY( currentPoint ); if(!poTransform->Transform(1, &x, &y)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } // project and store the points geoVector2->pointX[currentPoint] = x; geoVector2->pointY[currentPoint] = y; if(x < minX) minX=x; if(y < minY) minY=y; if(x > maxX) maxX=x; if(y > maxY) maxY=y; } else { geoVector2->pointX[currentPoint] = poLinearRing->getX( currentPoint ); geoVector2->pointY[currentPoint] = poLinearRing->getY( currentPoint ); } } vectorMapController->GetVectorMapModel()->AddGeoVector( geoVector2 ); } } } // Report a warning message for unhandled geometries else { Log::Inst().Warning("(Warning) Could not load vector data: unsupported geometry."); } OGRFeature::DestroyFeature( poFeature ); } if (float(minX) == float(maxX) && float(minY) == float(maxY)) { Log::Inst().Warning("(Warning) Failed to project vector map."); OGRDataset->DestroyDataSource(OGRDataset); return false; } if(needProjection) { vectorMapModel->SetVectorBoundary_MinX(minX); vectorMapModel->SetVectorBoundary_MaxX(maxX); vectorMapModel->SetVectorBoundary_MinY(minY); vectorMapModel->SetVectorBoundary_MaxY(maxY); } if(!SetupVectorScaling(vectorMapModel,progressDlg)) { OGRDataset->DestroyDataSource(OGRDataset); return false; } VectorMetaDataInfo(OGRDataset, studyController, vectorMapController); OGRDataSource::DestroyDataSource( OGRDataset ); return true; }
void lasclip(std::string &outfile, std::string &shapefile, std::string &layername, std::vector<std::string> &files, std::set<int> &classes, bool quiet) { if (outfile.empty()) g_argerr("An output file is required."); if (shapefile.empty()) g_argerr("A shape file is required."); if (files.size() == 0) g_argerr("At least one input file is required."); if (classes.size() == 0) g_warn("No classes specified, matching all classes."); /* Attempt to open and load geometries from the shape file. */ OGRRegisterAll(); OGRLayer *layer; OGRFeature *feat; OGRGeometry *og; OGRwkbGeometryType type; gg::GeometryCollection *geomColl; gg::Geometry *geom; OGRDataSource *ds = OGRSFDriverRegistrar::Open(shapefile.c_str(), FALSE); if (ds == nullptr) g_runerr("Couldn't open shapefile."); if (layername.empty()) { layer = ds->GetLayer(0); } else { layer = ds->GetLayerByName(layername.c_str()); } if (layer == nullptr) g_runerr("Couldn't get layer."); type = layer->GetGeomType(); if (type != wkbPolygon && type != wkbMultiPolygon) g_runerr("Geometry must be polygon or multipolygon."); const GEOSContextHandle_t gctx = OGRGeometry::createGEOSContext(); const gg::GeometryFactory *gf = gg::GeometryFactory::getDefaultInstance(); const gg::CoordinateSequenceFactory *cf = gf->getCoordinateSequenceFactory(); std::vector<gg::Geometry *> geoms; while ((feat = layer->GetNextFeature()) != NULL) { og = feat->GetGeometryRef(); geom = (gg::Geometry *) og->exportToGEOS(gctx); geoms.push_back(geom); } GDALClose(ds); if (geoms.size() == 0) g_runerr("No geometries were found."); /* The geometry collection is used for checking whether a las file intersects the region of interest. */ geomColl = gf->createGeometryCollection(geoms); const gg::Envelope *env = geomColl->getEnvelopeInternal(); Bounds cbounds(env->getMinX(), env->getMinY(), env->getMaxX(), env->getMaxY()); /* Loop over files and figure out which ones are relevant. */ liblas::ReaderFactory rf; liblas::Header *dsth = nullptr; std::vector<unsigned int> indices; for (unsigned int i = 0; i < files.size(); ++i) { std::ifstream in(files[i].c_str(), std::ios::in | std::ios::binary); liblas::Reader r = rf.CreateWithStream(in); liblas::Header h = r.GetHeader(); if (i == 0) dsth = new liblas::Header(h); std::vector<gg::Coordinate> coords; coords.push_back(gg::Coordinate(h.GetMinX(), h.GetMinY())); coords.push_back(gg::Coordinate(h.GetMaxX(), h.GetMinY())); coords.push_back(gg::Coordinate(h.GetMaxX(), h.GetMaxY())); coords.push_back(gg::Coordinate(h.GetMinX(), h.GetMaxY())); coords.push_back(gg::Coordinate(h.GetMinX(), h.GetMinY())); gg::CoordinateSequence *cs = cf->create(&coords); gg::LinearRing *lr = gf->createLinearRing(cs); gg::Polygon *bounds = gf->createPolygon(lr, NULL); if (bounds->intersects(geomColl)) indices.push_back(i); in.close(); } if (indices.size() == 0) g_runerr("No files matched the given bounds."); std::ofstream out(outfile, std::ios::out | std::ios::binary); liblas::WriterFactory wf; liblas::Writer w(out, *dsth); liblas::Header::RecordsByReturnArray recs; int count = 0; double bounds[] = { G_DBL_MAX_POS, G_DBL_MAX_NEG, G_DBL_MAX_POS, G_DBL_MAX_NEG, G_DBL_MAX_POS, G_DBL_MAX_NEG }; g_trace("Using points from " << indices.size() << " files."); for (int i = 0; i < 5; ++i) recs.push_back(0); for (unsigned int i = 0; i < indices.size(); ++i) { std::ifstream in(files[indices[i]].c_str(), std::ios::in | std::ios::binary); liblas::Reader r = rf.CreateWithStream(in); liblas::Header h = r.GetHeader(); g_trace("Processing file " << files[indices[i]]); while (r.ReadNextPoint()) { liblas::Point pt = r.GetPoint(); int cls = pt.GetClassification().GetClass(); if (classes.size() > 0 && !Util::inList(classes, cls)) continue; double x = pt.GetX(); double y = pt.GetY(); const gg::Coordinate c(x, y); gg::Point *p = gf->createPoint(c); if (cbounds.contains(x, y) && geomColl->contains(p)) { ++recs[cls]; ++count; w.WritePoint(pt); if (pt.GetX() < bounds[0]) bounds[0] = pt.GetX(); if (pt.GetX() > bounds[1]) bounds[1] = pt.GetX(); if (pt.GetY() < bounds[2]) bounds[2] = pt.GetY(); if (pt.GetY() > bounds[3]) bounds[3] = pt.GetY(); if (pt.GetZ() < bounds[4]) bounds[4] = pt.GetZ(); if (pt.GetZ() > bounds[5]) bounds[5] = pt.GetZ(); } } in.close(); } // Set the total count and update the point record counts. dsth->SetMin(bounds[0], bounds[2], bounds[4]); dsth->SetMax(bounds[1], bounds[3], bounds[5]); dsth->SetPointRecordsCount(count); for (unsigned int i = 0; i < recs.size(); ++i) dsth->SetPointRecordsByReturnCount(i, recs[i]); w.WriteHeader(); }
int FindSRS( const char *pszInput, OGRSpatialReference &oSRS, int bDebug ) { int bGotSRS = FALSE; VSILFILE *fp = NULL; GDALDataset *poGDALDS = NULL; OGRDataSource *poOGRDS = NULL; OGRLayer *poLayer = NULL; char *pszProjection = NULL; CPLErrorHandler oErrorHandler = NULL; int bIsFile = FALSE; OGRErr eErr = CE_None; /* temporarily supress error messages we may get from xOpen() */ if ( ! bDebug ) oErrorHandler = CPLSetErrorHandler ( CPLQuietErrorHandler ); /* Test if argument is a file */ fp = VSIFOpenL( pszInput, "r" ); if ( fp ) { bIsFile = TRUE; VSIFCloseL( fp ); CPLDebug( "gdalsrsinfo", "argument is a file" ); } /* try to open with GDAL */ CPLDebug( "gdalsrsinfo", "trying to open with GDAL" ); poGDALDS = (GDALDataset *) GDALOpen( pszInput, GA_ReadOnly ); if ( poGDALDS != NULL && poGDALDS->GetProjectionRef( ) != NULL ) { pszProjection = (char *) poGDALDS->GetProjectionRef( ); if( oSRS.importFromWkt( &pszProjection ) == CE_None ) { CPLDebug( "gdalsrsinfo", "got SRS from GDAL" ); bGotSRS = TRUE; } GDALClose( (GDALDatasetH) poGDALDS ); if ( ! bGotSRS ) CPLDebug( "gdalsrsinfo", "did not open with GDAL" ); } #ifdef OGR_ENABLED /* if unsuccessful, try to open with OGR */ if ( ! bGotSRS ) { CPLDebug( "gdalsrsinfo", "trying to open with OGR" ); poOGRDS = OGRSFDriverRegistrar::Open( pszInput, FALSE, NULL ); if( poOGRDS != NULL ) { poLayer = poOGRDS->GetLayer( 0 ); if ( poLayer != NULL ) { OGRSpatialReference *poSRS = poLayer->GetSpatialRef( ); if ( poSRS != NULL ) { CPLDebug( "gdalsrsinfo", "got SRS from OGR" ); bGotSRS = TRUE; OGRSpatialReference* poSRSClone = poSRS->Clone(); oSRS = *poSRSClone; OGRSpatialReference::DestroySpatialReference( poSRSClone ); } } OGRDataSource::DestroyDataSource( poOGRDS ); poOGRDS = NULL; } if ( ! bGotSRS ) CPLDebug( "gdalsrsinfo", "did not open with OGR" ); } #endif // OGR_ENABLED /* Try ESRI file */ if ( ! bGotSRS && bIsFile && (strstr(pszInput,".prj") != NULL) ) { CPLDebug( "gdalsrsinfo", "trying to get SRS from ESRI .prj file [%s]", pszInput ); char **pszTemp; if ( strstr(pszInput,"ESRI::") != NULL ) pszTemp = CSLLoad( pszInput+6 ); else pszTemp = CSLLoad( pszInput ); if( pszTemp ) { eErr = oSRS.importFromESRI( pszTemp ); CSLDestroy( pszTemp ); } else eErr = OGRERR_UNSUPPORTED_SRS; if( eErr != OGRERR_NONE ) { CPLDebug( "gdalsrsinfo", "did not get SRS from ESRI .prj file" ); } else { CPLDebug( "gdalsrsinfo", "got SRS from ESRI .prj file" ); bGotSRS = TRUE; } } /* Last resort, try OSRSetFromUserInput() */ if ( ! bGotSRS ) { CPLDebug( "gdalsrsinfo", "trying to get SRS from user input [%s]", pszInput ); eErr = oSRS.SetFromUserInput( pszInput ); if( eErr != OGRERR_NONE ) { CPLDebug( "gdalsrsinfo", "did not get SRS from user input" ); } else { CPLDebug( "gdalsrsinfo", "got SRS from user input" ); bGotSRS = TRUE; } } /* restore error messages */ if ( ! bDebug ) CPLSetErrorHandler ( oErrorHandler ); return bGotSRS; }
int main (int argc, const char * argv[]) { time_t startTime = time(NULL); if (argc < 2 || strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) { usage(); return(0); } OGRGeometry *geometry; for (int argNum = 1; argNum < argc; ++argNum) { //-- whether to compute the robustness or not if (strcmp(argv[argNum], "--robustness") == 0) { computeRobustness = true; } //-- whether to use the point set topology paradigm or not //-- if not, odd-even paradigm is used by default else if (strcmp(argv[argNum], "--setdiff") == 0) { pointSet = true; } //-- mininum area to keep in output else if (strcmp(argv[argNum], "--minarea") == 0) { minArea = atof(argv[argNum+1]); ++argNum; } //-- ISR snapping tolerance else if (strcmp(argv[argNum], "--isr") == 0) { isrTolerance = atof(argv[argNum+1]); ++argNum; // TODO : scale dataset if tolerance < 1.0 because of CGAL bug } //-- output a shapefile (out.shp) instead of a WKT else if (strcmp(argv[argNum], "--shpOut") == 0) { shpOut = true; } //-- time the results else if (strcmp(argv[argNum], "--time") == 0) { timeResults = true; } //-- reading from WKT passed directly else if (strcmp(argv[argNum], "--wkt") == 0) { unsigned int bufferSize = 100000000; char *inputWKT = (char *)malloc(bufferSize*sizeof(char)); strcpy(inputWKT, argv[argNum+1]); ++argNum; OGRErr err = OGRGeometryFactory::createFromWkt(&inputWKT, NULL, &geometry); if (err != OGRERR_NONE) { switch (err) { case OGRERR_UNSUPPORTED_GEOMETRY_TYPE: std::cerr << "Error: geometry must be Polygon or MultiPolygon" << std::endl; break; case OGRERR_NOT_ENOUGH_DATA: case OGRERR_CORRUPT_DATA: std::cerr << "Error: corrupted input" << std::endl; break; default: std::cerr << "Error: corrupted input" << std::endl; break; } return 1; } if (geometry->IsEmpty() == 1) { std::cerr << "Error: empty geometry" << std::endl; return 1; } if ( (geometry->getGeometryType() != wkbPolygon) && (geometry->getGeometryType() != wkbMultiPolygon) ) { std::cerr << "Error: geometry must be Polygon or MultiPolygon" << std::endl; return 1; } } //-- reading from WKT stored in first line of a text file else if (strcmp(argv[argNum], "-f") == 0) { unsigned int bufferSize = 100000000; char *inputWKT = (char *)malloc(bufferSize*sizeof(char)); if (argNum + 1 <= argc - 1 && argv[argNum+1][0] != '-') { std::ifstream infile(argv[argNum+1], std::ifstream::in); infile.getline(inputWKT, bufferSize); ++argNum; } else { std::cerr << "Error: Missing input file name." << std::endl; return 1; } OGRGeometryFactory::createFromWkt(&inputWKT, NULL, &geometry); if (geometry == NULL) { std::cout << "Error: WKT is not valid" << std::endl; return 1; } } //-- reading from a ogr dataset (most supported: shp, geojson, gml, etc) else if (strcmp(argv[argNum], "--ogr") == 0) { OGRRegisterAll(); OGRDataSource *dataSource = OGRSFDriverRegistrar::Open(argv[argNum+1], false); ++argNum; if (dataSource == NULL) { std::cerr << "Error: Could not open file." << std::endl; return false; } OGRLayer *dataLayer = dataSource->GetLayer(0); //-- get first layer dataLayer->ResetReading(); //-- Reads all features in this layer OGRFeature *feature; //-- get first feature if (dataLayer->GetFeatureCount(true) > 1) std::cout << "Reading only the first feature in the shapefile." << std::endl; feature = dataLayer->GetNextFeature(); if (feature->GetGeometryRef()->getGeometryType() == wkbPolygon) { geometry = static_cast<OGRPolygon *>(feature->GetGeometryRef());feature->GetGeometryRef(); } else { std::cout << "First feature ain't a POLYGON." << std::endl; return(0); } } else { usage(); return(0); } } if (!timeResults) startTime = 0; PolygonRepair prepair; //-- compute robustness if (computeRobustness == true) std::cout << "Robustness of input polygon: " << sqrt(prepair.computeRobustness(geometry)) <<std::endl; OGRMultiPolygon *outPolygons; if (pointSet) { outPolygons = prepair.repairPointSet(geometry, startTime); } else { outPolygons = prepair.repairOddEven(geometry, startTime); } if (minArea > 0) { prepair.removeSmallPolygons(outPolygons, minArea); } //-- output well known text if (shpOut) { prepair.saveToShp(outPolygons, "out.shp"); } else { char *outputWKT; outPolygons->exportToWkt(&outputWKT); std::cout << outputWKT << std::endl; } //-- compute robustness if (computeRobustness == true) std::cout << "Robustness of output polygon: " << sqrt(prepair.computeRobustness()) <<std::endl; //-- time results if (timeResults) { time_t totalTime = time(NULL)-startTime; std::cout << "Done! Process finished in " << totalTime/60 << " minutes " << totalTime%60 << " seconds." << std::endl; } return 0; }
int main( int nArgc, char ** papszArgv ) { const char *pszDataSource = NULL; char** papszLayers = NULL; const char *pszSQLStatement = NULL; int bRet = TRUE; /* Must process OGR_SKIP before OGRRegisterAll(), but we can't call */ /* OGRGeneralCmdLineProcessor before it needs the drivers to be registered */ /* for the --format or --formats options */ for( int iArg = 1; iArg < nArgc; iArg++ ) { if( EQUAL(papszArgv[iArg], "--config") && iArg + 2 < nArgc && EQUAL(papszArgv[iArg+1], "OGR_SKIP") ) { CPLSetConfigOption(papszArgv[iArg+1], papszArgv[iArg+2]); break; } } /* -------------------------------------------------------------------- */ /* Register format(s). */ /* -------------------------------------------------------------------- */ OGRRegisterAll(); /* -------------------------------------------------------------------- */ /* Processing command line arguments. */ /* -------------------------------------------------------------------- */ nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 ); if( nArgc < 1 ) exit( -nArgc ); /* -------------------------------------------------------------------- */ /* Processing command line arguments. */ /* -------------------------------------------------------------------- */ for( int iArg = 1; iArg < nArgc; iArg++ ) { if( EQUAL(papszArgv[iArg], "--utility_version") ) { printf("%s was compiled against GDAL %s and is running against GDAL %s\n", papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME")); return 0; } else if( EQUAL(papszArgv[iArg],"-ro") ) bReadOnly = TRUE; else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet")) bVerbose = FALSE; else if( EQUAL(papszArgv[iArg],"-sql") && iArg + 1 < nArgc) pszSQLStatement = papszArgv[++iArg]; else if( papszArgv[iArg][0] == '-' ) { Usage(); } else if (pszDataSource == NULL) pszDataSource = papszArgv[iArg]; else papszLayers = CSLAddString(papszLayers, papszArgv[iArg]); } if( pszDataSource == NULL ) Usage(); /* -------------------------------------------------------------------- */ /* Open data source. */ /* -------------------------------------------------------------------- */ OGRDataSource *poDS; OGRSFDriver *poDriver; poDS = OGRSFDriverRegistrar::Open( pszDataSource, !bReadOnly, &poDriver ); if( poDS == NULL && !bReadOnly ) { poDS = OGRSFDriverRegistrar::Open( pszDataSource, FALSE, &poDriver ); if( poDS != NULL && bVerbose ) { printf( "Had to open data source read-only.\n" ); bReadOnly = TRUE; } } /* -------------------------------------------------------------------- */ /* Report failure */ /* -------------------------------------------------------------------- */ if( poDS == NULL ) { OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar(); printf( "FAILURE:\n" "Unable to open datasource `%s' with the following drivers.\n", pszDataSource ); for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ ) { printf( " -> %s\n", poR->GetDriver(iDriver)->GetName() ); } exit( 1 ); } /* -------------------------------------------------------------------- */ /* Some information messages. */ /* -------------------------------------------------------------------- */ if( bVerbose ) printf( "INFO: Open of `%s' using driver `%s' successful.\n", pszDataSource, poDriver->GetName() ); if( bVerbose && !EQUAL(pszDataSource,poDS->GetName()) ) { printf( "INFO: Internal data source name `%s'\n" " different from user name `%s'.\n", poDS->GetName(), pszDataSource ); } /* -------------------------------------------------------------------- */ /* Process optionnal SQL request. */ /* -------------------------------------------------------------------- */ if (pszSQLStatement != NULL) { OGRLayer *poResultSet = poDS->ExecuteSQL(pszSQLStatement, NULL, NULL); if (poResultSet == NULL) exit(1); printf( "INFO: Testing layer %s.\n", poResultSet->GetName() ); bRet = TestOGRLayer( poDS, poResultSet, TRUE ); poDS->ReleaseResultSet(poResultSet); } /* -------------------------------------------------------------------- */ /* Process each data source layer. */ /* -------------------------------------------------------------------- */ else if (papszLayers == NULL) { for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ ) { OGRLayer *poLayer = poDS->GetLayer(iLayer); if( poLayer == NULL ) { printf( "FAILURE: Couldn't fetch advertised layer %d!\n", iLayer ); exit( 1 ); } printf( "INFO: Testing layer %s.\n", poLayer->GetName() ); bRet &= TestOGRLayer( poDS, poLayer, FALSE ); } } else { /* -------------------------------------------------------------------- */ /* Or process layers specified by the user */ /* -------------------------------------------------------------------- */ char** papszLayerIter = papszLayers; while (*papszLayerIter) { OGRLayer *poLayer = poDS->GetLayerByName(*papszLayerIter); if( poLayer == NULL ) { printf( "FAILURE: Couldn't fetch requested layer %s!\n", *papszLayerIter ); exit( 1 ); } printf( "INFO: Testing layer %s.\n", poLayer->GetName() ); bRet &= TestOGRLayer( poDS, poLayer, FALSE ); papszLayerIter ++; } } /* -------------------------------------------------------------------- */ /* Close down. */ /* -------------------------------------------------------------------- */ OGRDataSource::DestroyDataSource(poDS); OGRCleanupAll(); CSLDestroy(papszLayers); CSLDestroy(papszArgv); #ifdef DBMALLOC malloc_dump(1); #endif return (bRet) ? 0 : 1; }
int main( int nArgc, char ** papszArgv ) { int nFirstSourceDataset = -1, bLayersWildcarded = TRUE, iArg; const char *pszFormat = "ESRI Shapefile"; const char *pszTileIndexField = "LOCATION"; const char *pszOutputName = NULL; int write_absolute_path = FALSE; int skip_different_projection = FALSE; char* current_path = NULL; int accept_different_schemas = FALSE; int bFirstWarningForNonMatchingAttributes = TRUE; /* Check strict compilation and runtime library version as we use C++ API */ if (! GDAL_CHECK_VERSION(papszArgv[0])) exit(1); /* -------------------------------------------------------------------- */ /* Register format(s). */ /* -------------------------------------------------------------------- */ OGRRegisterAll(); /* -------------------------------------------------------------------- */ /* Processing command line arguments. */ /* -------------------------------------------------------------------- */ for( iArg = 1; iArg < nArgc; iArg++ ) { if( EQUAL(papszArgv[iArg], "--utility_version") ) { printf("%s was compiled against GDAL %s and is running against GDAL %s\n", papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME")); return 0; } else if( EQUAL(papszArgv[iArg],"-f") && iArg < nArgc-1 ) { pszFormat = papszArgv[++iArg]; } else if( EQUAL(papszArgv[iArg],"-write_absolute_path")) { write_absolute_path = TRUE; } else if( EQUAL(papszArgv[iArg],"-skip_different_projection")) { skip_different_projection = TRUE; } else if( EQUAL(papszArgv[iArg],"-accept_different_schemas")) { accept_different_schemas = TRUE; } else if( EQUAL(papszArgv[iArg],"-tileindex") && iArg < nArgc-1 ) { pszTileIndexField = papszArgv[++iArg]; } else if( EQUAL(papszArgv[iArg],"-lnum") || EQUAL(papszArgv[iArg],"-lname") ) { iArg++; bLayersWildcarded = FALSE; } else if( papszArgv[iArg][0] == '-' ) Usage(); else if( pszOutputName == NULL ) pszOutputName = papszArgv[iArg]; else if( nFirstSourceDataset == -1 ) nFirstSourceDataset = iArg; } if( pszOutputName == NULL || nFirstSourceDataset == -1 ) Usage(); /* -------------------------------------------------------------------- */ /* Try to open as an existing dataset for update access. */ /* -------------------------------------------------------------------- */ OGRDataSource *poDstDS; OGRLayer *poDstLayer = NULL; poDstDS = OGRSFDriverRegistrar::Open( pszOutputName, TRUE ); /* -------------------------------------------------------------------- */ /* If that failed, find the driver so we can create the tile index.*/ /* -------------------------------------------------------------------- */ if( poDstDS == NULL ) { OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar(); OGRSFDriver *poDriver = NULL; int iDriver; for( iDriver = 0; iDriver < poR->GetDriverCount() && poDriver == NULL; iDriver++ ) { if( EQUAL(poR->GetDriver(iDriver)->GetName(),pszFormat) ) { poDriver = poR->GetDriver(iDriver); } } if( poDriver == NULL ) { fprintf( stderr, "Unable to find driver `%s'.\n", pszFormat ); fprintf( stderr, "The following drivers are available:\n" ); for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ ) { fprintf( stderr, " -> `%s'\n", poR->GetDriver(iDriver)->GetName() ); } exit( 1 ); } if( !poDriver->TestCapability( ODrCCreateDataSource ) ) { fprintf( stderr, "%s driver does not support data source creation.\n", pszFormat ); exit( 1 ); } /* -------------------------------------------------------------------- */ /* Now create it. */ /* -------------------------------------------------------------------- */ poDstDS = poDriver->CreateDataSource( pszOutputName, NULL ); if( poDstDS == NULL ) { fprintf( stderr, "%s driver failed to create %s\n", pszFormat, pszOutputName ); exit( 1 ); } if( poDstDS->GetLayerCount() == 0 ) { OGRFieldDefn oLocation( pszTileIndexField, OFTString ); oLocation.SetWidth( 200 ); if( nFirstSourceDataset < nArgc && papszArgv[nFirstSourceDataset][0] == '-' ) { nFirstSourceDataset++; } OGRSpatialReference* poSrcSpatialRef = NULL; /* Fetches the SRS of the first layer and use it when creating the tileindex layer */ if (nFirstSourceDataset < nArgc) { OGRDataSource* poDS = OGRSFDriverRegistrar::Open( papszArgv[nFirstSourceDataset], FALSE ); if (poDS) { int iLayer; for( iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ ) { int bRequested = bLayersWildcarded; OGRLayer *poLayer = poDS->GetLayer(iLayer); for( iArg = 1; iArg < nArgc && !bRequested; iArg++ ) { if( EQUAL(papszArgv[iArg],"-lnum") && atoi(papszArgv[iArg+1]) == iLayer ) bRequested = TRUE; else if( EQUAL(papszArgv[iArg],"-lname") && EQUAL(papszArgv[iArg+1], poLayer->GetLayerDefn()->GetName()) ) bRequested = TRUE; } if( !bRequested ) continue; if ( poLayer->GetSpatialRef() ) poSrcSpatialRef = poLayer->GetSpatialRef()->Clone(); break; } } OGRDataSource::DestroyDataSource( poDS ); } poDstLayer = poDstDS->CreateLayer( "tileindex", poSrcSpatialRef ); poDstLayer->CreateField( &oLocation, OFTString ); OGRSpatialReference::DestroySpatialReference( poSrcSpatialRef ); } } /* -------------------------------------------------------------------- */ /* Identify target layer and field. */ /* -------------------------------------------------------------------- */ int iTileIndexField; poDstLayer = poDstDS->GetLayer(0); if( poDstLayer == NULL ) { fprintf( stderr, "Can't find any layer in output tileindex!\n" ); exit( 1 ); } iTileIndexField = poDstLayer->GetLayerDefn()->GetFieldIndex( pszTileIndexField ); if( iTileIndexField == -1 ) { fprintf( stderr, "Can't find %s field in tile index dataset.\n", pszTileIndexField ); exit( 1 ); } OGRFeatureDefn* poFeatureDefn = NULL; /* Load in memory existing file names in SHP */ int nExistingLayers = 0; char** existingLayersTab = NULL; OGRSpatialReference* alreadyExistingSpatialRef = NULL; int alreadyExistingSpatialRefValid = FALSE; nExistingLayers = poDstLayer->GetFeatureCount(); if (nExistingLayers) { int i; existingLayersTab = (char**)CPLMalloc(nExistingLayers * sizeof(char*)); for(i=0;i<nExistingLayers;i++) { OGRFeature* feature = poDstLayer->GetNextFeature(); existingLayersTab[i] = CPLStrdup(feature->GetFieldAsString( iTileIndexField)); if (i == 0) { OGRDataSource *poDS; char* filename = CPLStrdup(existingLayersTab[i]); int j; for(j=strlen(filename)-1;j>=0;j--) { if (filename[j] == ',') break; } if (j >= 0) { int iLayer = atoi(filename + j + 1); filename[j] = 0; poDS = OGRSFDriverRegistrar::Open(filename, FALSE ); if (poDS) { OGRLayer *poLayer = poDS->GetLayer(iLayer); if (poLayer) { alreadyExistingSpatialRefValid = TRUE; alreadyExistingSpatialRef = (poLayer->GetSpatialRef()) ? poLayer->GetSpatialRef()->Clone() : NULL; if (poFeatureDefn == NULL) poFeatureDefn = poLayer->GetLayerDefn()->Clone(); } OGRDataSource::DestroyDataSource( poDS ); } } } } } if (write_absolute_path) { current_path = CPLGetCurrentDir(); if (current_path == NULL) { fprintf( stderr, "This system does not support the CPLGetCurrentDir call. " "The option -write_absolute_path will have no effect\n"); write_absolute_path = FALSE; } } /* ==================================================================== */ /* Process each input datasource in turn. */ /* ==================================================================== */ for(; nFirstSourceDataset < nArgc; nFirstSourceDataset++ ) { int i; OGRDataSource *poDS; if( papszArgv[nFirstSourceDataset][0] == '-' ) { nFirstSourceDataset++; continue; } char* fileNameToWrite; VSIStatBuf sStatBuf; if (write_absolute_path && CPLIsFilenameRelative( papszArgv[nFirstSourceDataset] ) && VSIStat( papszArgv[nFirstSourceDataset], &sStatBuf ) == 0) { fileNameToWrite = CPLStrdup(CPLProjectRelativeFilename(current_path,papszArgv[nFirstSourceDataset])); } else { fileNameToWrite = CPLStrdup(papszArgv[nFirstSourceDataset]); } poDS = OGRSFDriverRegistrar::Open( papszArgv[nFirstSourceDataset], FALSE ); if( poDS == NULL ) { fprintf( stderr, "Failed to open dataset %s, skipping.\n", papszArgv[nFirstSourceDataset] ); CPLFree(fileNameToWrite); continue; } /* -------------------------------------------------------------------- */ /* Check all layers, and see if they match requests. */ /* -------------------------------------------------------------------- */ int iLayer; for( iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ ) { int bRequested = bLayersWildcarded; OGRLayer *poLayer = poDS->GetLayer(iLayer); for( iArg = 1; iArg < nArgc && !bRequested; iArg++ ) { if( EQUAL(papszArgv[iArg],"-lnum") && atoi(papszArgv[iArg+1]) == iLayer ) bRequested = TRUE; else if( EQUAL(papszArgv[iArg],"-lname") && EQUAL(papszArgv[iArg+1], poLayer->GetLayerDefn()->GetName()) ) bRequested = TRUE; } if( !bRequested ) continue; /* Checks that the layer is not already in tileindex */ for(i=0;i<nExistingLayers;i++) { char szLocation[5000]; sprintf( szLocation, "%s,%d", fileNameToWrite, iLayer ); if (EQUAL(szLocation, existingLayersTab[i])) { fprintf(stderr, "Layer %d of %s is already in tileindex. Skipping it.\n", iLayer, papszArgv[nFirstSourceDataset]); break; } } if (i != nExistingLayers) { continue; } OGRSpatialReference* spatialRef = poLayer->GetSpatialRef(); if (alreadyExistingSpatialRefValid) { if ((spatialRef != NULL && alreadyExistingSpatialRef != NULL && spatialRef->IsSame(alreadyExistingSpatialRef) == FALSE) || ((spatialRef != NULL) != (alreadyExistingSpatialRef != NULL))) { fprintf(stderr, "Warning : layer %d of %s is not using the same projection system as " "other files in the tileindex. This may cause problems when " "using it in MapServer for example.%s\n", iLayer, papszArgv[nFirstSourceDataset], (skip_different_projection) ? " Skipping it" : ""); if (skip_different_projection) { continue; } } } else { alreadyExistingSpatialRefValid = TRUE; alreadyExistingSpatialRef = (spatialRef) ? spatialRef->Clone() : NULL; } /* -------------------------------------------------------------------- */ /* Check if all layers in dataset have the same attributes schema. */ /* -------------------------------------------------------------------- */ if( poFeatureDefn == NULL ) { poFeatureDefn = poLayer->GetLayerDefn()->Clone(); } else if ( !accept_different_schemas ) { OGRFeatureDefn* poFeatureDefnCur = poLayer->GetLayerDefn(); assert(NULL != poFeatureDefnCur); int fieldCount = poFeatureDefnCur->GetFieldCount(); if( fieldCount != poFeatureDefn->GetFieldCount()) { fprintf( stderr, "Number of attributes of layer %s of %s does not match ... skipping it.\n", poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset]); if (bFirstWarningForNonMatchingAttributes) { fprintf( stderr, "Note : you can override this behaviour with -accept_different_schemas option\n" "but this may result in a tileindex incompatible with MapServer\n"); bFirstWarningForNonMatchingAttributes = FALSE; } continue; } int bSkip = FALSE; for( int fn = 0; fn < poFeatureDefnCur->GetFieldCount(); fn++ ) { OGRFieldDefn* poField = poFeatureDefn->GetFieldDefn(fn); OGRFieldDefn* poFieldCur = poFeatureDefnCur->GetFieldDefn(fn); /* XXX - Should those pointers be checked against NULL? */ assert(NULL != poField); assert(NULL != poFieldCur); if( poField->GetType() != poFieldCur->GetType() || poField->GetWidth() != poFieldCur->GetWidth() || poField->GetPrecision() != poFieldCur->GetPrecision() || !EQUAL( poField->GetNameRef(), poFieldCur->GetNameRef() ) ) { fprintf( stderr, "Schema of attributes of layer %s of %s does not match ... skipping it.\n", poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset]); if (bFirstWarningForNonMatchingAttributes) { fprintf( stderr, "Note : you can override this behaviour with -accept_different_schemas option\n" "but this may result in a tileindex incompatible with MapServer\n"); bFirstWarningForNonMatchingAttributes = FALSE; } bSkip = TRUE; break; } } if (bSkip) continue; } /* -------------------------------------------------------------------- */ /* Get layer extents, and create a corresponding polygon */ /* geometry. */ /* -------------------------------------------------------------------- */ OGREnvelope sExtents; OGRPolygon oRegion; OGRLinearRing oRing; if( poLayer->GetExtent( &sExtents, TRUE ) != OGRERR_NONE ) { fprintf( stderr, "GetExtent() failed on layer %s of %s, skipping.\n", poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset] ); continue; } oRing.addPoint( sExtents.MinX, sExtents.MinY ); oRing.addPoint( sExtents.MinX, sExtents.MaxY ); oRing.addPoint( sExtents.MaxX, sExtents.MaxY ); oRing.addPoint( sExtents.MaxX, sExtents.MinY ); oRing.addPoint( sExtents.MinX, sExtents.MinY ); oRegion.addRing( &oRing ); /* -------------------------------------------------------------------- */ /* Add layer to tileindex. */ /* -------------------------------------------------------------------- */ char szLocation[5000]; OGRFeature oTileFeat( poDstLayer->GetLayerDefn() ); sprintf( szLocation, "%s,%d", fileNameToWrite, iLayer ); oTileFeat.SetGeometry( &oRegion ); oTileFeat.SetField( iTileIndexField, szLocation ); if( poDstLayer->CreateFeature( &oTileFeat ) != OGRERR_NONE ) { fprintf( stderr, "Failed to create feature on tile index ... terminating." ); OGRDataSource::DestroyDataSource( poDstDS ); exit( 1 ); } } /* -------------------------------------------------------------------- */ /* Cleanup this data source. */ /* -------------------------------------------------------------------- */ CPLFree(fileNameToWrite); OGRDataSource::DestroyDataSource( poDS ); } /* -------------------------------------------------------------------- */ /* Close tile index and clear buffers. */ /* -------------------------------------------------------------------- */ OGRDataSource::DestroyDataSource( poDstDS ); OGRFeatureDefn::DestroyFeatureDefn( poFeatureDefn ); if (alreadyExistingSpatialRef != NULL) OGRSpatialReference::DestroySpatialReference( alreadyExistingSpatialRef ); CPLFree(current_path); if (nExistingLayers) { int i; for(i=0;i<nExistingLayers;i++) { CPLFree(existingLayersTab[i]); } CPLFree(existingLayersTab); } return 0; }
int Raster::VectortoRaster(const char * sVectorSourcePath, const char * sRasterOutputPath, const char * psFieldName, RasterMeta * p_rastermeta ){ OGRRegisterAll(); OGRDataSource * pDSVectorInput; pDSVectorInput = OGRSFDriverRegistrar::Open( sVectorSourcePath, FALSE ); if (pDSVectorInput == NULL) return INPUT_FILE_ERROR; OGRLayer * poLayer = pDSVectorInput->GetLayer(0); // The type of the field. OGRFeature * feat1 = poLayer->GetFeature(0); int fieldindex = feat1->GetFieldIndex(psFieldName); OGRFieldType fieldType = feat1->GetFieldDefnRef(fieldindex)->GetType(); OGRFeature::DestroyFeature( feat1 ); // The data type we're going to use for the file GDALDataType OutputDataType = GDT_Byte; // Handle field types according to their type: switch (fieldType) { case OFTString: CSVWriteVectorValues(poLayer, psFieldName, sRasterOutputPath); break; case OFTInteger: break; case OFTReal: OutputDataType = GDT_Float64; default: throw RasterManagerException(VECTOR_FIELD_NOT_VALID, "Type of field not recognized."); break; } // Get our projection and set the rastermeta accordingly. // ------------------------------------------------------- char *pszWKT = NULL; OGRSpatialReference* poSRS = poLayer->GetSpatialRef(); poSRS->exportToWkt(&pszWKT); p_rastermeta->SetProjectionRef(pszWKT); CPLFree(pszWKT); OSRDestroySpatialReference(poSRS); // Create the output dataset for writing GDALDataset * pDSOutput = CreateOutputDS(sRasterOutputPath, p_rastermeta); // Create a list of burn-in values // ------------------------------------------------------- std::vector<OGRGeometryH> ogrBurnGeometries; std::vector<double> dBurnValues; poLayer->ResetReading(); OGRFeature * ogrFeat = poLayer->GetNextFeature(); // <------- DRMEM!!! UNADDRESSABLE ACCESS of freed memory while( ogrFeat != NULL ){ OGRGeometry * ogrGeom = ogrFeat->GetGeometryRef(); // No geometry found. Move along. if( ogrGeom == NULL ) { OGRFeature::DestroyFeature( ogrFeat ); continue; } OGRGeometry * geoClone = ogrGeom->clone(); // <------- DRMEM!!! UNADDRESSABLE ACCESS of freed memory AND LEAK 20 direct bytes // Push a clone of this geometry onto the list of shapes to burn ogrBurnGeometries.push_back( (OGRGeometryH) geoClone ); if (fieldType == OFTString){ // If it's a string type we burn the FID. The value is then placed in a CSV file dBurnValues.push_back( ogrFeat->GetFID() ); } else { // If it's a float type or a byte type we write it directly. dBurnValues.push_back( ogrFeat->GetFieldAsDouble(psFieldName) ); } // GetNextFeature() creates a clone so we must delete it. OGRFeature::DestroyFeature( ogrFeat ); // <------- DRMEM!!! UNADDRESSABLE ACCESS beyond heap bounds: ogrFeat = poLayer->GetNextFeature(); // <------- DRMEM!!! UNADDRESSABLE ACCESS of freed memory } // Do the Actual Burning of Geometries. // ------------------------------------------------------- int band = 1; char **papszRasterizeOptions = NULL; papszRasterizeOptions = CSLSetNameValue( papszRasterizeOptions, "ALL_TOUCHED", "TRUE" ); CPLErr err = GDALRasterizeGeometries( pDSOutput, 1, &band, ogrBurnGeometries.size(), &(ogrBurnGeometries[0]), NULL, NULL, &(dBurnValues[0]), NULL, NULL, NULL ); if (err) { } ogrBurnGeometries.clear(); dBurnValues.clear(); // Done. Calculate stats and close file CalculateStats(pDSOutput->GetRasterBand(1)); CSLDestroy(papszRasterizeOptions); GDALClose(pDSOutput); pDSVectorInput->Release(); // <------- DRMEM!!! UNADDRESSABLE ACCESS beyond heap bounds: //This is where the implementation actually goes return PROCESS_OK; }