void way(const osmium::Way& way) { const char* highway = way.tags().get_value_by_key("highway"); if (highway) { try { std::unique_ptr<OGRLineString> ogr_linestring = m_factory.create_linestring(way); OGRFeature* feature = OGRFeature::CreateFeature(m_layer_linestring->GetLayerDefn()); feature->SetGeometry(ogr_linestring.get()); feature->SetField("id", static_cast<double>(way.id())); feature->SetField("type", highway); if (m_layer_linestring->CreateFeature(feature) != OGRERR_NONE) { std::cerr << "Failed to create feature.\n"; exit(1); } OGRFeature::DestroyFeature(feature); } catch (osmium::geometry_error&) { std::cerr << "Ignoring illegal geometry for way " << way.id() << ".\n"; } } }
explicit ProblemReporterOGR(OGRDataSource* data_source) : m_data_source(data_source) { OGRSpatialReference sparef; sparef.SetWellKnownGeogCS("WGS84"); m_layer_perror = m_data_source->CreateLayer("perrors", &sparef, wkbPoint, nullptr); if (!m_layer_perror) { std::runtime_error("Layer creation failed for layer 'perrors'"); } OGRFieldDefn layer_perror_field_id1("id1", OFTReal); layer_perror_field_id1.SetWidth(10); if (m_layer_perror->CreateField(&layer_perror_field_id1) != OGRERR_NONE) { std::runtime_error("Creating field 'id1' failed for layer 'perrors'"); } OGRFieldDefn layer_perror_field_id2("id2", OFTReal); layer_perror_field_id2.SetWidth(10); if (m_layer_perror->CreateField(&layer_perror_field_id2) != OGRERR_NONE) { std::runtime_error("Creating field 'id2' failed for layer 'perrors'"); } OGRFieldDefn layer_perror_field_problem_type("problem_type", OFTString); layer_perror_field_problem_type.SetWidth(30); if (m_layer_perror->CreateField(&layer_perror_field_problem_type) != OGRERR_NONE) { std::runtime_error("Creating field 'problem_type' failed for layer 'perrors'"); } /**************/ m_layer_lerror = m_data_source->CreateLayer("lerrors", &sparef, wkbLineString, nullptr); if (!m_layer_lerror) { std::runtime_error("Layer creation failed for layer 'lerrors'"); } OGRFieldDefn layer_lerror_field_id1("id1", OFTReal); layer_lerror_field_id1.SetWidth(10); if (m_layer_lerror->CreateField(&layer_lerror_field_id1) != OGRERR_NONE) { std::runtime_error("Creating field 'id1' failed for layer 'lerrors'"); } OGRFieldDefn layer_lerror_field_id2("id2", OFTReal); layer_lerror_field_id2.SetWidth(10); if (m_layer_lerror->CreateField(&layer_lerror_field_id2) != OGRERR_NONE) { std::runtime_error("Creating field 'id2' failed for layer 'lerrors'"); } OGRFieldDefn layer_lerror_field_problem_type("problem_type", OFTString); layer_lerror_field_problem_type.SetWidth(30); if (m_layer_lerror->CreateField(&layer_lerror_field_problem_type) != OGRERR_NONE) { std::runtime_error("Creating field 'problem_type' failed for layer 'lerrors'"); } }
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(); }
int wxStation::GetFirstStationLine(const char *xFilename) { OGRDataSourceH hDS; OGRLayer *poLayer; OGRFeature *poFeature; OGRLayerH hLayer; GIntBig iBig = 1; hDS = OGROpen( xFilename, FALSE, NULL ); if(hDS == NULL) { return -1; //very bad! } poLayer = (OGRLayer*)OGR_DS_GetLayer( hDS, 0 ); hLayer=OGR_DS_GetLayer(hDS,0); OGR_L_ResetReading(hLayer); poLayer->ResetReading(); poFeature = poLayer->GetFeature(iBig); if (poFeature==NULL) { return -1; //If there are no stations in the csv! } std::string start_datetime(poFeature->GetFieldAsString(15)); if(start_datetime.empty()==true) { return 1; } if(start_datetime.empty()==false) { return 2; } }
OGRFeature* create_area_feature(const shared_ptr<Osmium::OSM::Area const>& area) { OGRFeature* feature = OGRFeature::CreateFeature(m_layer_polygon->GetLayerDefn()); Osmium::Geometry::MultiPolygon mp(*area); OGRMultiPolygon* ogrgeom = Osmium::Geometry::create_ogr_geometry(mp); ogrgeom->transform(m_transformation); feature->SetGeometryDirectly(ogrgeom); sprintf(longint, "%ld", area->from_way() ? area->orig_id() : -area->orig_id()); feature->SetField("osm_id", longint); feature->SetField("z_order", calculate_z_order(area.get())); feature->SetField("way_area", ogrgeom->get_Area()); return feature; }
ogr_featureset::ogr_featureset(mapnik::context_ptr const & ctx, OGRLayer & layer, OGRGeometry & extent, std::string const& encoding) : ctx_(ctx), layer_(layer), layerdef_(layer.GetLayerDefn()), tr_(new transcoder(encoding)), fidcolumn_(layer_.GetFIDColumn ()), count_(0) { layer_.SetSpatialFilter (&extent); }
CPLErr GNMFileNetwork::LoadNetworkLayer(const char *pszLayername) { // check if not loaded for(size_t i = 0; i < m_apoLayers.size(); ++i) { if(EQUAL(m_apoLayers[i]->GetName(), pszLayername)) return CE_None; } const char* pszExt = m_poLayerDriver->GetMetadataItem(GDAL_DMD_EXTENSION); CPLString soFile = CPLFormFilename(m_soNetworkFullName, pszLayername, pszExt); GDALDataset *poDS = (GDALDataset*) GDALOpenEx( soFile, GDAL_OF_VECTOR | GDAL_OF_UPDATE, NULL, NULL, NULL ); if( NULL == poDS ) { CPLError( CE_Failure, CPLE_OpenFailed, "Open '%s' file failed", soFile.c_str() ); return CE_Failure; } OGRLayer* poLayer = poDS->GetLayer(0); if(NULL == poLayer) { CPLError( CE_Failure, CPLE_OpenFailed, "Layer '%s' is not exist", pszLayername ); return CE_Failure; } CPLDebug("GNM", "Layer '%s' loaded", poLayer->GetName()); GNMGenericLayer* pGNMLayer = new GNMGenericLayer(poLayer, this); m_apoLayers.push_back(pGNMLayer); m_mpLayerDatasetMap[pGNMLayer] = poDS; return CE_None; }
bool OGRPointToLatLon(double &x, double &y, OGRDataSourceH hDS, const char *datum) { char *pszPrj = NULL; OGRSpatialReference *poSrcSRS; OGRSpatialReference oSourceSRS, oTargetSRS; OGRCoordinateTransformation *poCT; if (hDS == NULL) { return false; } OGRLayer *poLayer; poLayer = (OGRLayer *)OGR_DS_GetLayer(hDS, 0); poLayer->ResetReading(); poSrcSRS = poLayer->GetSpatialRef(); if (poSrcSRS == NULL) { return false; } oTargetSRS.SetWellKnownGeogCS(datum); poCT = OGRCreateCoordinateTransformation(poSrcSRS, &oTargetSRS); if (poCT == NULL) { return false; } if (!poCT->Transform(1, &x, &y)) { OGRCoordinateTransformation::DestroyCT(poCT); return false; } OGRCoordinateTransformation::DestroyCT(poCT); return true; }
OGRErr GNMFileNetwork::DeleteLayer(int nIndex) { OGRLayer* pLayer = GetLayer(nIndex); GDALDataset* poDS = m_mpLayerDatasetMap[pLayer]; if(NULL == poDS) { return OGRERR_FAILURE; } CPLDebug("GNM", "Delete network layer '%s'", pLayer->GetName()); if(poDS->DeleteLayer(0) != OGRERR_NONE) { return OGRERR_FAILURE; } GDALClose(poDS); // remove pointer from map m_mpLayerDatasetMap.erase(pLayer); return GNMGenericNetwork::DeleteLayer(nIndex); }
CPLErr GNMDatabaseNetwork::LoadNetworkLayer(const char *pszLayername) { // check if not loaded for(size_t i = 0; i < m_apoLayers.size(); ++i) { if(EQUAL(m_apoLayers[i]->GetName(), pszLayername)) return CE_None; } OGRLayer* poLayer = m_poDS->GetLayerByName(pszLayername); if(NULL == poLayer) { CPLError( CE_Failure, CPLE_OpenFailed, "Layer '%s' is not exist", pszLayername ); return CE_Failure; } CPLDebug("GNM", "Layer '%s' loaded", poLayer->GetName()); GNMGenericLayer* pGNMLayer = new GNMGenericLayer(poLayer, this); m_apoLayers.push_back(pGNMLayer); return CE_None; }
// ************************************************************* // 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; }
ogr_featureset::ogr_featureset(OGRDataSource & dataset, OGRLayer & layer, OGRGeometry & extent, const std::string& encoding, const bool multiple_geometries) : dataset_(dataset), layer_(layer), layerdef_(layer.GetLayerDefn()), tr_(new transcoder(encoding)), fidcolumn_(layer_.GetFIDColumn ()), multiple_geometries_(multiple_geometries), count_(0) { layer_.SetSpatialFilter (&extent); }
ogr_featureset::ogr_featureset(mapnik::context_ptr const& ctx, OGRLayer & layer, mapnik::box2d<double> const& extent, std::string const& encoding) : ctx_(ctx), layer_(layer), layerdef_(layer.GetLayerDefn()), tr_(new transcoder(encoding)), fidcolumn_(layer_.GetFIDColumn()), // TODO - unused count_(0) { layer_.SetSpatialFilterRect (extent.minx(), extent.miny(), extent.maxx(), extent.maxy()); }
ogr_featureset::ogr_featureset(OGRDataSource & dataset, OGRLayer & layer, const mapnik::Envelope<double> & extent, const std::string& encoding, const bool multiple_geometries) : dataset_(dataset), layer_(layer), layerdef_(layer.GetLayerDefn()), tr_(new transcoder(encoding)), fidcolumn_(layer_.GetFIDColumn ()), multiple_geometries_(multiple_geometries), count_(0) { layer_.SetSpatialFilterRect (extent.minx(), extent.miny(), extent.maxx(), extent.maxy()); }
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"); }
ogr_index_featureset<filterT>::ogr_index_featureset(mapnik::context_ptr const & ctx, OGRLayer & layer, filterT const& filter, std::string const& index_file, std::string const& encoding) : ctx_(ctx), layer_(layer), layerdef_(layer.GetLayerDefn()), filter_(filter), tr_(new transcoder(encoding)), fidcolumn_(layer_.GetFIDColumn()), feature_envelope_() { #ifdef SHAPE_MEMORY_MAPPED_FILE boost::optional<mapnik::mapped_region_ptr> memory = mapnik::mapped_memory_cache::instance().find(index_file, true); if (memory) { boost::interprocess::ibufferstream file(static_cast<char*>((*memory)->get_address()),(*memory)->get_size()); ogr_index<filterT,boost::interprocess::ibufferstream >::query(filter,file,ids_); } #else #if defined (WINDOWS) std::ifstream file(mapnik::utf8_to_utf16(index_file), std::ios::in | std::ios::binary); #else std::ifstream file(index_file.c_str(), std::ios::in | std::ios::binary); #endif ogr_index<filterT,std::ifstream>::query(filter,file,ids_); #endif std::sort(ids_.begin(),ids_.end()); MAPNIK_LOG_DEBUG(ogr) << "ogr_index_featureset: Query size=" << ids_.size(); itr_ = ids_.begin(); // reset reading layer_.ResetReading(); }
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; }
int ILI2Reader::AddFeature(DOMElement *elem) { bool newLayer = true; OGRLayer *curLayer = 0; char *pszName = XMLString::transcode(elem->getTagName()); // test if this layer exist for (list<OGRLayer *>::reverse_iterator layerIt = m_listLayer.rbegin(); layerIt != m_listLayer.rend(); ++layerIt) { OGRFeatureDefn *fDef = (*layerIt)->GetLayerDefn(); if (cmpStr(fDef->GetName(), pszName) == 0) { newLayer = false; curLayer = *layerIt; break; } } // add a layer if (newLayer) { // FIXME in Layer: SRS Writer Type datasource CPLDebug( "OGR_ILI", "Adding layer: %s", pszName ); // new layer data OGRSpatialReference *poSRSIn = NULL; // FIXME fix values for initial layer int bWriterIn = 0; OGRwkbGeometryType eReqType = wkbUnknown; OGRILI2DataSource *poDSIn = NULL; curLayer = new OGRILI2Layer(pszName, poSRSIn, bWriterIn, eReqType, poDSIn); m_listLayer.push_back(curLayer); } // the feature and field definition OGRFeatureDefn *featureDef = curLayer->GetLayerDefn(); if (newLayer) { // add TID field OGRFieldDefn ofieldDefn (ILI2_TID, OFTString); featureDef->AddFieldDefn(&ofieldDefn); setFieldDefn(featureDef, elem); } // add the features OGRFeature *feature = new OGRFeature(featureDef); // assign TID int fIndex = feature->GetFieldIndex(ILI2_TID); if (fIndex != -1) { XMLCh *pszIli2_tid = XMLString::transcode(ILI2_TID); char *fChVal = XMLString::transcode(elem->getAttribute(pszIli2_tid)); feature->SetField(fIndex, fChVal); XMLString::release (&pszIli2_tid); XMLString::release (&fChVal); } else { CPLDebug( "OGR_ILI","'%s' not found", ILI2_TID); } SetFieldValues(feature, elem); curLayer->SetFeature(feature); XMLString::release (&pszName); return 0; }
int OGRGPSBabelDataSource::Open( const char * pszDatasourceName, const char* pszGPSBabelDriverNameIn, char** papszOpenOptionsIn ) { if (!STARTS_WITH_CI(pszDatasourceName, "GPSBABEL:")) { CPLAssert(pszGPSBabelDriverNameIn); pszGPSBabelDriverName = CPLStrdup(pszGPSBabelDriverNameIn); pszFilename = CPLStrdup(pszDatasourceName); } else { if( CSLFetchNameValue(papszOpenOptionsIn, "FILENAME") ) pszFilename = CPLStrdup(CSLFetchNameValue(papszOpenOptionsIn, "FILENAME")); if( CSLFetchNameValue(papszOpenOptionsIn, "GPSBABEL_DRIVER") ) { if( pszFilename == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Missing FILENAME"); return FALSE; } pszGPSBabelDriverName = CPLStrdup(CSLFetchNameValue(papszOpenOptionsIn, "DRIVER")); /* A bit of validation to avoid command line injection */ if (!IsValidDriverName(pszGPSBabelDriverName)) return FALSE; } } pszName = CPLStrdup( pszDatasourceName ); bool bExplicitFeatures = false; bool bWaypoints = true; bool bTracks = true; bool bRoutes = true; if (pszGPSBabelDriverName == NULL) { const char* pszSep = strchr(pszDatasourceName + 9, ':'); if (pszSep == NULL) { CPLError( CE_Failure, CPLE_AppDefined, "Wrong syntax. Expected GPSBabel:driver_name:file_name"); return FALSE; } pszGPSBabelDriverName = CPLStrdup(pszDatasourceName + 9); *(strchr(pszGPSBabelDriverName, ':')) = '\0'; /* A bit of validation to avoid command line injection */ if (!IsValidDriverName(pszGPSBabelDriverName)) return FALSE; /* Parse optional features= option */ if (STARTS_WITH_CI(pszSep+1, "features=")) { const char* pszNextSep = strchr(pszSep+1, ':'); if (pszNextSep == NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Wrong syntax. Expected " "GPSBabel:driver_name[,options]*:[" "features=waypoints,tracks,routes:]file_name"); return FALSE; } char* pszFeatures = CPLStrdup(pszSep+1+9); *strchr(pszFeatures, ':') = 0; char** papszTokens = CSLTokenizeString(pszFeatures); char** papszIter = papszTokens; bool bErr = false; bExplicitFeatures = true; bWaypoints = false; bTracks = false; bRoutes = false; while(papszIter && *papszIter) { if (EQUAL(*papszIter, "waypoints")) bWaypoints = true; else if (EQUAL(*papszIter, "tracks")) bTracks = true; else if (EQUAL(*papszIter, "routes")) bRoutes = true; else { CPLError( CE_Failure, CPLE_AppDefined, "Wrong value for 'features' options"); bErr = true; } papszIter++; } CSLDestroy(papszTokens); CPLFree(pszFeatures); if (bErr) return FALSE; pszSep = pszNextSep; } if( pszFilename == NULL ) pszFilename = CPLStrdup(pszSep+1); } const char* pszOptionUseTempFile = CPLGetConfigOption("USE_TEMPFILE", NULL); if (pszOptionUseTempFile && CPLTestBool(pszOptionUseTempFile)) osTmpFileName = CPLGenerateTempFilename(NULL); else osTmpFileName.Printf("/vsimem/ogrgpsbabeldatasource_%p", this); bool bRet = false; if (IsSpecialFile(pszFilename)) { /* Special file : don't try to open it */ char** argv = GetArgv(bExplicitFeatures, bWaypoints, bRoutes, bTracks, pszGPSBabelDriverName, pszFilename); VSILFILE* tmpfp = VSIFOpenL(osTmpFileName.c_str(), "wb"); bRet = (CPLSpawn(argv, NULL, tmpfp, TRUE) == 0); VSIFCloseL(tmpfp); tmpfp = NULL; CSLDestroy(argv); argv = NULL; } else { VSILFILE* fp = VSIFOpenL(pszFilename, "rb"); if (fp == NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot open file %s", pszFilename); return FALSE; } char** argv = GetArgv(bExplicitFeatures, bWaypoints, bRoutes, bTracks, pszGPSBabelDriverName, "-"); VSILFILE* tmpfp = VSIFOpenL(osTmpFileName.c_str(), "wb"); CPLPushErrorHandler(CPLQuietErrorHandler); bRet = (CPLSpawn(argv, fp, tmpfp, TRUE) == 0); CPLPopErrorHandler(); CSLDestroy(argv); argv = NULL; CPLErr nLastErrorType = CPLGetLastErrorType(); CPLErrorNum nLastErrorNo = CPLGetLastErrorNo(); CPLString osLastErrorMsg = CPLGetLastErrorMsg(); VSIFCloseL(tmpfp); tmpfp = NULL; VSIFCloseL(fp); fp = NULL; if (!bRet) { if ( strstr(osLastErrorMsg.c_str(), "This format cannot be used in piped commands") == NULL) { CPLError( nLastErrorType, nLastErrorNo, "%s", osLastErrorMsg.c_str()); } else { VSIStatBuf sStatBuf; if (VSIStat(pszFilename, &sStatBuf) != 0) { CPLError( CE_Failure, CPLE_NotSupported, "Driver %s only supports real (non virtual) " "files", pszGPSBabelDriverName ); return FALSE; } /* Try without piping in */ argv = GetArgv(bExplicitFeatures, bWaypoints, bRoutes, bTracks, pszGPSBabelDriverName, pszFilename); tmpfp = VSIFOpenL(osTmpFileName.c_str(), "wb"); bRet = (CPLSpawn(argv, NULL, tmpfp, TRUE) == 0); VSIFCloseL(tmpfp); tmpfp = NULL; CSLDestroy(argv); argv = NULL; } } } if (bRet) { poGPXDS = static_cast<GDALDataset *>( GDALOpenEx( osTmpFileName.c_str(), GDAL_OF_VECTOR, NULL, NULL, NULL ) ); if (poGPXDS) { if (bWaypoints) { OGRLayer* poLayer = poGPXDS->GetLayerByName("waypoints"); if (poLayer != NULL && poLayer->GetFeatureCount() != 0) apoLayers[nLayers++] = poLayer; } if (bRoutes) { OGRLayer* poLayer = poGPXDS->GetLayerByName("routes"); if (poLayer != NULL && poLayer->GetFeatureCount() != 0) apoLayers[nLayers++] = poLayer; poLayer = poGPXDS->GetLayerByName("route_points"); if (poLayer != NULL && poLayer->GetFeatureCount() != 0) apoLayers[nLayers++] = poLayer; } if (bTracks) { OGRLayer* poLayer = poGPXDS->GetLayerByName("tracks"); if (poLayer != NULL && poLayer->GetFeatureCount() != 0) apoLayers[nLayers++] = poLayer; poLayer = poGPXDS->GetLayerByName("track_points"); if (poLayer != NULL && poLayer->GetFeatureCount() != 0) apoLayers[nLayers++] = poLayer; } } } return nLayers > 0; }
void ogr_datasource::bind() const { if (is_bound_) return; // initialize ogr formats OGRRegisterAll(); std::string driver = *params_.get<std::string>("driver",""); if (! driver.empty()) { OGRSFDriver * ogr_driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driver.c_str()); if (ogr_driver && ogr_driver != NULL) { dataset_ = ogr_driver->Open((dataset_name_).c_str(), FALSE); } } else { // open ogr driver dataset_ = OGRSFDriverRegistrar::Open((dataset_name_).c_str(), FALSE); } if (! dataset_) { const std::string err = CPLGetLastErrorMsg(); if (err.size() == 0) { throw datasource_exception("OGR Plugin: connection failed: " + dataset_name_ + " was not found or is not a supported format"); } else { throw datasource_exception("OGR Plugin: " + err); } } // initialize layer boost::optional<std::string> layer_by_name = params_.get<std::string>("layer"); boost::optional<unsigned> layer_by_index = params_.get<unsigned>("layer_by_index"); boost::optional<std::string> layer_by_sql = params_.get<std::string>("layer_by_sql"); int passed_parameters = 0; passed_parameters += layer_by_name ? 1 : 0; passed_parameters += layer_by_index ? 1 : 0; passed_parameters += layer_by_sql ? 1 : 0; if (passed_parameters > 1) { throw datasource_exception("OGR Plugin: you can only select an ogr layer by name " "('layer' parameter), by number ('layer_by_index' parameter), " "or by sql ('layer_by_sql' parameter), " "do not supply 2 or more of them at the same time" ); } if (layer_by_name) { layer_name_ = *layer_by_name; layer_.layer_by_name(dataset_, layer_name_); } else if (layer_by_index) { const unsigned num_layers = dataset_->GetLayerCount(); if (*layer_by_index >= num_layers) { std::ostringstream s; s << "OGR Plugin: only "; s << num_layers; s << " layer(s) exist, cannot find layer by index '" << *layer_by_index << "'"; throw datasource_exception(s.str()); } layer_.layer_by_index(dataset_, *layer_by_index); layer_name_ = layer_.layer_name(); } else if (layer_by_sql) { layer_.layer_by_sql(dataset_, *layer_by_sql); layer_name_ = layer_.layer_name(); } else { std::ostringstream s; s << "OGR Plugin: missing <layer> or <layer_by_index> or <layer_by_sql> " << "parameter, available layers are: "; unsigned num_layers = dataset_->GetLayerCount(); bool layer_found = false; for (unsigned i = 0; i < num_layers; ++i ) { OGRLayer* ogr_layer = dataset_->GetLayer(i); OGRFeatureDefn* ogr_layer_def = ogr_layer->GetLayerDefn(); if (ogr_layer_def != 0) { layer_found = true; s << " '" << ogr_layer_def->GetName() << "' "; } } if (! layer_found) { s << "None (no layers were found in dataset)"; } throw datasource_exception(s.str()); } if (! layer_.is_valid()) { std::string s("OGR Plugin: "); if (layer_by_name) { s += "cannot find layer by name '" + *layer_by_name; } else if (layer_by_index) { s += "cannot find layer by index number '" + *layer_by_index; } else if (layer_by_sql) { s += "cannot find layer by sql query '" + *layer_by_sql; } s += "' in dataset '" + dataset_name_ + "'"; throw datasource_exception(s); } // work with real OGR layer OGRLayer* layer = layer_.layer(); // initialize envelope OGREnvelope envelope; layer->GetExtent(&envelope); extent_.init(envelope.MinX, envelope.MinY, envelope.MaxX, envelope.MaxY); // scan for index file // TODO - layer names don't match dataset name, so this will break for // any layer types of ogr than shapefiles, etc // fix here and in ogrindex size_t breakpoint = dataset_name_.find_last_of("."); if (breakpoint == std::string::npos) { breakpoint = dataset_name_.length(); } index_name_ = dataset_name_.substr(0, breakpoint) + ".ogrindex"; std::ifstream index_file(index_name_.c_str(), std::ios::in | std::ios::binary); if (index_file) { indexed_ = true; index_file.close(); } #if 0 // TODO - enable this warning once the ogrindex tool is a bit more stable/mature else { std::clog << "### Notice: no ogrindex file found for " << dataset_name_ << ", use the 'ogrindex' program to build an index for faster rendering" << std::endl; } #endif // deal with attributes descriptions OGRFeatureDefn* def = layer->GetLayerDefn(); if (def != 0) { const int fld_count = def->GetFieldCount(); for (int i = 0; i < fld_count; i++) { OGRFieldDefn* fld = def->GetFieldDefn(i); const std::string fld_name = fld->GetNameRef(); const OGRFieldType type_oid = fld->GetType(); switch (type_oid) { case OFTInteger: desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Integer)); break; case OFTReal: desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Double)); break; case OFTString: case OFTWideString: // deprecated desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::String)); break; case OFTBinary: desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Object)); break; case OFTIntegerList: case OFTRealList: case OFTStringList: case OFTWideStringList: // deprecated ! #ifdef MAPNIK_DEBUG std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl; #endif break; case OFTDate: case OFTTime: case OFTDateTime: // unhandled ! #ifdef MAPNIK_DEBUG std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl; #endif desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Object)); break; default: // unknown #ifdef MAPNIK_DEBUG std::clog << "OGR Plugin: unknown type_oid=" << type_oid << std::endl; #endif break; } } } is_bound_ = true; }
MyOGRHandler(const std::string& driver_name, const std::string& filename) { OGRRegisterAll(); OGRSFDriver* driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driver_name.c_str()); if (!driver) { std::cerr << driver_name << " driver not available.\n"; exit(1); } CPLSetConfigOption("OGR_SQLITE_SYNCHRONOUS", "FALSE"); const char* options[] = { "SPATIALITE=TRUE", nullptr }; m_data_source = driver->CreateDataSource(filename.c_str(), const_cast<char**>(options)); if (!m_data_source) { std::cerr << "Creation of output file failed.\n"; exit(1); } OGRSpatialReference sparef; sparef.importFromProj4(m_factory.proj_string().c_str()); m_layer_point = m_data_source->CreateLayer("postboxes", &sparef, wkbPoint, nullptr); if (!m_layer_point) { std::cerr << "Layer creation failed.\n"; exit(1); } OGRFieldDefn layer_point_field_id("id", OFTReal); layer_point_field_id.SetWidth(10); if (m_layer_point->CreateField(&layer_point_field_id) != OGRERR_NONE) { std::cerr << "Creating id field failed.\n"; exit(1); } OGRFieldDefn layer_point_field_operator("operator", OFTString); layer_point_field_operator.SetWidth(30); if (m_layer_point->CreateField(&layer_point_field_operator) != OGRERR_NONE) { std::cerr << "Creating operator field failed.\n"; exit(1); } /* Transactions might make things faster, then again they might not. Feel free to experiment and benchmark and report back. */ m_layer_point->StartTransaction(); m_layer_linestring = m_data_source->CreateLayer("roads", &sparef, wkbLineString, nullptr); if (!m_layer_linestring) { std::cerr << "Layer creation failed.\n"; exit(1); } OGRFieldDefn layer_linestring_field_id("id", OFTReal); layer_linestring_field_id.SetWidth(10); if (m_layer_linestring->CreateField(&layer_linestring_field_id) != OGRERR_NONE) { std::cerr << "Creating id field failed.\n"; exit(1); } OGRFieldDefn layer_linestring_field_type("type", OFTString); layer_linestring_field_type.SetWidth(30); if (m_layer_linestring->CreateField(&layer_linestring_field_type) != OGRERR_NONE) { std::cerr << "Creating type field failed.\n"; exit(1); } m_layer_linestring->StartTransaction(); m_layer_polygon = m_data_source->CreateLayer("buildings", &sparef, wkbMultiPolygon, nullptr); if (!m_layer_polygon) { std::cerr << "Layer creation failed.\n"; exit(1); } OGRFieldDefn layer_polygon_field_id("id", OFTInteger); layer_polygon_field_id.SetWidth(10); if (m_layer_polygon->CreateField(&layer_polygon_field_id) != OGRERR_NONE) { std::cerr << "Creating id field failed.\n"; exit(1); } OGRFieldDefn layer_polygon_field_type("type", OFTString); layer_polygon_field_type.SetWidth(30); if (m_layer_polygon->CreateField(&layer_polygon_field_type) != OGRERR_NONE) { std::cerr << "Creating type field failed.\n"; exit(1); } m_layer_polygon->StartTransaction(); }
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::ChangeBlockState(GNMGFID nFID, bool bIsBlock) { if(!m_bIsGraphLoaded && LoadGraph() != CE_None) { return CE_Failure; } // change block state in layer OGRLayer* poLayer = GetLayerByName(m_moFeatureFIDMap[nFID]); if(NULL == poLayer) { CPLError( CE_Failure, CPLE_AppDefined, "Failed to get layer '%s'.", m_moFeatureFIDMap[nFID].c_str() ); return CE_Failure; } OGRFeature* poFeature = poLayer->GetFeature(nFID); if(NULL == poFeature) { CPLError( CE_Failure, CPLE_AppDefined, "Failed to get feature '" GNMGFIDFormat"'.", nFID ); return CE_Failure; } 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 ); GNMGFID nSrcFID, nTgtFID, nConFID; // change block state in graph layer m_poGraphLayer->ResetReading(); while ((poFeature = m_poGraphLayer->GetNextFeature()) != NULL) { nSrcFID = poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_SOURCE); nTgtFID = poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_TARGET); nConFID = poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_CONNECTOR); int nBlockState = poFeature->GetFieldAsInteger(GNM_SYSFIELD_BLOCKED); if(bIsBlock) { if(nSrcFID == nFID) nBlockState |= GNM_BLOCK_SRC; else if(nTgtFID == nFID) nBlockState |= GNM_BLOCK_TGT; else if(nConFID == nFID) nBlockState |= GNM_BLOCK_CONN; poFeature->SetField( GNM_SYSFIELD_BLOCKED, nBlockState ); } else { if(nSrcFID == nFID) nBlockState &= ~GNM_BLOCK_SRC; else if(nTgtFID == nFID) nBlockState &= ~GNM_BLOCK_TGT; else if(nConFID == nFID) nBlockState &= ~GNM_BLOCK_CONN; poFeature->SetField( GNM_SYSFIELD_BLOCKED, nBlockState ); } 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 block state in graph m_oGraph.ChangeBlockState(nFID, bIsBlock); return CE_None; }
bool rspfOgrVectorTileSource::open() { const char* MODULE = "rspfOgrVectorTileSource::open"; if (isOgrVectorDataSource() == false) { close(); return false; } if(isOpen()) { close(); } theDataSource = OGRSFDriverRegistrar::Open(theImageFile, false); if (theDataSource) { int layerCount = theDataSource->GetLayerCount(); theLayerVector.resize(layerCount); if(layerCount) { for(int i = 0; i < layerCount; ++i) { OGRLayer* layer = theDataSource->GetLayer(i); if(layer) { OGRSpatialReference* spatialReference = layer->GetSpatialRef(); if(!spatialReference) { if(traceDebug()) { rspfNotify(rspfNotifyLevel_NOTICE) << MODULE << " No spatial reference given, assuming geographic" << endl; } } } else { if(traceDebug()) { rspfNotify(rspfNotifyLevel_NOTICE) << MODULE << " layer " << i << " is null." << endl; } } if (layer) { layer->GetExtent(&theBoundingExtent, true); rspfRefPtr<rspfProjection> proj = createProjFromReference(layer->GetSpatialRef()); rspfRefPtr<rspfImageGeometry> imageGeometry = 0; bool isDefaultProjection = false; if(proj.valid()) { imageGeometry = new rspfImageGeometry(0, proj.get()); } rspfMapProjection* mapProj = 0; if(imageGeometry.valid()) { mapProj = PTR_CAST(rspfMapProjection, imageGeometry->getProjection()); } else { mapProj = createDefaultProj(); imageGeometry = new rspfImageGeometry(0, mapProj); isDefaultProjection = true; } if(mapProj) { rspfDrect rect(theBoundingExtent.MinX, theBoundingExtent.MaxY, theBoundingExtent.MaxX, theBoundingExtent.MinY, RSPF_RIGHT_HANDED); std::vector<rspfGpt> points; if (isDefaultProjection || mapProj->isGeographic()) { rspfGpt g1(rect.ul().y, rect.ul().x); rspfGpt g2(rect.ur().y, rect.ur().x); rspfGpt g3(rect.lr().y, rect.lr().x); rspfGpt g4(rect.ll().y, rect.ll().x); points.push_back(g1); points.push_back(g2); points.push_back(g3); points.push_back(g4); } else { rspfGpt g1 = mapProj->inverse(rect.ul()); rspfGpt g2 = mapProj->inverse(rect.ur()); rspfGpt g3 = mapProj->inverse(rect.lr()); rspfGpt g4 = mapProj->inverse(rect.ll()); points.push_back(g1); points.push_back(g2); points.push_back(g3); points.push_back(g4); } std::vector<rspfDpt> rectTmp; rectTmp.resize(4); for(std::vector<rspfGpt>::size_type index=0; index < 4; ++index) { imageGeometry->worldToLocal(points[(int)index], rectTmp[(int)index]); } rspfDrect rect2 = rspfDrect(rectTmp[0], rectTmp[1], rectTmp[2], rectTmp[3]); theLayerVector[i] = new rspfOgrVectorLayerNode(rect2); theLayerVector[i]->setGeoImage(imageGeometry); if (i == 0) theImageGeometry = imageGeometry; } } } } } else { delete theDataSource; theDataSource = 0; return false; } return (theDataSource!=0); }
void ShpReader::VectorMetaDataInfo(OGRDataSource* OGRDataset, StudyControllerPtr studyController, VectorMapControllerPtr vectorMapController) { vFileMetaData* vHeader = vectorMapController->GetVectorMapModel()->GetVectorMetaData(); OGRLayer *poLayer = OGRDataset->GetLayer( 0 ); char *originalWkt = NULL; char *destinationWkt = NULL; OGREnvelope psEnvelope; poLayer->GetExtent( &psEnvelope ); vHeader->originalExtents.x = psEnvelope.MinX; vHeader->originalExtents.dx = psEnvelope.MaxX; vHeader->originalExtents.y = psEnvelope.MinY; vHeader->originalExtents.dy = psEnvelope.MaxY; Log::Inst().Write("Original Extents: "); Log::Inst().Write(_T("Lower, Left (x,y): ") +wxString(StringTools::ToStringW(vHeader->originalExtents.x, 2).c_str()) + _T(", ") + wxString(StringTools::ToStringW(vHeader->originalExtents.y, 2).c_str())); Log::Inst().Write(_T("Upper, Right (x,y): ") +wxString(StringTools::ToStringW(vHeader->originalExtents.dx, 2).c_str()) + _T(", ") + wxString(StringTools::ToStringW(vHeader->originalExtents.dy, 2).c_str())); vHeader->numFeatures= poLayer->GetFeatureCount(); Log::Inst().Write("Number of Features: " + StringTools::ToString(vHeader->numFeatures)); std::string type; OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn(); if ( wkbFlatten( poFDefn->GetGeomType() ) == wkbPoint || wkbFlatten( poFDefn->GetGeomType() ) == wkbMultiPoint ) type="Point"; else if ( wkbFlatten(poFDefn->GetGeomType() ) == wkbLineString || wkbFlatten(poFDefn->GetGeomType() ) == wkbMultiLineString ) type="Polyline"; else if ( wkbFlatten( poFDefn->GetGeomType() ) == wkbPolygon || wkbFlatten( poFDefn->GetGeomType() ) == wkbMultiPolygon ) type="Polygon"; else type="Unknown"; vHeader->geometryType=type; Log::Inst().Write("Geometry Type: "+ type); OGRSpatialReference* originalShpSR = poLayer->GetSpatialRef(); if (originalShpSR != NULL) { originalShpSR->exportToWkt(&originalWkt); vHeader->originalProjection = std::string(originalWkt); } Log::Inst().Write("Original Projection: " + vHeader->originalProjection); Log::Inst().Write(""); ProjectionToolPtr projTool = studyController->GetProjectionTool(); if (projTool != NULL) { OGRSpatialReference *destinationCS= projTool->GetTargetCS (); destinationCS->exportToWkt(&destinationWkt); vHeader->destinationProjection = std::string(destinationWkt); } vHeader->currentExtents.x = vectorMapController->GetVectorMapModel()->GetVectorBoundary_MinX(); vHeader->currentExtents.y = vectorMapController->GetVectorMapModel()->GetVectorBoundary_MinY(); vHeader->currentExtents.dx = vectorMapController->GetVectorMapModel()->GetVectorBoundary_MaxX(); vHeader->currentExtents.dy = vectorMapController->GetVectorMapModel()->GetVectorBoundary_MaxY(); //Log::Inst().Write("Upper, Right (x,y): " + // StringTools::ToString(vHeader->currentExtents.dx) + ", " + //StringTools::ToString(vHeader->currentExtents.dy)); }
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; }
CPLErr GNMGenericNetwork::CreateMetadataLayer(GDALDataset * const pDS, int nVersion, size_t nFieldSize) { OGRLayer* pMetadataLayer = pDS->CreateLayer(GNM_SYSLAYER_META, NULL, wkbNone, NULL); if (NULL == pMetadataLayer) { CPLError( CE_Failure, CPLE_AppDefined, "Creation of '%s' layer failed", GNM_SYSLAYER_META ); return CE_Failure; } OGRFieldDefn oFieldKey(GNM_SYSFIELD_PARAMNAME, OFTString); oFieldKey.SetWidth(static_cast<int>(nFieldSize)); OGRFieldDefn oFieldValue(GNM_SYSFIELD_PARAMVALUE, OFTString); oFieldValue.SetWidth(static_cast<int>(nFieldSize)); if(pMetadataLayer->CreateField(&oFieldKey) != OGRERR_NONE || pMetadataLayer->CreateField(&oFieldValue) != OGRERR_NONE) { CPLError( CE_Failure, CPLE_AppDefined, "Creation of layer '%s' fields failed", GNM_SYSLAYER_META ); return CE_Failure; } OGRFeature *poFeature; // write name poFeature = OGRFeature::CreateFeature(pMetadataLayer->GetLayerDefn()); poFeature->SetField(GNM_SYSFIELD_PARAMNAME, GNM_MD_NAME); poFeature->SetField(GNM_SYSFIELD_PARAMVALUE, m_soName); if(pMetadataLayer->CreateFeature(poFeature) != OGRERR_NONE) { OGRFeature::DestroyFeature( poFeature ); CPLError( CE_Failure, CPLE_AppDefined, "Write GNM name failed"); return CE_Failure; } OGRFeature::DestroyFeature(poFeature); // write version poFeature = OGRFeature::CreateFeature(pMetadataLayer->GetLayerDefn()); poFeature->SetField(GNM_SYSFIELD_PARAMNAME, GNM_MD_VERSION); poFeature->SetField(GNM_SYSFIELD_PARAMVALUE, CPLSPrintf("%d", nVersion)); if(pMetadataLayer->CreateFeature(poFeature) != OGRERR_NONE) { OGRFeature::DestroyFeature( poFeature ); CPLError( CE_Failure, CPLE_AppDefined, "Write GNM version failed"); return CE_Failure; } OGRFeature::DestroyFeature(poFeature); // write description if(!sDescription.empty()) { poFeature = OGRFeature::CreateFeature(pMetadataLayer->GetLayerDefn()); poFeature->SetField(GNM_SYSFIELD_PARAMNAME, GNM_MD_DESCR); poFeature->SetField(GNM_SYSFIELD_PARAMVALUE, sDescription); if(pMetadataLayer->CreateFeature(poFeature) != OGRERR_NONE) { OGRFeature::DestroyFeature( poFeature ); CPLError( CE_Failure, CPLE_AppDefined, "Write GNM description failed"); return CE_Failure; } OGRFeature::DestroyFeature(poFeature); } // write srs if < 254 or create file if(!m_soSRS.empty()) { if(m_soSRS.size() >= nFieldSize) { // cppcheck-suppress knownConditionTrueFalse if(StoreNetworkSrs() != CE_None) return CE_Failure; } else { poFeature = OGRFeature::CreateFeature(pMetadataLayer->GetLayerDefn()); poFeature->SetField(GNM_SYSFIELD_PARAMNAME, GNM_MD_SRS); poFeature->SetField(GNM_SYSFIELD_PARAMVALUE, m_soSRS); if(pMetadataLayer->CreateFeature(poFeature) != OGRERR_NONE) { OGRFeature::DestroyFeature( poFeature ); CPLError( CE_Failure, CPLE_AppDefined, "Write GNM SRS failed"); return CE_Failure; } OGRFeature::DestroyFeature(poFeature); } } m_poMetadataLayer = pMetadataLayer; m_nVersion = nVersion; // create default rule return CreateRule("ALLOW CONNECTS ANY"); }
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; }
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; }