int main(int argc, char **argv) { // Get data from ogr OGRRegisterAll(); std::cout << "Opening: " << argv[1] << std::endl; OGRDataSource *shp = OGRSFDriverRegistrar::Open(argv[1], FALSE); IsValid(shp, "Error opening file."); std::cout << "Shape contains " << shp->GetLayerCount() << " layers." << std::endl; OGRLayer *layer = shp->GetLayerByName(argv[2]); IsValid(layer, "Couldn't grab layer"); OGRSpatialReference *srcSRS = NULL; srcSRS = layer->GetSpatialRef(); // Set up writing const char *kDriverName = "ESRI Shapefile"; OGRSFDriver *shpDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(kDriverName); IsValid(shpDriver, "Couldn't grab the shapefile driver."); IsValid(argv[3], "Please provide a output shp."); std::cout << "Writing to: " << argv[3] << std::endl; OGRDataSource *shpOut = shpDriver->CreateDataSource(argv[3], NULL); IsValid(shpOut, "Couldn't open output file"); OGRLayer *outLayer = shpOut->CreateLayer(layer->GetName(), srcSRS, wkbMultiLineString, NULL); IsValid(outLayer, "Couldn't create an output layer"); // copy over the fields from the source file OGRFeatureDefn *source = layer->GetLayerDefn(); for(int i=0; i < source->GetFieldCount(); i++){ OGRFieldDefn *field = source->GetFieldDefn(i); if(outLayer->CreateField(field) != OGRERR_NONE) { std::cout << "Couldn't make layer" << std::endl; exit(1); }; } // Loop through features and grab the hull and put it into CGAL then // skeletonize the points OGRFeature *feature; int count = 0; while((feature = layer->GetNextFeature()) != NULL) { OGRMultiPolygon *geometry = dynamic_cast<OGRMultiPolygon *>(OGRGeometryFactory::forceToMultiPolygon(feature->GetGeometryRef())); IsValid(geometry, "No geometry."); OGRFeature *outFeature = OGRFeature::CreateFeature(outLayer->GetLayerDefn()); IsValid(outFeature, "Couldn't make a feature."); for(int i=0; i < source->GetFieldCount(); i++){ OGRField *field = feature->GetRawFieldRef(i); outFeature->SetField(i, field); } OGRGeometry* line = NULL; for(int i=0; i < geometry->getNumGeometries(); i++){ OGRGeometry* segment = BuildMultiLine(geometry->getGeometryRef(i)); if(segment != NULL){ if(line == NULL) { line = new OGRLineString; } OGRGeometry* tmp = line->Union(segment); if(tmp != NULL){ delete line; line = tmp; } delete segment; } } outFeature->SetGeometry(line); if(outLayer->CreateFeature(outFeature) != OGRERR_NONE){ std::cout << "Couldn't create feature." << std::endl; exit(1); } // clean up OGRFeature::DestroyFeature(outFeature); std::cout << std::endl << ++count << std::endl; } // cleanup OGRDataSource::DestroyDataSource(shp); OGRDataSource::DestroyDataSource(shpOut); return 0; }
bool V2vProj::Compute(const data::VectorBarral * barrel) { OGRDataSource * poSourceDs = VectorOpen(barrel->GetSrcDataSource().c_str(), GA_ReadOnly); ON_SCOPE_EXIT([&]() {OGRDataSource::DestroyDataSource(poSourceDs); }); OGRDataSource * poOutputDs = VectorOpen(barrel->GetDstDataSource().c_str(), GA_Update); ON_SCOPE_EXIT([&]() {OGRDataSource::DestroyDataSource(poOutputDs); }); OGRLayer * poSrcLayer = poSourceDs->GetLayerByName( barrel->GetSrcLayer().c_str()); OGRLayer * poDstLayer = poOutputDs->GetLayerByName( barrel->GetDstLayer().c_str()); OGRSpatialReference * poSourceSRS = poSrcLayer->GetSpatialRef(); OGRCoordinateTransformation * poCT = poCT = OGRCreateCoordinateTransformation( poSourceSRS, m_ogrSr); OGRFeatureDefn * poDstFeatureDefn = poDstLayer->GetLayerDefn(); auto features = barrel->GetFeatures(); std::for_each(begin(features), end(features) , [&](int fid) { poSrcLayer->GetFeature(fid); OGRFeature * poDstFeature = OGRFeature::CreateFeature(poDstFeatureDefn); ON_SCOPE_EXIT([&]() {OGRFeature::DestroyFeature(poDstFeature); }); poDstFeature->SetFrom(poSrcLayer->GetFeature(fid)); OGRGeometry * poDstGeometry = poDstFeature->GetGeometryRef(); OGRGeometry * poReprojectedGeom = OGRGeometryFactory::transformWithOptions( poDstGeometry, poCT, NULL); poDstFeature->SetGeometryDirectly(poReprojectedGeom); poDstLayer->CreateFeature(poDstFeature); }); return true; }
void OGRDataSourceWithTransaction::RemapLayers() { std::set<OGRLayerWithTransaction*>::iterator oIter = m_oSetLayers.begin(); for(; oIter != m_oSetLayers.end(); ++oIter ) { OGRLayerWithTransaction* poWrappedLayer = *oIter; if( m_poBaseDataSource == NULL ) poWrappedLayer->m_poDecoratedLayer = NULL; else { poWrappedLayer->m_poDecoratedLayer = m_poBaseDataSource->GetLayerByName(poWrappedLayer->GetName()); } } m_oMapLayers.clear(); }
void MSN_Helper::LoadSamples(Config &config, Matrix &mat) { if(config.bShapefile) { OGRRegisterAll(); string pLayerName = StringGetFileName(config.sSamples); OGRDataSource* poDS = OGRSFDriverRegistrar::Open(config.sSamples.c_str(),FALSE); OGRLayer* poLayer = poDS->GetLayerByName(pLayerName.c_str()); config.nSamples = poLayer->GetFeatureCount(); mat.Resize(config.nSamples, 4); OGRPoint *poPoint; OGRFeature * pFeature =poLayer->GetNextFeature(); for(unsigned long i=1; i<=config.nSamples; i++) { //样本取值字段名为value,double型 poPoint = (OGRPoint *)pFeature->GetGeometryRef(); mat[i][1] = poPoint->getX(); mat[i][2] = poPoint->getY(); mat[i][3] = pFeature->GetFieldAsInteger("stratum"); mat[i][4] = pFeature->GetFieldAsDouble("value"); pFeature = poLayer->GetNextFeature(); } OGRDataSource::DestroyDataSource( poDS ); } else { double x, y, v, stratum; string sline; ifstream infile(config.sSamples.c_str()); infile >> config.nSamples; mat.Resize(config.nSamples, 4); for(unsigned long i=1; i<=config.nSamples; i++) { infile >> x >> y >> stratum >> v; mat[i][1] = x; mat[i][2] = y; mat[i][3] = stratum; mat[i][4] = v; } infile.close(); } }
JNIEXPORT jlong JNICALL Java_es_gva_cit_jogr_OGRDataSource_getLayerByNameNat (JNIEnv *env, jobject obj, jlong cPtr, jstring name){ OGRDataSource *ds = (OGRDataSource *) 0 ; const char *layername; OGRLayer *layer; long ptro_layer=-1; ds = *(OGRDataSource **)&cPtr; layername = env->GetStringUTFChars( name, 0 ); if(ds!=NULL){ layer=ds->GetLayerByName(layername); if(layer!=NULL)ptro_layer = (long)&(*layer); } env->ReleaseStringUTFChars( name, layername ); return (jlong)ptro_layer; }
MyOGRHandler(const std::string& filename) : m_data_source(NULL), m_layer_point(NULL), m_filter(true), m_tohstore() { OGRRegisterAll(); OGRSFDriver* driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName("PostgreSQL"); if (driver == NULL) { std::cerr << "PostgreSQL OGR driver not available.\n"; exit(1); } // using COPY is much faster than INSERT CPLSetConfigOption("PG_USE_COPY", "YES"); const char* options[] = { NULL }; m_data_source = driver->CreateDataSource(filename.c_str(), const_cast<char**>(options)); if (m_data_source == NULL) { std::cerr << "Database open failed.\n"; exit(1); } // OGR can't create a table with hstore column, so we do it ourselves here OGRLayer* dummy = m_data_source->ExecuteSQL("CREATE TABLE nodes (id VARCHAR, tags hstore);", NULL, NULL); if (dummy) { m_data_source->ReleaseResultSet(dummy); } dummy = m_data_source->ExecuteSQL("SELECT AddGeometryColumn('nodes', 'geom', 4326, 'POINT', 2);", NULL, NULL); if (dummy) { m_data_source->ReleaseResultSet(dummy); } m_layer_point = m_data_source->GetLayerByName("nodes"); if (!m_layer_point) { std::cerr << "Something went wrong setting up the 'nodes' layer.\n"; exit(1); } // using transactions makes this much faster than without m_layer_point->StartTransaction(); m_filter.add(false, "created_by"); m_filter.add(false, "odbl"); }
OGRLayer *OGRDataSourceWithTransaction::GetLayerByName(const char *pszName) { if( !m_poBaseDataSource ) return NULL; return WrapLayer(m_poBaseDataSource->GetLayerByName(pszName)); }
OGRLayer * OGRDataSource::ExecuteSQL( const char *pszStatement, OGRGeometry *poSpatialFilter, const char *pszDialect ) { const char *pszError; swq_select *psSelectInfo = NULL; (void) pszDialect; /* -------------------------------------------------------------------- */ /* Handle CREATE INDEX statements specially. */ /* -------------------------------------------------------------------- */ if( EQUALN(pszStatement,"CREATE INDEX",12) ) { ProcessSQLCreateIndex( pszStatement ); return NULL; } /* -------------------------------------------------------------------- */ /* Handle DROP INDEX statements specially. */ /* -------------------------------------------------------------------- */ if( EQUALN(pszStatement,"DROP INDEX",10) ) { ProcessSQLDropIndex( pszStatement ); return NULL; } /* -------------------------------------------------------------------- */ /* Preparse the SQL statement. */ /* -------------------------------------------------------------------- */ pszError = swq_select_preparse( pszStatement, &psSelectInfo ); if( pszError != NULL ) { CPLError( CE_Failure, CPLE_AppDefined, "SQL: %s", pszError ); return NULL; } /* -------------------------------------------------------------------- */ /* Validate that all the source tables are recognised, count */ /* fields. */ /* -------------------------------------------------------------------- */ int nFieldCount = 0, iTable; for( iTable = 0; iTable < psSelectInfo->table_count; iTable++ ) { swq_table_def *psTableDef = psSelectInfo->table_defs + iTable; OGRLayer *poSrcLayer; OGRDataSource *poTableDS = this; if( psTableDef->data_source != NULL ) { poTableDS = (OGRDataSource *) OGROpenShared( psTableDef->data_source, FALSE, NULL ); if( poTableDS == NULL ) { if( strlen(CPLGetLastErrorMsg()) == 0 ) CPLError( CE_Failure, CPLE_AppDefined, "Unable to open secondary datasource\n" "`%s' required by JOIN.", psTableDef->data_source ); swq_select_free( psSelectInfo ); return NULL; } // This drops explicit reference, but leave it open for use by // code in ogr_gensql.cpp poTableDS->Dereference(); } poSrcLayer = poTableDS->GetLayerByName( psTableDef->table_name ); if( poSrcLayer == NULL ) { CPLError( CE_Failure, CPLE_AppDefined, "SELECT from table %s failed, no such table/featureclass.", psTableDef->table_name ); swq_select_free( psSelectInfo ); return NULL; } nFieldCount += poSrcLayer->GetLayerDefn()->GetFieldCount(); } /* -------------------------------------------------------------------- */ /* Build the field list for all indicated tables. */ /* -------------------------------------------------------------------- */ swq_field_list sFieldList; int nFIDIndex = 0; memset( &sFieldList, 0, sizeof(sFieldList) ); sFieldList.table_count = psSelectInfo->table_count; sFieldList.table_defs = psSelectInfo->table_defs; sFieldList.count = 0; sFieldList.names = (char **) CPLMalloc( sizeof(char *) * (nFieldCount+1) ); sFieldList.types = (swq_field_type *) CPLMalloc( sizeof(swq_field_type) * (nFieldCount+1) ); sFieldList.table_ids = (int *) CPLMalloc( sizeof(int) * (nFieldCount+1) ); sFieldList.ids = (int *) CPLMalloc( sizeof(int) * (nFieldCount+1) ); for( iTable = 0; iTable < psSelectInfo->table_count; iTable++ ) { swq_table_def *psTableDef = psSelectInfo->table_defs + iTable; OGRDataSource *poTableDS = this; OGRLayer *poSrcLayer; int iField; if( psTableDef->data_source != NULL ) { poTableDS = (OGRDataSource *) OGROpenShared( psTableDef->data_source, FALSE, NULL ); CPLAssert( poTableDS != NULL ); poTableDS->Dereference(); } poSrcLayer = poTableDS->GetLayerByName( psTableDef->table_name ); for( iField = 0; iField < poSrcLayer->GetLayerDefn()->GetFieldCount(); iField++ ) { OGRFieldDefn *poFDefn=poSrcLayer->GetLayerDefn()->GetFieldDefn(iField); int iOutField = sFieldList.count++; sFieldList.names[iOutField] = (char *) poFDefn->GetNameRef(); if( poFDefn->GetType() == OFTInteger ) sFieldList.types[iOutField] = SWQ_INTEGER; else if( poFDefn->GetType() == OFTReal ) sFieldList.types[iOutField] = SWQ_FLOAT; else if( poFDefn->GetType() == OFTString ) sFieldList.types[iOutField] = SWQ_STRING; else sFieldList.types[iOutField] = SWQ_OTHER; sFieldList.table_ids[iOutField] = iTable; sFieldList.ids[iOutField] = iField; } if( iTable == 0 ) nFIDIndex = poSrcLayer->GetLayerDefn()->GetFieldCount(); } /* -------------------------------------------------------------------- */ /* Expand '*' in 'SELECT *' now before we add the pseudo field */ /* 'FID'. */ /* -------------------------------------------------------------------- */ pszError = swq_select_expand_wildcard( psSelectInfo, &sFieldList ); if( pszError != NULL ) { CPLError( CE_Failure, CPLE_AppDefined, "SQL: %s", pszError ); return NULL; } sFieldList.names[sFieldList.count] = "FID"; sFieldList.types[sFieldList.count] = SWQ_INTEGER; sFieldList.table_ids[sFieldList.count] = 0; sFieldList.ids[sFieldList.count] = nFIDIndex; sFieldList.count++; /* -------------------------------------------------------------------- */ /* Finish the parse operation. */ /* -------------------------------------------------------------------- */ pszError = swq_select_parse( psSelectInfo, &sFieldList, 0 ); CPLFree( sFieldList.names ); CPLFree( sFieldList.types ); CPLFree( sFieldList.table_ids ); CPLFree( sFieldList.ids ); if( pszError != NULL ) { CPLError( CE_Failure, CPLE_AppDefined, "SQL: %s", pszError ); return NULL; } /* -------------------------------------------------------------------- */ /* Everything seems OK, try to instantiate a results layer. */ /* -------------------------------------------------------------------- */ OGRGenSQLResultsLayer *poResults; poResults = new OGRGenSQLResultsLayer( this, psSelectInfo, poSpatialFilter ); // Eventually, we should keep track of layers to cleanup. return poResults; }
OGRLayer * OGRSQLiteExecuteSQL( OGRDataSource* poDS, const char *pszStatement, OGRGeometry *poSpatialFilter, const char *pszDialect ) { char* pszTmpDBName = (char*) CPLMalloc(256); sprintf(pszTmpDBName, "/vsimem/ogr2sqlite/temp_%p.db", pszTmpDBName); OGRSQLiteDataSource* poSQLiteDS = NULL; int nRet; int bSpatialiteDB = FALSE; CPLString osOldVal; const char* pszOldVal = CPLGetConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", NULL); if( pszOldVal != NULL ) { osOldVal = pszOldVal; pszOldVal = osOldVal.c_str(); } /* -------------------------------------------------------------------- */ /* Create in-memory sqlite/spatialite DB */ /* -------------------------------------------------------------------- */ #ifdef HAVE_SPATIALITE /* -------------------------------------------------------------------- */ /* Creating an empty spatialite DB (with spatial_ref_sys populated */ /* has a non-neglectable cost. So at the first attempt, let's make */ /* one and cache it for later use. */ /* -------------------------------------------------------------------- */ #if 1 static vsi_l_offset nEmptyDBSize = 0; static GByte* pabyEmptyDB = NULL; { static void* hMutex = NULL; CPLMutexHolder oMutexHolder(&hMutex); static int bTried = FALSE; if( !bTried && CSLTestBoolean(CPLGetConfigOption("OGR_SQLITE_DIALECT_USE_SPATIALITE", "YES")) ) { bTried = TRUE; char* pszCachedFilename = (char*) CPLMalloc(256); sprintf(pszCachedFilename, "/vsimem/ogr2sqlite/reference_%p.db",pszCachedFilename); char** papszOptions = CSLAddString(NULL, "SPATIALITE=YES"); OGRSQLiteDataSource* poCachedDS = new OGRSQLiteDataSource(); nRet = poCachedDS->Create( pszCachedFilename, papszOptions ); CSLDestroy(papszOptions); papszOptions = NULL; delete poCachedDS; if( nRet ) /* Note: the reference file keeps the ownership of the data, so that */ /* it gets released with VSICleanupFileManager() */ pabyEmptyDB = VSIGetMemFileBuffer( pszCachedFilename, &nEmptyDBSize, FALSE ); CPLFree( pszCachedFilename ); } } /* The following configuration option is usefull mostly for debugging/testing */ if( pabyEmptyDB != NULL && CSLTestBoolean(CPLGetConfigOption("OGR_SQLITE_DIALECT_USE_SPATIALITE", "YES")) ) { GByte* pabyEmptyDBClone = (GByte*)VSIMalloc(nEmptyDBSize); if( pabyEmptyDBClone == NULL ) { CPLFree(pszTmpDBName); return NULL; } memcpy(pabyEmptyDBClone, pabyEmptyDB, nEmptyDBSize); VSIFCloseL(VSIFileFromMemBuffer( pszTmpDBName, pabyEmptyDBClone, nEmptyDBSize, TRUE )); poSQLiteDS = new OGRSQLiteDataSource(); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO"); nRet = poSQLiteDS->Open( pszTmpDBName, TRUE ); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal); if( !nRet ) { /* should not happen really ! */ delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } bSpatialiteDB = TRUE; } #else /* No caching version */ poSQLiteDS = new OGRSQLiteDataSource(); char** papszOptions = CSLAddString(NULL, "SPATIALITE=YES"); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO"); nRet = poSQLiteDS->Create( pszTmpDBName, papszOptions ); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal); CSLDestroy(papszOptions); papszOptions = NULL; if( nRet ) { bSpatialiteDB = TRUE; } #endif else { delete poSQLiteDS; poSQLiteDS = NULL; #else // HAVE_SPATIALITE if( TRUE ) { #endif // HAVE_SPATIALITE poSQLiteDS = new OGRSQLiteDataSource(); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO"); nRet = poSQLiteDS->Create( pszTmpDBName, NULL ); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal); if( !nRet ) { delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } } /* -------------------------------------------------------------------- */ /* Attach the Virtual Table OGR2SQLITE module to it. */ /* -------------------------------------------------------------------- */ OGR2SQLITEModule* poModule = OGR2SQLITE_Setup(poDS, poSQLiteDS); sqlite3* hDB = poSQLiteDS->GetDB(); /* -------------------------------------------------------------------- */ /* Analysze the statement to determine which tables will be used. */ /* -------------------------------------------------------------------- */ std::set<LayerDesc> oSetLayers; std::set<CPLString> oSetSpatialIndex; CPLString osModifiedSQL; OGR2SQLITEGetPotentialLayerNames(pszStatement, oSetLayers, oSetSpatialIndex, osModifiedSQL); std::set<LayerDesc>::iterator oIter = oSetLayers.begin(); if( strcmp(pszStatement, osModifiedSQL.c_str()) != 0 ) CPLDebug("OGR", "Modified SQL: %s", osModifiedSQL.c_str()); pszStatement = osModifiedSQL.c_str(); /* do not use it anymore */ int bFoundOGRStyle = ( osModifiedSQL.ifind("OGR_STYLE") != std::string::npos ); /* -------------------------------------------------------------------- */ /* For each of those tables, create a Virtual Table. */ /* -------------------------------------------------------------------- */ for(; oIter != oSetLayers.end(); ++oIter) { const LayerDesc& oLayerDesc = *oIter; /*CPLDebug("OGR", "Layer desc : %s, %s, %s, %s", oLayerDesc.osOriginalStr.c_str(), oLayerDesc.osSubstitutedName.c_str(), oLayerDesc.osDSName.c_str(), oLayerDesc.osLayerName.c_str());*/ CPLString osSQL; OGRLayer* poLayer = NULL; CPLString osTableName; int nExtraDS; if( oLayerDesc.osDSName.size() == 0 ) { poLayer = poDS->GetLayerByName(oLayerDesc.osLayerName); /* Might be a false positive (unlikely) */ if( poLayer == NULL ) continue; osTableName = oLayerDesc.osLayerName; nExtraDS = -1; osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" USING VirtualOGR(%d,'%s',%d)", OGRSQLiteEscapeName(osTableName).c_str(), nExtraDS, OGRSQLiteEscape(osTableName).c_str(), bFoundOGRStyle); } else { OGRDataSource* poOtherDS = (OGRDataSource* ) OGROpen(oLayerDesc.osDSName, FALSE, NULL); if( poOtherDS == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot open datasource '%s'", oLayerDesc.osDSName.c_str() ); delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } poLayer = poOtherDS->GetLayerByName(oLayerDesc.osLayerName); if( poLayer == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot find layer '%s' in '%s'", oLayerDesc.osLayerName.c_str(), oLayerDesc.osDSName.c_str() ); delete poOtherDS; delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } osTableName = oLayerDesc.osSubstitutedName; nExtraDS = OGR2SQLITE_AddExtraDS(poModule, poOtherDS); osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" USING VirtualOGR(%d,'%s',%d)", OGRSQLiteEscapeName(osTableName).c_str(), nExtraDS, OGRSQLiteEscape(oLayerDesc.osLayerName).c_str(), bFoundOGRStyle); } char* pszErrMsg = NULL; int rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, &pszErrMsg ); if( rc != SQLITE_OK ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot create virtual table for layer '%s' : %s", osTableName.c_str(), pszErrMsg); sqlite3_free(pszErrMsg); continue; } if( poLayer->GetGeomType() == wkbNone ) continue; CPLString osGeomColRaw(OGR2SQLITE_GetNameForGeometryColumn(poLayer)); const char* pszGeomColRaw = osGeomColRaw.c_str(); CPLString osGeomColEscaped(OGRSQLiteEscape(pszGeomColRaw)); const char* pszGeomColEscaped = osGeomColEscaped.c_str(); CPLString osLayerNameEscaped(OGRSQLiteEscape(osTableName)); const char* pszLayerNameEscaped = osLayerNameEscaped.c_str(); CPLString osIdxNameRaw(CPLSPrintf("idx_%s_%s", oLayerDesc.osLayerName.c_str(), pszGeomColRaw)); CPLString osIdxNameEscaped(OGRSQLiteEscapeName(osIdxNameRaw)); /* Make sure that the SRS is injected in spatial_ref_sys */ OGRSpatialReference* poSRS = poLayer->GetSpatialRef(); int nSRSId = poSQLiteDS->GetUndefinedSRID(); if( poSRS != NULL ) nSRSId = poSQLiteDS->FetchSRSId(poSRS); int bCreateSpatialIndex = FALSE; if( !bSpatialiteDB ) { osSQL.Printf("INSERT INTO geometry_columns (f_table_name, " "f_geometry_column, geometry_format, geometry_type, " "coord_dimension, srid) " "VALUES ('%s','%s','SpatiaLite',%d,%d,%d)", pszLayerNameEscaped, pszGeomColEscaped, (int) wkbFlatten(poLayer->GetGeomType()), ( poLayer->GetGeomType() & wkb25DBit ) ? 3 : 2, nSRSId); } #ifdef HAVE_SPATIALITE else { /* We detect the need for creating a spatial index by 2 means : */ /* 1) if there's an explicit reference to a 'idx_layername_geometrycolumn' */ /* table in the SQL --> old/traditionnal way of requesting spatial indices */ /* with spatialite. */ std::set<LayerDesc>::iterator oIter2 = oSetLayers.begin(); for(; oIter2 != oSetLayers.end(); ++oIter2) { const LayerDesc& oLayerDescIter = *oIter2; if( EQUAL(oLayerDescIter.osLayerName, osIdxNameRaw) ) { bCreateSpatialIndex = TRUE; break; } } /* 2) or if there's a SELECT FROM SpatialIndex WHERE f_table_name = 'layername' */ if( !bCreateSpatialIndex ) { std::set<CPLString>::iterator oIter3 = oSetSpatialIndex.begin(); for(; oIter3 != oSetSpatialIndex.end(); ++oIter3) { const CPLString& osNameIter = *oIter3; if( EQUAL(osNameIter, oLayerDesc.osLayerName) ) { bCreateSpatialIndex = TRUE; break; } } } if( poSQLiteDS->HasSpatialite4Layout() ) { int nGeomType = poLayer->GetGeomType(); int nCoordDimension = 2; if( nGeomType & wkb25DBit ) { nGeomType += 1000; nCoordDimension = 3; } osSQL.Printf("INSERT INTO geometry_columns (f_table_name, " "f_geometry_column, geometry_type, coord_dimension, " "srid, spatial_index_enabled) " "VALUES ('%s',Lower('%s'),%d ,%d ,%d, %d)", pszLayerNameEscaped, pszGeomColEscaped, nGeomType, nCoordDimension, nSRSId, bCreateSpatialIndex ); } else { const char *pszGeometryType = OGRToOGCGeomType(poLayer->GetGeomType()); if (pszGeometryType[0] == '\0') pszGeometryType = "GEOMETRY"; osSQL.Printf("INSERT INTO geometry_columns (f_table_name, " "f_geometry_column, type, coord_dimension, " "srid, spatial_index_enabled) " "VALUES ('%s','%s','%s','%s',%d, %d)", pszLayerNameEscaped, pszGeomColEscaped, pszGeometryType, ( poLayer->GetGeomType() & wkb25DBit ) ? "XYZ" : "XY", nSRSId, bCreateSpatialIndex ); } } #endif // HAVE_SPATIALITE sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL ); #ifdef HAVE_SPATIALITE /* -------------------------------------------------------------------- */ /* Should we create a spatial index ?. */ /* -------------------------------------------------------------------- */ if( !bSpatialiteDB || !bCreateSpatialIndex ) continue; CPLDebug("SQLITE", "Create spatial index %s", osIdxNameRaw.c_str()); /* ENABLE_VIRTUAL_OGR_SPATIAL_INDEX is not defined */ #ifdef ENABLE_VIRTUAL_OGR_SPATIAL_INDEX osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" USING " "VirtualOGRSpatialIndex(%d, '%s', pkid, xmin, xmax, ymin, ymax)", osIdxNameEscaped.c_str(), nExtraDS, OGRSQLiteEscape(oLayerDesc.osLayerName).c_str()); rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL ); if( rc != SQLITE_OK ) { CPLDebug("SQLITE", "Error occured during spatial index creation : %s", sqlite3_errmsg(hDB)); } #else // ENABLE_VIRTUAL_OGR_SPATIAL_INDEX rc = sqlite3_exec( hDB, "BEGIN", NULL, NULL, NULL ); osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" " "USING rtree(pkid, xmin, xmax, ymin, ymax)", osIdxNameEscaped.c_str()); if( rc == SQLITE_OK ) rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL ); sqlite3_stmt *hStmt = NULL; if( rc == SQLITE_OK ) { const char* pszInsertInto = CPLSPrintf( "INSERT INTO \"%s\" (pkid, xmin, xmax, ymin, ymax) " "VALUES (?,?,?,?,?)", osIdxNameEscaped.c_str()); rc = sqlite3_prepare(hDB, pszInsertInto, -1, &hStmt, NULL); } OGRFeature* poFeature; OGREnvelope sEnvelope; OGR2SQLITE_IgnoreAllFieldsExceptGeometry(poLayer); poLayer->ResetReading(); while( rc == SQLITE_OK && (poFeature = poLayer->GetNextFeature()) != NULL ) { OGRGeometry* poGeom = poFeature->GetGeometryRef(); if( poGeom != NULL && !poGeom->IsEmpty() ) { poGeom->getEnvelope(&sEnvelope); sqlite3_bind_int64(hStmt, 1, (sqlite3_int64) poFeature->GetFID() ); sqlite3_bind_double(hStmt, 2, sEnvelope.MinX); sqlite3_bind_double(hStmt, 3, sEnvelope.MaxX); sqlite3_bind_double(hStmt, 4, sEnvelope.MinY); sqlite3_bind_double(hStmt, 5, sEnvelope.MaxY); rc = sqlite3_step(hStmt); if( rc == SQLITE_OK || rc == SQLITE_DONE ) rc = sqlite3_reset(hStmt); } delete poFeature; } poLayer->SetIgnoredFields(NULL); sqlite3_finalize(hStmt); if( rc == SQLITE_OK ) rc = sqlite3_exec( hDB, "COMMIT", NULL, NULL, NULL ); else { CPLDebug("SQLITE", "Error occured during spatial index creation : %s", sqlite3_errmsg(hDB)); rc = sqlite3_exec( hDB, "ROLLBACK", NULL, NULL, NULL ); } #endif // ENABLE_VIRTUAL_OGR_SPATIAL_INDEX #endif // HAVE_SPATIALITE } /* -------------------------------------------------------------------- */ /* Reload, so that virtual tables are recognized */ /* -------------------------------------------------------------------- */ poSQLiteDS->ReloadLayers(); /* -------------------------------------------------------------------- */ /* Prepare the statement. */ /* -------------------------------------------------------------------- */ /* This will speed-up layer creation */ /* ORDER BY are costly to evaluate and are not necessary to establish */ /* the layer definition. */ int bUseStatementForGetNextFeature = TRUE; int bEmptyLayer = FALSE; sqlite3_stmt *hSQLStmt = NULL; int rc = sqlite3_prepare( hDB, pszStatement, strlen(pszStatement), &hSQLStmt, NULL ); if( rc != SQLITE_OK ) { CPLError( CE_Failure, CPLE_AppDefined, "In ExecuteSQL(): sqlite3_prepare(%s):\n %s", pszStatement, sqlite3_errmsg(hDB) ); if( hSQLStmt != NULL ) { sqlite3_finalize( hSQLStmt ); } delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } /* -------------------------------------------------------------------- */ /* Do we get a resultset? */ /* -------------------------------------------------------------------- */ rc = sqlite3_step( hSQLStmt ); if( rc != SQLITE_ROW ) { if ( rc != SQLITE_DONE ) { CPLError( CE_Failure, CPLE_AppDefined, "In ExecuteSQL(): sqlite3_step(%s):\n %s", pszStatement, sqlite3_errmsg(hDB) ); sqlite3_finalize( hSQLStmt ); delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } if( !EQUALN(pszStatement, "SELECT ", 7) ) { sqlite3_finalize( hSQLStmt ); delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } bUseStatementForGetNextFeature = FALSE; bEmptyLayer = TRUE; } /* -------------------------------------------------------------------- */ /* Create layer. */ /* -------------------------------------------------------------------- */ OGRSQLiteSelectLayer *poLayer = NULL; poLayer = new OGRSQLiteExecuteSQLLayer( pszTmpDBName, poSQLiteDS, pszStatement, hSQLStmt, bUseStatementForGetNextFeature, bEmptyLayer ); if( poSpatialFilter != NULL ) poLayer->SetSpatialFilter( poSpatialFilter ); return poLayer; } /************************************************************************/ /* OGRSQLiteGetReferencedLayers() */ /************************************************************************/ std::set<LayerDesc> OGRSQLiteGetReferencedLayers(const char* pszStatement) { /* -------------------------------------------------------------------- */ /* Analysze the statement to determine which tables will be used. */ /* -------------------------------------------------------------------- */ std::set<LayerDesc> oSetLayers; std::set<CPLString> oSetSpatialIndex; CPLString osModifiedSQL; OGR2SQLITEGetPotentialLayerNames(pszStatement, oSetLayers, oSetSpatialIndex, osModifiedSQL); return oSetLayers; }
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(); }
OGRLayer * OGRDataSource::ExecuteSQL( const char *pszStatement, OGRGeometry *poSpatialFilter, const char *pszDialect ) { const char *pszError; swq_select *psSelectInfo = NULL; (void) pszDialect; swq_field_list sFieldList; int nFIDIndex = 0; OGRGenSQLResultsLayer *poResults = NULL; memset( &sFieldList, 0, sizeof(sFieldList) ); /* -------------------------------------------------------------------- */ /* Handle CREATE INDEX statements specially. */ /* -------------------------------------------------------------------- */ if( EQUALN(pszStatement,"CREATE INDEX",12) ) { ProcessSQLCreateIndex( pszStatement ); return NULL; } /* -------------------------------------------------------------------- */ /* Handle DROP INDEX statements specially. */ /* -------------------------------------------------------------------- */ if( EQUALN(pszStatement,"DROP INDEX",10) ) { ProcessSQLDropIndex( pszStatement ); return NULL; } /* -------------------------------------------------------------------- */ /* Preparse the SQL statement. */ /* -------------------------------------------------------------------- */ pszError = swq_select_preparse( pszStatement, &psSelectInfo ); if( pszError != NULL ) { CPLError( CE_Failure, CPLE_AppDefined, "SQL: %s", pszError ); return NULL; } /* -------------------------------------------------------------------- */ /* Validate that all the source tables are recognised, count */ /* fields. */ /* -------------------------------------------------------------------- */ int nFieldCount = 0, iTable, iField; int iEDS; int nExtraDSCount = 0; OGRDataSource** papoExtraDS = NULL; OGRSFDriverRegistrar *poReg=OGRSFDriverRegistrar::GetRegistrar(); for( iTable = 0; iTable < psSelectInfo->table_count; iTable++ ) { swq_table_def *psTableDef = psSelectInfo->table_defs + iTable; OGRLayer *poSrcLayer; OGRDataSource *poTableDS = this; if( psTableDef->data_source != NULL ) { poTableDS = (OGRDataSource *) OGROpenShared( psTableDef->data_source, FALSE, NULL ); if( poTableDS == NULL ) { if( strlen(CPLGetLastErrorMsg()) == 0 ) CPLError( CE_Failure, CPLE_AppDefined, "Unable to open secondary datasource\n" "`%s' required by JOIN.", psTableDef->data_source ); swq_select_free( psSelectInfo ); goto end; } /* Keep in an array to release at the end of this function */ papoExtraDS = (OGRDataSource** )CPLRealloc(papoExtraDS, sizeof(OGRDataSource*) * (nExtraDSCount + 1)); papoExtraDS[nExtraDSCount++] = poTableDS; } poSrcLayer = poTableDS->GetLayerByName( psTableDef->table_name ); if( poSrcLayer == NULL ) { CPLError( CE_Failure, CPLE_AppDefined, "SELECT from table %s failed, no such table/featureclass.", psTableDef->table_name ); swq_select_free( psSelectInfo ); goto end; } nFieldCount += poSrcLayer->GetLayerDefn()->GetFieldCount(); } /* -------------------------------------------------------------------- */ /* Build the field list for all indicated tables. */ /* -------------------------------------------------------------------- */ sFieldList.table_count = psSelectInfo->table_count; sFieldList.table_defs = psSelectInfo->table_defs; sFieldList.count = 0; sFieldList.names = (char **) CPLMalloc( sizeof(char *) * (nFieldCount+SPECIAL_FIELD_COUNT) ); sFieldList.types = (swq_field_type *) CPLMalloc( sizeof(swq_field_type) * (nFieldCount+SPECIAL_FIELD_COUNT) ); sFieldList.table_ids = (int *) CPLMalloc( sizeof(int) * (nFieldCount+SPECIAL_FIELD_COUNT) ); sFieldList.ids = (int *) CPLMalloc( sizeof(int) * (nFieldCount+SPECIAL_FIELD_COUNT) ); for( iTable = 0; iTable < psSelectInfo->table_count; iTable++ ) { swq_table_def *psTableDef = psSelectInfo->table_defs + iTable; OGRDataSource *poTableDS = this; OGRLayer *poSrcLayer; if( psTableDef->data_source != NULL ) { poTableDS = (OGRDataSource *) OGROpenShared( psTableDef->data_source, FALSE, NULL ); CPLAssert( poTableDS != NULL ); poTableDS->Dereference(); } poSrcLayer = poTableDS->GetLayerByName( psTableDef->table_name ); for( iField = 0; iField < poSrcLayer->GetLayerDefn()->GetFieldCount(); iField++ ) { OGRFieldDefn *poFDefn=poSrcLayer->GetLayerDefn()->GetFieldDefn(iField); int iOutField = sFieldList.count++; sFieldList.names[iOutField] = (char *) poFDefn->GetNameRef(); if( poFDefn->GetType() == OFTInteger ) sFieldList.types[iOutField] = SWQ_INTEGER; else if( poFDefn->GetType() == OFTReal ) sFieldList.types[iOutField] = SWQ_FLOAT; else if( poFDefn->GetType() == OFTString ) sFieldList.types[iOutField] = SWQ_STRING; else sFieldList.types[iOutField] = SWQ_OTHER; sFieldList.table_ids[iOutField] = iTable; sFieldList.ids[iOutField] = iField; } if( iTable == 0 ) nFIDIndex = poSrcLayer->GetLayerDefn()->GetFieldCount(); } /* -------------------------------------------------------------------- */ /* Expand '*' in 'SELECT *' now before we add the pseudo fields */ /* -------------------------------------------------------------------- */ pszError = swq_select_expand_wildcard( psSelectInfo, &sFieldList ); if( pszError != NULL ) { swq_select_free( psSelectInfo ); CPLError( CE_Failure, CPLE_AppDefined, "SQL: %s", pszError ); goto end; } for (iField = 0; iField < SPECIAL_FIELD_COUNT; iField++) { sFieldList.names[sFieldList.count] = (char*) SpecialFieldNames[iField]; sFieldList.types[sFieldList.count] = SpecialFieldTypes[iField]; sFieldList.table_ids[sFieldList.count] = 0; sFieldList.ids[sFieldList.count] = nFIDIndex + iField; sFieldList.count++; } /* -------------------------------------------------------------------- */ /* Finish the parse operation. */ /* -------------------------------------------------------------------- */ pszError = swq_select_parse( psSelectInfo, &sFieldList, 0 ); if( pszError != NULL ) { swq_select_free( psSelectInfo ); CPLError( CE_Failure, CPLE_AppDefined, "SQL: %s", pszError ); goto end; } /* -------------------------------------------------------------------- */ /* Everything seems OK, try to instantiate a results layer. */ /* -------------------------------------------------------------------- */ poResults = new OGRGenSQLResultsLayer( this, psSelectInfo, poSpatialFilter ); // Eventually, we should keep track of layers to cleanup. end: CPLFree( sFieldList.names ); CPLFree( sFieldList.types ); CPLFree( sFieldList.table_ids ); CPLFree( sFieldList.ids ); /* Release the datasets we have opened with OGROpenShared() */ /* It is safe to do that as the 'new OGRGenSQLResultsLayer' itself */ /* has taken a reference on them, which it will release in its */ /* destructor */ for(iEDS = 0; iEDS < nExtraDSCount; iEDS++) poReg->ReleaseDataSource( papoExtraDS[iEDS] ); CPLFree(papoExtraDS); return poResults; }
OGRLayer * OGRSQLiteExecuteSQL( GDALDataset* poDS, const char *pszStatement, OGRGeometry *poSpatialFilter, CPL_UNUSED const char *pszDialect ) { char* pszTmpDBName = (char*) CPLMalloc(256); snprintf(pszTmpDBName, 256, "/vsimem/ogr2sqlite/temp_%p.db", pszTmpDBName); OGRSQLiteDataSource* poSQLiteDS = NULL; int nRet; int bSpatialiteDB = FALSE; CPLString osOldVal; const char* pszOldVal = CPLGetConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", NULL); if( pszOldVal != NULL ) { osOldVal = pszOldVal; pszOldVal = osOldVal.c_str(); } /* -------------------------------------------------------------------- */ /* Create in-memory sqlite/spatialite DB */ /* -------------------------------------------------------------------- */ #ifdef HAVE_SPATIALITE /* -------------------------------------------------------------------- */ /* Creating an empty SpatiaLite DB (with spatial_ref_sys populated */ /* has a significant cost. So at the first attempt, let's make */ /* one and cache it for later use. */ /* -------------------------------------------------------------------- */ #if 1 static size_t nEmptyDBSize = 0; static GByte* pabyEmptyDB = NULL; { static CPLMutex* hMutex = NULL; CPLMutexHolder oMutexHolder(&hMutex); static int bTried = FALSE; if( !bTried && CPLTestBool(CPLGetConfigOption("OGR_SQLITE_DIALECT_USE_SPATIALITE", "YES")) ) { bTried = TRUE; char* pszCachedFilename = (char*) CPLMalloc(256); snprintf(pszCachedFilename, 256, "/vsimem/ogr2sqlite/reference_%p.db", pszCachedFilename); char** papszOptions = CSLAddString(NULL, "SPATIALITE=YES"); OGRSQLiteDataSource* poCachedDS = new OGRSQLiteDataSource(); nRet = poCachedDS->Create( pszCachedFilename, papszOptions ); CSLDestroy(papszOptions); papszOptions = NULL; delete poCachedDS; if( nRet ) { /* Note: the reference file keeps the ownership of the data, so that */ /* it gets released with VSICleanupFileManager() */ vsi_l_offset nEmptyDBSizeLarge = 0; pabyEmptyDB = VSIGetMemFileBuffer( pszCachedFilename, &nEmptyDBSizeLarge, FALSE ); nEmptyDBSize = static_cast<size_t>(nEmptyDBSizeLarge); } CPLFree( pszCachedFilename ); } } /* The following configuration option is useful mostly for debugging/testing */ if( pabyEmptyDB != NULL && CPLTestBool(CPLGetConfigOption("OGR_SQLITE_DIALECT_USE_SPATIALITE", "YES")) ) { GByte* pabyEmptyDBClone = (GByte*)VSI_MALLOC_VERBOSE(nEmptyDBSize); if( pabyEmptyDBClone == NULL ) { CPLFree(pszTmpDBName); return NULL; } memcpy(pabyEmptyDBClone, pabyEmptyDB, nEmptyDBSize); VSIFCloseL(VSIFileFromMemBuffer( pszTmpDBName, pabyEmptyDBClone, nEmptyDBSize, TRUE )); poSQLiteDS = new OGRSQLiteDataSource(); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO"); nRet = poSQLiteDS->Open( pszTmpDBName, TRUE, NULL ); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal); if( !nRet ) { /* should not happen really ! */ delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } bSpatialiteDB = TRUE; } #else /* No caching version */ poSQLiteDS = new OGRSQLiteDataSource(); char** papszOptions = CSLAddString(NULL, "SPATIALITE=YES"); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO"); nRet = poSQLiteDS->Create( pszTmpDBName, papszOptions ); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal); CSLDestroy(papszOptions); papszOptions = NULL; if( nRet ) { bSpatialiteDB = TRUE; } #endif else { delete poSQLiteDS; poSQLiteDS = NULL; #else // HAVE_SPATIALITE if( true ) { #endif // HAVE_SPATIALITE poSQLiteDS = new OGRSQLiteDataSource(); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO"); nRet = poSQLiteDS->Create( pszTmpDBName, NULL ); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal); if( !nRet ) { delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } } /* -------------------------------------------------------------------- */ /* Attach the Virtual Table OGR2SQLITE module to it. */ /* -------------------------------------------------------------------- */ OGR2SQLITEModule* poModule = OGR2SQLITE_Setup(poDS, poSQLiteDS); sqlite3* hDB = poSQLiteDS->GetDB(); /* -------------------------------------------------------------------- */ /* Analysze the statement to determine which tables will be used. */ /* -------------------------------------------------------------------- */ std::set<LayerDesc> oSetLayers; std::set<CPLString> oSetSpatialIndex; CPLString osModifiedSQL; OGR2SQLITEGetPotentialLayerNames(pszStatement, oSetLayers, oSetSpatialIndex, osModifiedSQL); std::set<LayerDesc>::iterator oIter = oSetLayers.begin(); if( strcmp(pszStatement, osModifiedSQL.c_str()) != 0 ) CPLDebug("OGR", "Modified SQL: %s", osModifiedSQL.c_str()); pszStatement = osModifiedSQL.c_str(); /* do not use it anymore */ int bFoundOGRStyle = ( osModifiedSQL.ifind("OGR_STYLE") != std::string::npos ); /* -------------------------------------------------------------------- */ /* For each of those tables, create a Virtual Table. */ /* -------------------------------------------------------------------- */ OGRLayer* poSingleSrcLayer = NULL; for(; oIter != oSetLayers.end(); ++oIter) { const LayerDesc& oLayerDesc = *oIter; /*CPLDebug("OGR", "Layer desc : %s, %s, %s, %s", oLayerDesc.osOriginalStr.c_str(), oLayerDesc.osSubstitutedName.c_str(), oLayerDesc.osDSName.c_str(), oLayerDesc.osLayerName.c_str());*/ CPLString osSQL; OGRLayer* poLayer = NULL; CPLString osTableName; int nExtraDS; if( oLayerDesc.osDSName.size() == 0 ) { poLayer = poDS->GetLayerByName(oLayerDesc.osLayerName); /* Might be a false positive (unlikely) */ if( poLayer == NULL ) continue; osTableName = oLayerDesc.osLayerName; nExtraDS = -1; } else { OGRDataSource* poOtherDS = (OGRDataSource* ) OGROpen(oLayerDesc.osDSName, FALSE, NULL); if( poOtherDS == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot open datasource '%s'", oLayerDesc.osDSName.c_str() ); delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } poLayer = poOtherDS->GetLayerByName(oLayerDesc.osLayerName); if( poLayer == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot find layer '%s' in '%s'", oLayerDesc.osLayerName.c_str(), oLayerDesc.osDSName.c_str() ); delete poOtherDS; delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } osTableName = oLayerDesc.osSubstitutedName; nExtraDS = OGR2SQLITE_AddExtraDS(poModule, poOtherDS); } if( oSetLayers.size() == 1 ) poSingleSrcLayer = poLayer; osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" USING VirtualOGR(%d,'%s',%d,%d)", OGRSQLiteEscapeName(osTableName).c_str(), nExtraDS, OGRSQLiteEscape(oLayerDesc.osLayerName).c_str(), bFoundOGRStyle, TRUE/*bExposeOGRNativeData*/); char* pszErrMsg = NULL; int rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, &pszErrMsg ); if( rc != SQLITE_OK ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot create virtual table for layer '%s' : %s", osTableName.c_str(), pszErrMsg); sqlite3_free(pszErrMsg); continue; } for(int i=0; i<poLayer->GetLayerDefn()->GetGeomFieldCount(); i++) { OGR2SQLITEDealWithSpatialColumn(poLayer, i, oLayerDesc, osTableName, poSQLiteDS, hDB, bSpatialiteDB, oSetLayers, oSetSpatialIndex); } } /* -------------------------------------------------------------------- */ /* Reload, so that virtual tables are recognized */ /* -------------------------------------------------------------------- */ poSQLiteDS->ReloadLayers(); /* -------------------------------------------------------------------- */ /* Prepare the statement. */ /* -------------------------------------------------------------------- */ /* This will speed-up layer creation */ /* ORDER BY are costly to evaluate and are not necessary to establish */ /* the layer definition. */ int bUseStatementForGetNextFeature = TRUE; int bEmptyLayer = FALSE; sqlite3_stmt *hSQLStmt = NULL; int rc = sqlite3_prepare( hDB, pszStatement, -1, &hSQLStmt, NULL ); if( rc != SQLITE_OK ) { CPLError( CE_Failure, CPLE_AppDefined, "In ExecuteSQL(): sqlite3_prepare(%s):\n %s", pszStatement, sqlite3_errmsg(hDB) ); if( hSQLStmt != NULL ) { sqlite3_finalize( hSQLStmt ); } delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } /* -------------------------------------------------------------------- */ /* Do we get a resultset? */ /* -------------------------------------------------------------------- */ rc = sqlite3_step( hSQLStmt ); if( rc != SQLITE_ROW ) { if ( rc != SQLITE_DONE ) { CPLError( CE_Failure, CPLE_AppDefined, "In ExecuteSQL(): sqlite3_step(%s):\n %s", pszStatement, sqlite3_errmsg(hDB) ); sqlite3_finalize( hSQLStmt ); delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } if( !STARTS_WITH_CI(pszStatement, "SELECT ") ) { sqlite3_finalize( hSQLStmt ); delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } bUseStatementForGetNextFeature = FALSE; bEmptyLayer = TRUE; } /* -------------------------------------------------------------------- */ /* Create layer. */ /* -------------------------------------------------------------------- */ OGRSQLiteSelectLayer *poLayer = NULL; poLayer = new OGRSQLiteExecuteSQLLayer( pszTmpDBName, poSQLiteDS, pszStatement, hSQLStmt, bUseStatementForGetNextFeature, bEmptyLayer ); if( poSpatialFilter != NULL ) poLayer->SetSpatialFilter( 0, poSpatialFilter ); if( poSingleSrcLayer != NULL ) poLayer->SetMetadata( poSingleSrcLayer->GetMetadata( "NATIVE_DATA" ), "NATIVE_DATA" ); return poLayer; } /************************************************************************/ /* OGRSQLiteGetReferencedLayers() */ /************************************************************************/ std::set<LayerDesc> OGRSQLiteGetReferencedLayers(const char* pszStatement) { /* -------------------------------------------------------------------- */ /* Analysze the statement to determine which tables will be used. */ /* -------------------------------------------------------------------- */ std::set<LayerDesc> oSetLayers; std::set<CPLString> oSetSpatialIndex; CPLString osModifiedSQL; OGR2SQLITEGetPotentialLayerNames(pszStatement, oSetLayers, oSetSpatialIndex, osModifiedSQL); return oSetLayers; }
void DrawShape::featuredetect(int XPoint,int YPoint) { if(!sfile.empty() && XPoint>=(x_pos_shift-increase_width/2)*6.40 && XPoint<=(x_pos_shift-increase_width/2)*6.40+(100+increase_width)*6.4 && YPoint>=(y_pos_shift-increase_height/2)*4.8 && YPoint<=(y_pos_shift-increase_height/2)*4.8+(100+increase_height)*4.8 )//check if point is inside the view area { OGRDataSource *poDS; string dfile = sfile + ".shp"; string shp = "g_4326/" + sfile + ".shp"; poDS = OGRSFDriverRegistrar::Open(shp.c_str(), FALSE ); //comment till here if( poDS == NULL ) { WApplication::instance()->doJavaScript("alert('Open failed')"); cout << "Open failed"; } OGRLayer *poLayer; poLayer = poDS->GetLayerByName( sfile.c_str() ); // comment here OGRFeature *poFeature; OGREnvelope * psExtent = new OGREnvelope(); poLayer->GetExtent(psExtent); double xMin = psExtent->MinX; double yMin = psExtent->MinY; double xMax = psExtent->MaxX; double yMax = psExtent->MaxY; stringstream strm; strm << xMin; string exp; double scaleFactor; string bound_string = strm.str(); int size = bound_string.size(); size_t found=bound_string.find("+"); if (found!=string::npos) { exp = bound_string.substr(found+1,size); } if(exp.empty()) { stringstream strExtent; strExtent << yMin; bound_string = strExtent.str(); size = bound_string.size(); found = bound_string.find("+"); if(found!=string::npos) { exp = bound_string.substr(found+1,size); } } if(exp.empty()) { stringstream strExtent; strExtent << xMax; bound_string = strExtent.str(); size = bound_string.size(); found = bound_string.find("+"); if(found!=string::npos) { exp = bound_string.substr(found+1,size); } } if(exp.empty()) { stringstream strExtent; strExtent << yMax; bound_string = strExtent.str(); size = bound_string.size(); found = bound_string.find("+"); if(found!=string::npos) { exp = bound_string.substr(found+1,size); } } if(!exp.empty()) { int exponent = boost::lexical_cast<int>(exp); exponent-=3; scaleFactor = pow (10,exponent); } else { scaleFactor = 1; } xMin/=scaleFactor; xMax/=scaleFactor; yMin/=scaleFactor; yMax/=scaleFactor; double gWidth = xMax - xMin; double gHeight = yMax - yMin; double widthFactor = 1; double pwidth = abs(gWidth-gHeight); double s = gWidth - gHeight; if(s<0.16) gWidth = gHeight + 0.16; double scaledX=(XPoint*(gWidth* widthFactor*(100-increase_width)/100)/640 + (xMin+(-x_pos_shift+increase_width/2)/100*gWidth* widthFactor))*scaleFactor; double scaledY=(YPoint*(gHeight*widthFactor*(-1+increase_height/100))/480 + (yMax+(y_pos_shift-increase_height/2)/100*gHeight*widthFactor))*scaleFactor; OGRPoint *poPoint =new OGRPoint(); poPoint->setX(scaledX); poPoint->setY(scaledY); poLayer->ResetReading(); int index=0;bool flagFeature=false; while( (poFeature = poLayer->GetNextFeature()) != NULL ) { OGRGeometry *poGeometry; poGeometry = poFeature->GetGeometryRef(); if(poGeometry->Distance(poPoint)/scaleFactor<=0.01*gWidth*widthFactor) { flagFeature=true; //std::cerr<<index<<" " <<flagFeature<<" "<<poGeometry->Distance(poPoint); break; } index++; } if(flagFeature) DBFDialog *attrtable =new DBFDialog(cfile,sfile,flagFeature,index); } }
void readQuadIndex(int series, QString file, QString layerName, Projection *pj) { OGRDataSource *ds = OGRSFDriverRegistrar::Open(file.toLatin1().data(), false); if (!ds) { fprintf(stderr, "Could not open quad index '%s'.\n", file.toLatin1().data()); exit(-1); } OGRLayer *layer; layer = ds->GetLayerByName(layerName.toLatin1().data()); if (!layer) { fprintf(stderr, "Could not read layer '%s'.\n", layerName.toLatin1().data()); exit(-1); } OGRSpatialReference *srs = layer->GetSpatialRef(); if (!srs) { fprintf(stderr, "Missing spatial reference for layer '%s'.\n", layerName.toLatin1().data()); exit(-1); } char *proj = NULL; srs->exportToProj4(&proj); if (!proj) { fprintf(stderr, "Error computing PROJ4 spatial reference for layer '%s'.\n", layerName.toLatin1().data()); exit(-1); } Projection pjIndex(proj); CPLFree(proj); layer->ResetReading(); OGRFeatureDefn *def = layer->GetLayerDefn(); int idFieldNr = def->GetFieldIndex("ID"); int nameFieldNr = def->GetFieldIndex("NAME"); if (idFieldNr < 0 || nameFieldNr < 0) { fprintf(stderr, "Missing index layer fields.\n"); exit(-1); } OGRFeature *f; while ((f = layer->GetNextFeature()) != NULL) { QString id(f->GetFieldAsString(idFieldNr)); QString name(f->GetFieldAsString(nameFieldNr)); // printf("Quad id: %s; name: %s\n", id.toLatin1().data(), name.toLatin1().data()); OGRGeometry *g; g = f->GetGeometryRef(); if (g != NULL && wkbFlatten(g->getGeometryType()) == wkbPolygon) { OGRPolygon *p = (OGRPolygon *)g; OGRLinearRing *r = p->getExteriorRing(); if (!r) { fprintf(stderr, "Quad has no exterior polygon ring %s\n", id.toLatin1().data()); continue; } int size = r->getNumPoints(); QPolygonF boundary; for (int i = 0; i < size; i++) { OGRPoint p; r->getPoint(i, &p); boundary << QPointF(p.getX(), p.getY()); } QPolygonF projBoundary = pj->transformFrom(&pjIndex, boundary); quads[id] = Quad(series, id, name, projBoundary); } else { fprintf(stderr, "Missing or invalid geometry for quad %s\n", id.toLatin1().data()); } } OGRDataSource::DestroyDataSource(ds); }
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; }
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; }
bool MapWidget::loadCountyShapes() { OGRRegisterAll(); std::string filename = g_dataDirectory + "/counties/tl_2009_48_county00.shp"; OGRDataSource * dataSource = OGRSFDriverRegistrar::Open(filename.c_str(), false); if(dataSource == NULL) { put_flog(LOG_ERROR, "could not open %s", filename.c_str()); return false; } OGRLayer * layer = dataSource->GetLayerByName("tl_2009_48_county00"); layer->ResetReading(); OGRFeature * feature; while((feature = layer->GetNextFeature()) != NULL) { // get county FIPS code int nodeId = feature->GetFieldAsInteger("COUNTYFP00"); if(nodeId == 0) { put_flog(LOG_WARN, "invalid county"); } // add a new county to the counties map corresponding to this nodeId boost::shared_ptr<MapShape> county(new MapShape()); counties_[nodeId] = county; OGRGeometry * geometry = feature->GetGeometryRef(); if(geometry != NULL && geometry->getGeometryType() == wkbPolygon) { OGRPolygon * polygon = (OGRPolygon *)geometry; OGRLinearRing * ring = polygon->getExteriorRing(); for(int i=0; i<ring->getNumPoints(); i++) { // x is longitude, y latitude county->addVertex(ring->getY(i), ring->getX(i)); } // set the centroid OGRPoint centroidPoint; if(polygon->Centroid(¢roidPoint) == OGRERR_NONE) { county->setCentroid(centroidPoint.getY(), centroidPoint.getX()); } else { put_flog(LOG_WARN, "no polygon centroid"); } } else { put_flog(LOG_WARN, "no polygon geometry"); } OGRFeature::DestroyFeature(feature); } OGRDataSource::DestroyDataSource(dataSource); return true; }
void DataCvt_Log::CalAsShp() { double ptmptime_start = MPI_Wtime(); OGRRegisterAll(); //create a new shp to caculate CBaseOperate pbaseOperate; if(rankid==0) { pbaseOperate.CreateCopyShp(m_DatasourceConStr.c_str(),m_PathOrTableName.c_str(),m_ResultPathOrTableName.c_str()); } MPI_Barrier(MPI_COMM_WORLD); string pLayerName = m_ResultPathOrTableName; if(strcmp(m_DatasourceConStr.c_str(),"")==0)//input is shp file { m_DatasourceConStr = m_ResultPathOrTableName; string pShpPath = m_ResultPathOrTableName; string p_LayerName = GetFileNameOnly(pShpPath.c_str()); int pindex = p_LayerName.find_first_of('.'); pLayerName = p_LayerName.erase(pindex,p_LayerName.size()-1); } OGRDataSource* poDS = OGRSFDriverRegistrar::Open(m_DatasourceConStr.c_str(),TRUE); OGRLayer* poLayer = poDS->GetLayerByName(pLayerName.c_str()); OGRFeature * pFeature =poLayer->GetNextFeature(); m_RowNum = poLayer->GetFeatureCount(); //if -c argv is null, all field will be used m_ColNum= pFeature->GetFieldCount(); if(c_CaculateCols.size()==0) { if(rankid==0) cout<<"!!!!!!! No input columns ids, all fields in the input file will be used..."<<endl<<endl; for(int i=0;i<m_ColNum;i++) { c_CaculateCols.push_back(i); } } double ptmptime_end = MPI_Wtime(); m_GdalIOInCal_Time=m_GdalIOInCal_Time+ptmptime_end-ptmptime_start; //assign number to each process int pnum_start,pnum_end; int pMyProcessNum=0; int pRemainder=m_RowNum%numproc; if(rankid<pRemainder) { pMyProcessNum = m_RowNum/numproc+1; pnum_start = rankid*pMyProcessNum; pnum_end = pnum_start+pMyProcessNum-1; } else { pMyProcessNum = m_RowNum/numproc; pnum_start = pRemainder*(pMyProcessNum+1)+(rankid-pRemainder)*pMyProcessNum; pnum_end = pnum_start+pMyProcessNum-1; } //postgis: fid begins from 1, not 0 string pwhere=""; if(strcmp(m_DatasourceConStr.substr(0,3).c_str(),"PG:")==0)//input is postgis { pwhere = "gid>="+toString(pnum_start+1)+" and gid<="+toString(pnum_end+1); } else//shpfile: fid begins from 0, not 1 { pwhere = "fid>="+toString(pnum_start)+" and fid<="+toString(pnum_end); } poLayer->SetAttributeFilter(pwhere.c_str()); pFeature = poLayer->GetNextFeature(); while(pFeature!=NULL) { for(int i=0;i<c_CaculateCols.size();i++) { double tmp = pFeature->GetFieldAsDouble(c_CaculateCols[i]); if(tmp!=0) tmp = log(fabs(tmp)); else tmp=0; double pstart = MPI_Wtime(); pFeature->SetField(c_CaculateCols[i],tmp); poLayer->SetFeature(pFeature); double pend = MPI_Wtime(); m_GdalIOInCal_Time = m_GdalIOInCal_Time+pend-pstart; } pFeature = poLayer->GetNextFeature(); } OGRDataSource::DestroyDataSource( poDS ); double ptmptime_endall = MPI_Wtime(); Mpi_Caculate_Time = ptmptime_endall-ptmptime_start-m_GdalIOInCal_Time; double tmp=Mpi_Caculate_Time; MPI_Reduce(&Mpi_Caculate_Time,&tmp,1,MPI_DOUBLE,MPI_MIN,0,MPI_COMM_WORLD); Mpi_Caculate_Time = tmp; }
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; }
bool CStakeInfo::Load() { OGRRegisterAll(); OGRDataSource* poDataSource = NULL; poDataSource = OGRSFDriverRegistrar::Open(m_strPath.c_str()); if (poDataSource == NULL) { printf("Open file faild [%s]", m_strPath.c_str()); return false; } OGRLayer *poLayer; OGRFeature *poFeature; poLayer = poDataSource->GetLayerByName(CPLGetBasename(m_strPath.c_str())); poLayer->ResetReading(); while ((poFeature = poLayer->GetNextFeature()) != NULL) { StakeInfo stStakeInfo; try { stStakeInfo.routeID = poFeature->GetFieldAsString("RD_NAME"); stStakeInfo.lLinkID = poFeature->GetFieldAsInteger("LINKID"); stStakeInfo.dcoord.Lat = poFeature->GetFieldAsDouble("XSWD"); stStakeInfo.dcoord.Lon = poFeature->GetFieldAsDouble("XSJD"); #ifdef ONLY_STAKE_DATA stStakeInfo.strRouteName = poFeature->GetFieldAsString("LXMC"); stStakeInfo.iDir = poFeature->GetFieldAsInteger("SXX"); stStakeInfo.stakeID = atoi(poFeature->GetFieldAsString("LCZ")); #else stStakeInfo.stakeID = (int)poFeature->GetFieldAsDouble("LCZ"); #endif // auto itWay = m_mapStakeInfo.find(stStakeInfo.routeID); if (itWay != m_mapStakeInfo.end()) { std::map<long long, std::vector<StakeInfo>>& mapStakeLink = itWay->second; auto itLink = mapStakeLink.find(stStakeInfo.lLinkID); if (itLink != mapStakeLink.end()) { std::vector<StakeInfo>& vecStakeInfo = itLink->second; for (int ii = 0;ii < vecStakeInfo.size(); ii++) { if (vecStakeInfo[ii].stakeID == stStakeInfo.stakeID) { auto itStake = vecStakeInfo.begin(); itStake += ii; vecStakeInfo.erase(itStake); } } vecStakeInfo.push_back(stStakeInfo); } else { std::vector<StakeInfo> vecStakeInfo; mapStakeLink.insert(std::pair<long long, std::vector<StakeInfo>>(stStakeInfo.lLinkID, vecStakeInfo)); itLink = mapStakeLink.find(stStakeInfo.lLinkID); itLink->second.push_back(stStakeInfo); } } else { std::map<long long, std::vector<StakeInfo>> mapStakeLink; m_mapStakeInfo.insert(std::pair<std::string, std::map<long long, std::vector<StakeInfo>>>( stStakeInfo.routeID, mapStakeLink)); itWay = m_mapStakeInfo.find(stStakeInfo.routeID); std::vector<StakeInfo> vecStakeInfo; itWay->second.insert(std::pair<long long, std::vector<StakeInfo>>(stStakeInfo.lLinkID, vecStakeInfo)); auto itLink = itWay->second.find(stStakeInfo.lLinkID); itLink->second.push_back(stStakeInfo); } } catch (const std::exception&) { return false; } OGRFeature::DestroyFeature(poFeature); } OGRDataSource::DestroyDataSource(poDataSource); return true; }