GNMGFID GNMGenericNetwork::FindNearestPoint(const OGRPoint* poPoint, const std::vector<OGRLayer*>& paPointLayers, double dfTolerance) { VALIDATE_POINTER1(poPoint, "GNMGenericNetwork::FindNearestPoint", -1); double dfMinX = poPoint->getX() - dfTolerance; double dfMinY = poPoint->getY() - dfTolerance; double dfMaxX = poPoint->getX() + dfTolerance; double dfMaxY = poPoint->getY() + dfTolerance; OGRFeature *poFeature; for(size_t i = 0; i < paPointLayers.size(); ++i) { OGRLayer *poLayer = paPointLayers[i]; poLayer->SetSpatialFilterRect(dfMinX, dfMinY, dfMaxX, dfMaxY); poLayer->ResetReading(); while((poFeature = poLayer->GetNextFeature()) != NULL) { GNMGFID nRetFID = poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_GFID); OGRFeature::DestroyFeature(poFeature); return nRetFID; } } return -1; }
OGRSpatialReference* OGRGeomediaDataSource::GetGeomediaSRS(const char* pszGCoordSystemTable, const char* pszGCoordSystemGUID) { if (pszGCoordSystemTable == NULL || pszGCoordSystemGUID == NULL) return NULL; OGRLayer* poGCoordSystemTable = GetLayerByName(pszGCoordSystemTable); if (poGCoordSystemTable == NULL) return NULL; poGCoordSystemTable->ResetReading(); OGRFeature* poFeature; while((poFeature = poGCoordSystemTable->GetNextFeature()) != NULL) { const char* pszCSGUID = poFeature->GetFieldAsString("CSGUID"); if (pszCSGUID && strcmp(pszCSGUID, pszGCoordSystemGUID) == 0) { OGRSpatialReference* poSRS = OGRGetGeomediaSRS(poFeature); delete poFeature; return poSRS; } delete poFeature; } return NULL; }
//本函数返回矢量点的数目 int CGouTIN::read_samplenum(const char* pDataSource,const char* pLayerName,char** pSpatialRefWkt) { //将类CIDW做参数 OGRRegisterAll(); OGRDataSource *poDS=OGRSFDriverRegistrar::Open(pDataSource,FALSE); //OGRDataSource *poDS=OGRSFDriverRegistrar::Open("point.shp",FALSE); if( poDS == NULL ) { printf( "[ERROR] zmw Open failed.\n" ); exit( 1 ); } OGRLayer *poLayer = poDS->GetLayerByName(pLayerName); //cout<<f3.c_str()<<endl; //cout<<"here2"<<endl; //OGRSpatialReference * sref= poLayer->GetSpatialRef(); //sref->exportToWkt(pSpatialRefWkt); //cout<<"here3"<<endl; OGRFeature *poFeature; poLayer->ResetReading(); //cout<<"here4"<<endl; int count = 0;//统计散点数 while((poFeature=poLayer->GetNextFeature())!=NULL) { count++; } OGRDataSource::DestroyDataSource( poDS ); return count; }
int FGdbDataSource::FixIndexes() { int bRet = TRUE; if( m_pConnection && m_pConnection->IsFIDHackInProgress() ) { m_pConnection->CloseGeodatabase(); char* apszDrivers[2]; apszDrivers[0] = (char*) "OpenFileGDB"; apszDrivers[1] = NULL; const char* pszSystemCatalog = CPLFormFilename(m_osFSName, "a00000001.gdbtable", NULL); GDALDataset* poOpenFileGDBDS = (GDALDataset*) GDALOpenEx(pszSystemCatalog, GDAL_OF_VECTOR, apszDrivers, NULL, NULL); if( poOpenFileGDBDS == NULL || poOpenFileGDBDS->GetLayer(0) == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot open %s with OpenFileGDB driver. " "Should not happen. Some layers will be corrupted", pszSystemCatalog); bRet = FALSE; } else { OGRLayer* poLayer = poOpenFileGDBDS->GetLayer(0); size_t count = m_layers.size(); for(size_t i = 0; i < count; ++i ) { if( m_layers[i]->m_oMapOGRFIDToFGDBFID.size() == 0) continue; CPLString osFilter = "name = '"; osFilter += m_layers[i]->GetName(); osFilter += "'"; poLayer->SetAttributeFilter(osFilter); poLayer->ResetReading(); OGRFeature* poF = poLayer->GetNextFeature(); if( poF == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot find filename for layer %s", m_layers[i]->GetName()); bRet = FALSE; } else { if( !m_layers[i]->EditIndexesForFIDHack(CPLFormFilename(m_osFSName, CPLSPrintf("a%08x", (int)poF->GetFID()), NULL)) ) { bRet = FALSE; } } delete poF; } } GDALClose(poOpenFileGDBDS); m_pConnection->SetFIDHackInProgress(FALSE); } return bRet; }
//--------------------------------------------------------- CSG_Shapes * COGR_DataSource::Read_Shapes(int iLayer) { OGRLayer *pLayer = Get_Layer(iLayer); //----------------------------------------------------- if( pLayer && Get_Type(iLayer) != SHAPE_TYPE_Undefined ) { int iField; OGRFeature *pFeature; OGRFeatureDefn *pDef = pLayer->GetLayerDefn(); CSG_Shapes *pShapes = SG_Create_Shapes(Get_Type(iLayer), CSG_String(pDef->GetName())); for(iField=0; iField<pDef->GetFieldCount(); iField++) { OGRFieldDefn *pDefField = pDef->GetFieldDefn(iField); pShapes->Add_Field(pDefField->GetNameRef(), COGR_Driver::Get_Type(pDefField->GetType())); } pLayer->ResetReading(); //------------------------------------------------- while( (pFeature = pLayer->GetNextFeature()) != NULL && SG_UI_Process_Get_Okay(false) ) { OGRGeometry *pGeometry = pFeature->GetGeometryRef(); if( pGeometry != NULL ) { CSG_Shape *pShape = pShapes->Add_Shape(); for(iField=0; iField<pDef->GetFieldCount(); iField++) { OGRFieldDefn *pDefField = pDef->GetFieldDefn(iField); switch( pDefField->GetType() ) { default: pShape->Set_Value(iField, SG_STR_MBTOSG(pFeature->GetFieldAsString (iField))); break; case OFTString: pShape->Set_Value(iField, SG_STR_MBTOSG(pFeature->GetFieldAsString (iField))); break; case OFTInteger: pShape->Set_Value(iField, pFeature->GetFieldAsInteger(iField)); break; case OFTReal: pShape->Set_Value(iField, pFeature->GetFieldAsDouble (iField)); break; } } //----------------------------------------- if( _Read_Geometry(pShape, pGeometry) == false ) { pShapes->Del_Shape(pShape); } } OGRFeature::DestroyFeature(pFeature); } return( pShapes ); } //----------------------------------------------------- return( NULL ); }
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(); } }
static void OGR2SQLITE_ogr_geocode_set_result(sqlite3_context* pContext, OGRLayerH hLayer, const char* pszField) { if( hLayer == NULL ) sqlite3_result_null (pContext); else { OGRLayer* poLayer = (OGRLayer*)hLayer; OGRFeatureDefn* poFDefn = poLayer->GetLayerDefn(); OGRFeature* poFeature = poLayer->GetNextFeature(); int nIdx = -1; if( poFeature == NULL ) sqlite3_result_null (pContext); else if( strcmp(pszField, "geometry") == 0 && poFeature->GetGeometryRef() != NULL ) { GByte* pabyGeomBLOB = NULL; int nGeomBLOBLen = 0; if( OGRSQLiteLayer::ExportSpatiaLiteGeometry( poFeature->GetGeometryRef(), 4326, wkbNDR, FALSE, FALSE, FALSE, &pabyGeomBLOB, &nGeomBLOBLen ) != CE_None ) { sqlite3_result_null (pContext); } else { sqlite3_result_blob (pContext, pabyGeomBLOB, nGeomBLOBLen, CPLFree); } } else if( (nIdx = poFDefn->GetFieldIndex(pszField)) >= 0 && poFeature->IsFieldSet(nIdx) ) { OGRFieldType eType = poFDefn->GetFieldDefn(nIdx)->GetType(); if( eType == OFTInteger ) sqlite3_result_int(pContext, poFeature->GetFieldAsInteger(nIdx)); else if( eType == OFTInteger64 ) sqlite3_result_int64(pContext, poFeature->GetFieldAsInteger64(nIdx)); else if( eType == OFTReal ) sqlite3_result_double(pContext, poFeature->GetFieldAsDouble(nIdx)); else sqlite3_result_text(pContext, poFeature->GetFieldAsString(nIdx), -1, SQLITE_TRANSIENT); } else sqlite3_result_null (pContext); delete poFeature; OGRGeocodeFreeResult(hLayer); } }
bool AoIIntersection::compareIntersectionResults( OGRDataSource *resultData, IntersectionSummary *origSummary ) { bool success = true; IntersectionSummary resultSummary; OGRLayer *resultLayer; resultSummary.numLayers = resultData->GetLayerCount(); if ( resultSummary.numLayers != origSummary->numLayers ) { printf( "Test results: Layer count mismatch.\n" ); success = false; } for (int layerCt = 0; layerCt < resultSummary.numLayers; ++layerCt) { resultLayer = resultData->GetLayer( layerCt ); if ( resultLayer == NULL ) { printf( "Test results: Layer count mismatch.\n" ); success = false; } // get field indices for the fields we wrote int acreIndex = resultLayer->GetLayerDefn()->GetFieldIndex( "Acres in AoI" ); int areaIndex = resultLayer->GetLayerDefn()->GetFieldIndex( "Percent of AOI" ); resultLayer->ResetReading(); OGRFeature *resultFeature; while( (resultFeature = resultLayer->GetNextFeature()) != NULL ) { double acres = resultFeature->GetFieldAsDouble( acreIndex ); double area = resultFeature->GetFieldAsDouble( areaIndex ); resultSummary.totalPercentOfAoI += area; resultSummary.totalIntersectionAcres += acres; } } if ( resultSummary.totalPercentOfAoI != origSummary->totalPercentOfAoI ) { printf( "Test results: Percent of AoI mismatch.\n" ); success = false; } if ( resultSummary.totalIntersectionAcres != origSummary->totalIntersectionAcres ) { printf( "Test results: Acreage mismatch.\n" ); success = false; } return success; }
int main() { // Read in raster data for night time lights int band_number = 1; // only one band, starts with one Raster* raster = import_raster("raster.tif", band_number); // Read in shapefile data containing municipality administrative regions int layer_number = 0; // only one layer, starts with zero OGRLayer* shapelayer = import_shapefile("MEX_adm2.shp", layer_number); shapelayer->SetAttributeFilter("ID_1 = 1834"); // Filter for Yucatan const int idx_of_number_field = 5; // Column number of municipality number const int idx_of_name_field = 6; // Column number of municipality name OGRFeature* poFeature; int feature_ctr = 0; while( (poFeature = shapelayer->GetNextFeature()) != NULL ) { cerr << "Feature: " << feature_ctr++ << "\t"; int feature_num = poFeature->GetFieldAsInteger(idx_of_number_field); string feature_name = poFeature->GetFieldAsString(idx_of_name_field); OGRFeatureDefn *poFDefn = shapelayer->GetLayerDefn(); for( int iField = 0; iField < poFDefn->GetFieldCount(); iField++ ) { OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( iField ); if( poFieldDefn->GetType() == OFTString ) cerr << poFeature->GetFieldAsString(iField) << ","; } OGRGeometry* poGeometry = poFeature->GetGeometryRef(); if( poGeometry != NULL) { // For contiguous regions if ( wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon ) { cerr << " polygon" << endl; report_raster_data_within_polygon(raster, (OGRPolygon *) poGeometry, feature_num, feature_name); // For disjoint regions } else if ( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon ) { cerr << " multipolygon" << endl; OGRMultiPolygon *multipolygon = (OGRMultiPolygon *) poGeometry; for (int i = 0; i<multipolygon->getNumGeometries(); i++) { report_raster_data_within_polygon(raster, (OGRPolygon*) multipolygon->getGeometryRef(i), feature_num, feature_name); } // Is this really the right shapefile? } else { cerr << "No polygon or multipolygon geometry for this feature: " << poGeometry->getGeometryName() << endl; } } else { cerr << "No geometry for this feature" << endl; } } OGRFeature::DestroyFeature( poFeature ); }
bool LoadShapes(GDALDataset* dataset, QueryIntermediateData& qid) { OGRLayer* waterLayer = dataset->GetLayerByName("water"); if (!waterLayer) return true; // requested layer may not be present in requested dataset waterLayer->ResetReading(); OGRFeature* feature; while ((feature = waterLayer->GetNextFeature()) != NULL) { auto geo = feature->GetGeometryRef(); auto featureId = feature->GetFID(); if (qid.transform) { if (geo->transform(qid.transform) != OGRERR_NONE) { continue; } } if (geo->getGeometryType() == wkbMultiPolygon) { auto mp = (OGRMultiPolygon*)geo; const int numPolys = mp->getNumGeometries(); for (int p = 0; p < numPolys; p++) { auto poly = new Polygon((OGRPolygon*)mp->getGeometryRef(p), featureId); qid.waterPolyQuadtree.Insert(poly); qid.waterPolygons.push_back(poly); } } else if (geo->getGeometryType() == wkbPolygon) { auto poly = new Polygon((OGRPolygon*)geo, featureId); qid.waterPolyQuadtree.Insert(poly); qid.waterPolygons.push_back(poly); } OGRFeature::DestroyFeature(feature); } return true; }
/** @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); }
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(); }
// ************************************************************* // LoadStyle() // ************************************************************* CStringW OgrStyleHelper::LoadStyle(GDALDataset* dataset, CStringW styleTableName, CStringW layerName, CStringW styleName) { USES_CONVERSION; CStringW sql; sql.Format(L"SELECT style FROM %s WHERE layername = '%s' AND stylename = '%s'", styleTableName, layerName, styleName); CStringW xml = L""; bool found = false; CPLErrorReset(); OGRLayer* layer = dataset->ExecuteSQL(OgrHelper::String2OgrString(sql), NULL, NULL); if (layer) { OGRFeature* ft = layer->GetNextFeature(); if (ft) { const char* s = ft->GetFieldAsString(0); if (s) { xml = OgrHelper::OgrString2Unicode(s); } OGRFeature::DestroyFeature(ft); } dataset->ReleaseResultSet(layer); } return xml; }
int OGRAmigoCloudDataSource::Open( const char * pszFilename, char** papszOpenOptionsIn, int bUpdateIn ) { bReadWrite = CPL_TO_BOOL(bUpdateIn); pszName = CPLStrdup( pszFilename ); pszProjectId = CPLStrdup(pszFilename + strlen("AMIGOCLOUD:")); char* pchSpace = strchr(pszProjectId, ' '); if( pchSpace ) *pchSpace = '\0'; if( pszProjectId[0] == 0 ) { CPLError(CE_Failure, CPLE_AppDefined, "Missing project id"); return FALSE; } osAPIKey = CSLFetchNameValueDef(papszOpenOptionsIn, "AMIGOCLOUD_API_KEY", CPLGetConfigOption("AMIGOCLOUD_API_KEY", "")); if (osAPIKey.empty()) { osAPIKey = OGRAMIGOCLOUDGetOptionValue(pszFilename, "AMIGOCLOUD_API_KEY"); } if (osAPIKey.empty()) { CPLError(CE_Failure, CPLE_AppDefined, "AMIGOCLOUD_API_KEY is not defined.\n"); return FALSE; } OGRLayer* poSchemaLayer = ExecuteSQLInternal("SELECT current_schema()"); if( poSchemaLayer ) { OGRFeature* poFeat = poSchemaLayer->GetNextFeature(); if( poFeat ) { if( poFeat->GetFieldCount() == 1 ) { osCurrentSchema = poFeat->GetFieldAsString(0); } delete poFeat; } ReleaseResultSet(poSchemaLayer); } if( osCurrentSchema.empty() ) return FALSE; CPLString osDatasets = OGRAMIGOCLOUDGetOptionValue(pszFilename, "datasets"); if (!osDatasets.empty()) { char** papszTables = CSLTokenizeString2(osDatasets, ",", 0); for(int i=0;papszTables && papszTables[i];i++) { papoLayers = (OGRAmigoCloudTableLayer**) CPLRealloc( papoLayers, (nLayers + 1) * sizeof(OGRAmigoCloudTableLayer*)); papoLayers[nLayers ++] = new OGRAmigoCloudTableLayer(this, papszTables[i]); } CSLDestroy(papszTables); // If OVERWRITE: YES, truncate the layer. if( nLayers==1 && CPLFetchBool(papszOpenOptionsIn, "OVERWRITE", false) ) { TruncateDataset(papoLayers[0]->GetTableName()); } return TRUE; } else { // If 'datasets' word is in the filename, but no dataset id specified, // print the list of available datasets if(std::string(pszFilename).find("datasets") != std::string::npos) ListDatasets(); } return TRUE; }
CPLErr GNMGenericNetwork::ChangeAllBlockState(bool bIsBlock) { if(!m_bIsGraphLoaded && LoadGraph() != CE_None) { return CE_Failure; } OGRFeature *poFeature; m_poGraphLayer->ResetReading(); while ((poFeature = m_poGraphLayer->GetNextFeature()) != NULL) { if(bIsBlock) { poFeature->SetField( GNM_SYSFIELD_BLOCKED, GNM_BLOCK_ALL ); } else { poFeature->SetField( GNM_SYSFIELD_BLOCKED, GNM_BLOCK_NONE ); } if( m_poGraphLayer->SetFeature( poFeature ) != OGRERR_NONE ) { OGRFeature::DestroyFeature( poFeature ); CPLError( CE_Failure, CPLE_AppDefined, "Failed to update feature." ); return CE_Failure; } OGRFeature::DestroyFeature( poFeature ); } // change all network layers for(size_t i = 0; i < m_apoLayers.size(); ++i) { OGRLayer* poLayer = m_apoLayers[i]; if(NULL == poLayer) continue; while ((poFeature = poLayer->GetNextFeature()) != NULL) { if(bIsBlock) { poFeature->SetField( GNM_SYSFIELD_BLOCKED, GNM_BLOCK_ALL ); } else { poFeature->SetField( GNM_SYSFIELD_BLOCKED, GNM_BLOCK_NONE ); } if( poLayer->SetFeature( poFeature ) != OGRERR_NONE ) { OGRFeature::DestroyFeature( poFeature ); CPLError( CE_Failure, CPLE_AppDefined, "Failed to update feature." ); return CE_Failure; } OGRFeature::DestroyFeature( poFeature ); } } m_oGraph.ChangeAllBlockState(bIsBlock); return CE_None; }
CPLErr GNMGenericNetwork::ConnectPointsByLines(char **papszLayerList, double dfTolerance, double dfCost, double dfInvCost, GNMDirection eDir) { if( CSLCount(papszLayerList) < 2 ) { CPLError( CE_Failure, CPLE_IllegalArg, "Minimum 2 layers needed to connect" ); return CE_Failure; } std::vector<OGRLayer*> paLineLayers; std::vector<OGRLayer*> paPointLayers; int eType; int iLayer; OGRLayer* poLayer; for(iLayer = 0; papszLayerList[iLayer] != NULL; ++iLayer) { poLayer = GetLayerByName(papszLayerList[iLayer]); if(NULL == poLayer) continue; eType = wkbFlatten(poLayer->GetGeomType()); if(eType == wkbLineString || eType == wkbMultiLineString) { paLineLayers.push_back(poLayer); } else if(eType == wkbPoint) { paPointLayers.push_back(poLayer); } } if (paLineLayers.empty() || paPointLayers.empty() ) { CPLError( CE_Failure, CPLE_IllegalArg, "Need at least one line (or " "multiline) layer and one point layer to connect" ); return CE_Failure; } // now walk through all lines and find nearest points for line start and end OGRFeature* poFeature; for(size_t i = 0; i < paLineLayers.size(); ++i) { poLayer = paLineLayers[i]; eType = wkbFlatten(poLayer->GetGeomType()); poLayer->ResetReading(); while((poFeature = poLayer->GetNextFeature()) != NULL) { const OGRGeometry* poGeom = poFeature->GetGeometryRef(); if(NULL != poGeom) { if(eType == wkbLineString) { const OGRLineString* poLineString = (const OGRLineString*) poGeom; ConnectPointsByLine(poFeature->GetFID(), poLineString, paPointLayers, dfTolerance, dfCost, dfInvCost, eDir); } else if( eType == wkbMultiLineString) { const OGRMultiLineString* poMultiLineString = (const OGRMultiLineString*) poGeom; ConnectPointsByMultiline(poFeature->GetFID(), poMultiLineString, paPointLayers, dfTolerance, dfCost, dfInvCost, eDir); } } OGRFeature::DestroyFeature(poFeature); } } return CE_None; }
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; }
boost::optional<mapnik::datasource_geometry_t> ogr_datasource::get_geometry_type() const { boost::optional<mapnik::datasource_geometry_t> result; if (dataset_ && layer_.is_valid()) { OGRLayer* layer = layer_.layer(); // NOTE: wkbFlatten macro in ogr flattens 2.5d types into base 2d type #if GDAL_VERSION_NUM < 1800 switch (wkbFlatten(layer->GetLayerDefn()->GetGeomType())) #else switch (wkbFlatten(layer->GetGeomType())) #endif { case wkbPoint: case wkbMultiPoint: result.reset(mapnik::datasource_geometry_t::Point); break; case wkbLinearRing: case wkbLineString: case wkbMultiLineString: result.reset(mapnik::datasource_geometry_t::LineString); break; case wkbPolygon: case wkbMultiPolygon: result.reset(mapnik::datasource_geometry_t::Polygon); break; case wkbGeometryCollection: result.reset(mapnik::datasource_geometry_t::Collection); break; case wkbNone: case wkbUnknown: { // fallback to inspecting first actual geometry // TODO - csv and shapefile inspect first 4 features if (dataset_ && layer_.is_valid()) { layer = layer_.layer(); // only new either reset of setNext //layer->ResetReading(); layer->SetNextByIndex(0); OGRFeature *poFeature; while ((poFeature = layer->GetNextFeature()) != nullptr) { OGRGeometry* geom = poFeature->GetGeometryRef(); if (geom && ! geom->IsEmpty()) { switch (wkbFlatten(geom->getGeometryType())) { case wkbPoint: case wkbMultiPoint: result.reset(mapnik::datasource_geometry_t::Point); break; case wkbLinearRing: case wkbLineString: case wkbMultiLineString: result.reset(mapnik::datasource_geometry_t::LineString); break; case wkbPolygon: case wkbMultiPolygon: result.reset(mapnik::datasource_geometry_t::Polygon); break; case wkbGeometryCollection: result.reset(mapnik::datasource_geometry_t::Collection); break; default: break; } } OGRFeature::DestroyFeature( poFeature ); break; } } break; } default: break; } } return result; }
bool ShortNavigation::createObstaclesTables() { // OGRLayer* layer; status = true; if ( !status==false ) { qDebug()<<"bool ShortNavigation::createObstaclesTables()"; /// POINT_OFFSET is the area around the obstacle, /// so is it's value is 5, it will draw 10 m^2 //float POINT_OFFSET = settingsManager->getPOffset(); float POINT_OFFSET = 5; //test values, above comment from old code //float NOT_ALLOWED_DEPTH = settingsManager->getMinDepth(); float NOT_ALLOWED_DEPTH = 2; //test values, above comment from old code /// signsound with depth from 0 to this value are /// taken in consideration for the obstacles layer //float SIGNSOUND_THRESHOLD = settingsManager->getSignsound(); float SIGNSOUND_THRESHOLD = 1; //test values, above comment from old code // ################################################## // list of polygon layers considered obstacles QList<QString> polygon_layers; polygon_layers.append("generarea_r"); // list of point layers to be considered as obstacles QList<QString> point_layers; point_layers.append("rock_p"); point_layers.append("wreck_p"); point_layers.append("navaid_p"); point_layers.append("signsound_p"); // line layers to be considered as obstacles QList<QString> line_layers; line_layers.append("depthcont_l"); //#################################################### for (int i = 0 ; i < this->chartObjects.size(); i++) { // qDebug() << "chartObjects size" << chartObjects.size(); if(this->chartObjects.at(i)->getTableName() == "generarea_r") { for (int j = 0 ; j < this->chartObjects.at(i)->getCoordinateGeometry().size();j++) { this->polyObstacles.append(this->chartObjects.at(i)->getCoordinateGeometry().at(j)); } } if(this->chartObjects.at(i)->getTableName() == "depthcont_l") { for (int j = 0 ; j < this->chartObjects.at(i)->getCoordinateGeometry().size();j++) { //TODO: parse line from polygon //this->lineObstacles.append(this->chartObjects.at(i)->getCoordinateGeometry().at(j)); //Not used in Shortnavigation -> can be removed! } } if(this->chartObjects.at(i)->getTableName() == "rock_p") { for (int j = 0 ; j < this->chartObjects.at(i)->getCoordinateGeometry().size();j++) { //need to check how vectors are written from DB. is getfeaturecount = polygonvector.size ? for(int k = 0; k < this->chartObjects.at(i)->getCoordinateGeometry().at(j).size();k++) { this->pointObstacles.append(this->chartObjects.at(i)->getCoordinateGeometry().at(j).at(k)); } } } if(this->chartObjects.at(i)->getTableName() == "wreck_p") { for (int j = 0 ; j < this->chartObjects.at(i)->getCoordinateGeometry().size();j++) { for(int k = 0; k < this->chartObjects.at(i)->getCoordinateGeometry().at(j).size();k++) { this->pointObstacles.append(this->chartObjects.at(i)->getCoordinateGeometry().at(j).at(k)); } } } if(this->chartObjects.at(i)->getTableName() == "navaid_p") { for (int j = 0 ; j < this->chartObjects.at(i)->getCoordinateGeometry().size();j++) { for(int k = 0; k < this->chartObjects.at(i)->getCoordinateGeometry().at(j).size();k++) { this->pointObstacles.append(this->chartObjects.at(i)->getCoordinateGeometry().at(j).at(k)); } } } if(this->chartObjects.at(i)->getTableName() == "signsound_p") { QVector<QPolygonF> qpoint; QList<QPointF> listqpoint; OGRLayer* layer; OGRFeatureDefn *poFDefn; OGRFeature *poFeature; qpoint = this->chartObjects.at(i)->getCoordinateGeometry(); for(int n = 0; n < qpoint.size(); n++){ listqpoint = qpoint.value(n).toList(); } layer = this->chartObjects.at(i)->getFeatureData(); layer->ResetReading(); QString /*sql("SELECT * FROM *"); //FIX THIS! //*/ sql("SELECT * FROM ( SELECT DISTINCT Intersects( wkb_geometry, "); for(int m= 0; m < layer->GetFeatureCount();m++ ) { poFDefn = layer->GetLayerDefn(); poFeature = layer->GetNextFeature(); for(int j = 0; j < poFDefn->GetFieldCount(); j++ ){ OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn( j ); QString str = poFieldDefn->GetNameRef(); if(str.contains("depth") == true) { if (poFeature->GetFieldAsDouble(j) < SIGNSOUND_THRESHOLD) { //parse out depths above signsound threshold since they are not obstacles pointObstacles.append(listqpoint.at(m)); } } } } // // CREATE NEW TABLES sql = "CREATE TABLE obstacles_r (ogc_fid serial);"; sql.append( "CREATE TABLE obstacles_l (ogc_fid serial);" ); sql.append( "SELECT AddGeometryColumn ('obstacles_r','wkb_geometry',-1,'POLYGON',2);" ); sql.append( "SELECT AddGeometryColumn ('obstacles_l','wkb_geometry',-1,'LINESTRING',2);" ); sql.append( "ALTER TABLE obstacles_r ADD COLUMN source_table char(11);" ); sql.append( "ALTER TABLE obstacles_l ADD COLUMN source_table char(11);" ); res = PQexec(conn, sql.toAscii() ); PQclear(res); // INSERT POLYGON LAYERS sql.clear(); // DIRECT VERSION, WITHOUT ADDING THE OFFSET for ( int i = 0; i < polygon_layers.size(); i++ ) { sql.append( "INSERT INTO obstacles_r( wkb_geometry, source_table) SELECT wkb_geometry, '"); sql.append( polygon_layers[i] ); sql.append( "' AS source_table FROM " ); sql.append( polygon_layers[i] ); sql.append( ";" ); if (debug) qDebug() << QString("UwShort: Adding obstacles of %1").arg( polygon_layers[i]); } // WARNING: very long string: res = PQexec(conn, sql.toAscii() ); PQclear(res); qDebug() << "for in 1"; // INSERT POINT LAYERS WITH OFFSET for ( int i = 0; i < point_layers.size(); i++ ) { bool signsound = ( point_layers[i] == "signsound_p" ); sql = "SELECT X(wkb_geometry),Y(wkb_geometry)"; if ( signsound) sql.append( ",depth"); sql.append( " FROM "); sql.append( point_layers[i] ); if ( signsound) sql.append( QString(" WHERE depth < %1 ").arg( QString::number( SIGNSOUND_THRESHOLD))); sql.append( ";"); res = PQexec(conn, sql.toAscii() ); if (debug) qDebug() << QString("UwShort: Adding obstacles of %1 (%2/%3): %4 obstacles").arg( point_layers[i], QString::number(i+1), QString::number(point_layers.size()), QString::number(PQntuples(res))); sql.clear(); for ( int j = 0; j < PQntuples(res); j++ ) { QPointF point( QString( PQgetvalue( res, j, 0)).toDouble(), QString( PQgetvalue( res, j, 1)).toDouble()); //forms a qpoint double precision sql.append( "INSERT INTO obstacles_r ( wkb_geometry, source_table) VALUES ( "); if ( point_layers[i] == "rock_p") sql.append( ShortNavigation::buildWKTPolygon( point, POINT_OFFSET * POINT_OFFSET_FACTOR_ROCK )); else if ( point_layers[i] == "wreck_p" ) sql.append( ShortNavigation::buildWKTPolygon( point, POINT_OFFSET * POINT_OFFSET_FACTOR_ROCK )); else if ( signsound) // for signsound POINT_OFFSET = POINT_OFFSET / ( depth of signsound / factor ) // the bigger the signsound is, the bigger the point offset gets sql.append( ShortNavigation::buildWKTPolygon( point, POINT_OFFSET / ( QString( PQgetvalue( res, j, 2)).toDouble() / POINT_OFFSET_FACTOR_SIGNSOUND ) )); else sql.append( ShortNavigation::buildWKTPolygon( point, POINT_OFFSET)); sql.append( ", '"); sql.append( point_layers[i]); sql.append( "'); "); } PQclear(res); res = PQexec( conn, sql.toAscii()); PQclear(res); //INSERT LINE LAYERS sql.clear(); for ( int i = 0; i < line_layers.size(); i++ ) { sql.append( "INSERT INTO obstacles_l( wkb_geometry, source_table) SELECT wkb_geometry, '"); sql.append( line_layers[i]); sql.append( "' AS source_table FROM " ); sql.append( line_layers[i] ); if ( line_layers[i] == "depthcont_l" ) { sql.append( " WHERE valdco<=" ); sql.append( QString::number( NOT_ALLOWED_DEPTH)); } sql.append( ";"); if (debug) { // WARNING: very long string: qDebug() << QString("UwShort: Adding obstacles of ").append( line_layers[i]); } res = PQexec(conn, sql.toAscii() ); PQclear(res); } // for loop for testing // for (int s=0; s<pointObstacles.size();s++){ // qDebug() << " index: " << s << "point x" << pointObstacles.at(s).x() << "y" << pointObstacles.at(s).y(); // } // tables are done this->obstaclesTablesCreated = true; qDebug("createObstaclesTables() returns = true"); return true; } } } }else { // tables are not done this->obstaclesTablesCreated = false; return false; } }
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; }
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 ) { 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; }
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 }
void Dust::MakeGrid(WindNinjaInputs &input, AsciiGrid<double> &grid) { /*------------------------------------------*/ /* Open grid as a GDAL dataset */ /*------------------------------------------*/ int nXSize = grid.get_nCols(); int nYSize = grid.get_nRows(); GDALDriverH hDriver = GDALGetDriverByName( "MEM" ); GDALDatasetH hMemDS = GDALCreate(hDriver, "", nXSize, nYSize, 1, GDT_Float64, NULL); double *padfScanline; padfScanline = new double[nXSize]; double adfGeoTransform[6]; adfGeoTransform[0] = grid.get_xllCorner(); adfGeoTransform[1] = grid.get_cellSize(); adfGeoTransform[2] = 0; adfGeoTransform[3] = grid.get_yllCorner()+(grid.get_nRows()*grid.get_cellSize()); adfGeoTransform[4] = 0; adfGeoTransform[5] = -grid.get_cellSize(); char* pszDstWKT = (char*)grid.prjString.c_str(); GDALSetProjection(hMemDS, pszDstWKT); GDALSetGeoTransform(hMemDS, adfGeoTransform); GDALRasterBandH hBand = GDALGetRasterBand( hMemDS, 1 ); GDALSetRasterNoDataValue(hBand, -9999.0); for(int i=nYSize-1; i>=0; i--) { for(int j=0; j<nXSize; j++) { padfScanline[j] = grid.get_cellValue(nYSize-1-i, j); } GDALRasterIO(hBand, GF_Write, 0, i, nXSize, 1, padfScanline, nXSize, 1, GDT_Float64, 0, 0); } /*------------------------------------------*/ /* Get the geometry info */ /*------------------------------------------*/ OGRDataSourceH hOGRDS = 0; hOGRDS = OGROpen(input.dustFilename.c_str(), FALSE, 0); if(hOGRDS == NULL) { throw std::runtime_error("Could not open the fire perimeter file '" + input.dustFilename + "' for reading."); } OGRLayer *poLayer; OGRFeature *poFeature; OGRGeometry *poGeo; poLayer = (OGRLayer*)OGR_DS_GetLayer(hOGRDS, 0); poLayer->ResetReading(); poFeature = poLayer->GetNextFeature(); poGeo = poFeature->GetGeometryRef(); OGRGeometryH hPolygon = (OGRGeometryH) poGeo; /* -------------------------------------------------------------------- */ /* Check for same CRS in fire perimeter and DEM files */ /* -------------------------------------------------------------------- */ char *pszSrcWKT; OGRSpatialReference *poSrcSRS, oDstSRS; poSrcSRS = poLayer->GetSpatialRef(); //shapefile CRS poSrcSRS->exportToWkt( &pszSrcWKT ); //printf("CRS of DEM is:\n %s\n", pszDstWKT); //printf("WKT CRS of .shp is:\n %s\n", pszSrcWKT); oDstSRS.importFromWkt( &pszDstWKT ); char *pszDstProj4, *pszSrcProj4; oDstSRS.exportToProj4( &pszDstProj4 ); poSrcSRS->exportToProj4( &pszSrcProj4 ); //printf("proj4 of .shp is:\n %s\n", pszSrcProj4); //printf("proj4 of dem is:\n %s\n", pszDstProj4); /* -------------------------------------------------------------------- */ /* If the CRSs are not equal, convert shapefile CRS to DEM CRS */ /* -------------------------------------------------------------------- */ GDALTransformerFunc pfnTransformer = NULL; if( !EQUAL( pszSrcProj4, pszDstProj4 ) ){ //tranform shp CRS to DEM CRS poGeo->transformTo(&oDstSRS); } /* -------------------------------------------------------------------- */ /* Rasterize the shapefile */ /* -------------------------------------------------------------------- */ int nTargetBand = 1; double BurnValue = 1.0; CPLErr eErr; eErr = GDALRasterizeGeometries(hMemDS, 1, &nTargetBand, 1, &hPolygon, pfnTransformer, NULL, &BurnValue, NULL, NULL, NULL); if(eErr != CE_None) { throw std::runtime_error("Error in GDALRasterizeGeometies in Dust:MakeGrid()."); } GDAL2AsciiGrid((GDALDataset*)hMemDS, 1, grid); /* -------------------------------------------------------------------- */ /* clean up */ /* -------------------------------------------------------------------- */ if( hMemDS != NULL ){ GDALClose( hMemDS ); hMemDS = NULL; } OGR_DS_Destroy(hOGRDS); }
//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; }
bool shape::load(string filename) { OGRRegisterAll(); // First open the shape file ds = OGRSFDriverRegistrar::Open( filename.c_str(), FALSE ); // Now to load in the points ..... points = vector<vector<glm::vec2>>(); // Grab the first layer OGRLayer* layer = ds->GetLayer(0); // Grab the spatial reference and create a coordinate transform function sr = layer->GetSpatialRef(); // Taking from http://www.compsci.wm.edu/SciClone/documentation/software/geo/gdal-1.9.0/html/ogr/ogr_apitut.html OGRFeature *poFeature; layer->ResetReading(); while( (poFeature = layer->GetNextFeature()) != NULL ) { OGRFeatureDefn *poFDefn = layer->GetLayerDefn(); int iField; OGRGeometry *poGeometry; poGeometry = poFeature->GetGeometryRef(); if( poGeometry != NULL && wkbFlatten(poGeometry->getGeometryType()) == wkbPoint ) { OGRPoint *poPoint = (OGRPoint *) poGeometry; //printf( "%.3f,%3.f\n", poPoint->getX(), poPoint->getY() ); } else if (poGeometry != NULL && wkbFlatten(poGeometry->getGeometryType()) == wkbLineString) { //cout << "LINES!!!!" << endl; OGRLineString* ls= (OGRLineString*)poGeometry; points.push_back(vector<glm::vec2>()); for(int i = 0; i < ls->getNumPoints(); i++ ) { OGRPoint p; ls->getPoint(i,&p); // This function can transform a larget set of points..... double x = p.getX(); double y = p.getY(); points[points.size()-1].push_back(glm::vec2(x,y)); //poTransform->Transform (1, &x, &y); //cout << p.getX() << " " << p.getY() << "Transformed!: " << x << " " << y << endl; } } else if (poGeometry != NULL && wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon) { OGRLineString* ls= (OGRLineString*)poGeometry->getBoundary(); points.push_back(vector<glm::vec2>()); cout << "POLYGON" << ls->getNumPoints() << endl; //exit(0); for(int i = 0; i < ls->getNumPoints(); i++ ) { OGRPoint p; ls->getPoint(i,&p); // This function can transform a larget set of points..... double x = p.getX(); double y = p.getY(); points[points.size()-1].push_back(glm::vec2(x,y)); //poTransform->Transform (1, &x, &y); //cout << p.getX() << " " << p.getY() << "Transformed!: " << x << " " << y << endl; } } OGRFeature::DestroyFeature( poFeature ); } return true; }
int OGRAmigoCloudDataSource::Open( const char * pszFilename, char** papszOpenOptionsIn, int bUpdateIn ) { bReadWrite = CPL_TO_BOOL(bUpdateIn); pszName = CPLStrdup( pszFilename ); if( CSLFetchNameValue(papszOpenOptionsIn, "PROJECTID") ) pszProjetctId = CPLStrdup(CSLFetchNameValue(papszOpenOptionsIn, "PROJECTID")); else { pszProjetctId = CPLStrdup(pszFilename + strlen("AMIGOCLOUD:")); char* pchSpace = strchr(pszProjetctId, ' '); if( pchSpace ) *pchSpace = '\0'; if( pszProjetctId[0] == 0 ) { CPLError(CE_Failure, CPLE_AppDefined, "Missing projetc id"); return FALSE; } } osAPIKey = CSLFetchNameValueDef(papszOpenOptionsIn, "API_KEY", CPLGetConfigOption("AMIGOCLOUD_API_KEY", "")); CPLString osDatasets = OGRAMIGOCLOUDGetOptionValue(pszFilename, "datasets"); bUseHTTPS = CPLTestBool(CPLGetConfigOption("AMIGOCLOUD_HTTPS", "YES")); OGRLayer* poSchemaLayer = ExecuteSQLInternal("SELECT current_schema()"); if( poSchemaLayer ) { OGRFeature* poFeat = poSchemaLayer->GetNextFeature(); if( poFeat ) { if( poFeat->GetFieldCount() == 1 ) { osCurrentSchema = poFeat->GetFieldAsString(0); } delete poFeat; } ReleaseResultSet(poSchemaLayer); } if( osCurrentSchema.size() == 0 ) return FALSE; if (osDatasets.size() != 0) { char** papszTables = CSLTokenizeString2(osDatasets, ",", 0); for(int i=0;papszTables && papszTables[i];i++) { papoLayers = (OGRAmigoCloudTableLayer**) CPLRealloc( papoLayers, (nLayers + 1) * sizeof(OGRAmigoCloudTableLayer*)); papoLayers[nLayers ++] = new OGRAmigoCloudTableLayer(this, papszTables[i]); } CSLDestroy(papszTables); return TRUE; } return TRUE; }
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 }