int main(int argc, char **argv) { // Get data from ogr OGRRegisterAll(); std::cout << "Opening: " << argv[1] << std::endl; OGRDataSource *shp = OGRSFDriverRegistrar::Open(argv[1], FALSE); IsValid(shp, "Error opening file."); std::cout << "Shape contains " << shp->GetLayerCount() << " layers." << std::endl; OGRLayer *layer = shp->GetLayerByName(argv[2]); IsValid(layer, "Couldn't grab layer"); OGRSpatialReference *srcSRS = NULL; srcSRS = layer->GetSpatialRef(); // Set up writing const char *kDriverName = "ESRI Shapefile"; OGRSFDriver *shpDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(kDriverName); IsValid(shpDriver, "Couldn't grab the shapefile driver."); IsValid(argv[3], "Please provide a output shp."); std::cout << "Writing to: " << argv[3] << std::endl; OGRDataSource *shpOut = shpDriver->CreateDataSource(argv[3], NULL); IsValid(shpOut, "Couldn't open output file"); OGRLayer *outLayer = shpOut->CreateLayer(layer->GetName(), srcSRS, wkbMultiLineString, NULL); IsValid(outLayer, "Couldn't create an output layer"); // copy over the fields from the source file OGRFeatureDefn *source = layer->GetLayerDefn(); for(int i=0; i < source->GetFieldCount(); i++){ OGRFieldDefn *field = source->GetFieldDefn(i); if(outLayer->CreateField(field) != OGRERR_NONE) { std::cout << "Couldn't make layer" << std::endl; exit(1); }; } // Loop through features and grab the hull and put it into CGAL then // skeletonize the points OGRFeature *feature; int count = 0; while((feature = layer->GetNextFeature()) != NULL) { OGRMultiPolygon *geometry = dynamic_cast<OGRMultiPolygon *>(OGRGeometryFactory::forceToMultiPolygon(feature->GetGeometryRef())); IsValid(geometry, "No geometry."); OGRFeature *outFeature = OGRFeature::CreateFeature(outLayer->GetLayerDefn()); IsValid(outFeature, "Couldn't make a feature."); for(int i=0; i < source->GetFieldCount(); i++){ OGRField *field = feature->GetRawFieldRef(i); outFeature->SetField(i, field); } OGRGeometry* line = NULL; for(int i=0; i < geometry->getNumGeometries(); i++){ OGRGeometry* segment = BuildMultiLine(geometry->getGeometryRef(i)); if(segment != NULL){ if(line == NULL) { line = new OGRLineString; } OGRGeometry* tmp = line->Union(segment); if(tmp != NULL){ delete line; line = tmp; } delete segment; } } outFeature->SetGeometry(line); if(outLayer->CreateFeature(outFeature) != OGRERR_NONE){ std::cout << "Couldn't create feature." << std::endl; exit(1); } // clean up OGRFeature::DestroyFeature(outFeature); std::cout << std::endl << ++count << std::endl; } // cleanup OGRDataSource::DestroyDataSource(shp); OGRDataSource::DestroyDataSource(shpOut); return 0; }
OGRLayer* init_layer(const std::string& name, const stringv& fields, const OGRwkbGeometryType type) { std::cerr << "Creating layer: " << name << "\n"; OGRLayer* layer = m_data_source->CreateLayer(name.c_str(), &m_srs_out, type, NULL); if (layer == NULL) { std::cerr << "Layer creation failed (" << name << ").\n"; exit(1); } std::cerr << " Creating field: osm_id\n"; OGRFieldDefn field_osm_id("osm_id", OFTString); field_osm_id.SetWidth(11); if (layer->CreateField(&field_osm_id) != OGRERR_NONE ) { std::cerr << "Creating field 'osm_id' failed.\n"; exit(1); } std::cerr << " Creating field: z_order\n"; OGRFieldDefn field_z_order("z_order", OFTInteger); field_z_order.SetWidth(4); if (layer->CreateField(&field_z_order) != OGRERR_NONE ) { std::cerr << "Creating field 'z_order' failed.\n"; exit(1); } std::cerr << " Creating field: way_area\n"; OGRFieldDefn field_way_area("way_area", OFTReal); field_way_area.SetWidth(10); if (layer->CreateField(&field_way_area) != OGRERR_NONE ) { std::cerr << "Creating field 'way_area' failed.\n"; exit(1); } stringv::const_iterator it; for (it = fields.begin(); it != fields.end(); ++it) { std::cerr << " Creating field: " << *it << "\n"; OGRFieldDefn field_tag((*it).c_str(), OFTString); field_tag.SetWidth(255); if (layer->CreateField(&field_tag) != OGRERR_NONE ) { std::cerr << "Creating field '" << *it << "' failed.\n"; exit(1); } } return layer; }
OGRLayer *GNMDatabaseNetwork::ICreateLayer(const char *pszName, CPL_UNUSED OGRSpatialReference *poSpatialRef, OGRwkbGeometryType eGType, char **papszOptions) { //check if layer with such name exist for(int i = 0; i < GetLayerCount(); ++i) { OGRLayer* pLayer = GetLayer(i); if(NULL == pLayer) continue; if(EQUAL(pLayer->GetName(), pszName)) { CPLError( CE_Failure, CPLE_IllegalArg, "The network layer '%s' already exist.", pszName ); return NULL; } } OGRSpatialReference oSpaRef(m_soSRS); OGRLayer *poLayer = m_poDS->CreateLayer( pszName, &oSpaRef, eGType, papszOptions ); if( poLayer == NULL ) { CPLError( CE_Failure, CPLE_FileIO, "Layer creation failed." ); return NULL; } OGRFieldDefn oField( GNM_SYSFIELD_GFID, GNMGFIDInt ); if( poLayer->CreateField( &oField ) != OGRERR_NONE ) { CPLError( CE_Failure, CPLE_FileIO, "Creating global identificator field failed." ); return NULL; } OGRFieldDefn oFieldBlock(GNM_SYSFIELD_BLOCKED, OFTInteger); if( poLayer->CreateField( &oFieldBlock ) != OGRERR_NONE ) { CPLError( CE_Failure, CPLE_FileIO, "Creating is blocking field failed." ); return NULL; } GNMGenericLayer* pGNMLayer = new GNMGenericLayer(poLayer, this); m_apoLayers.push_back(pGNMLayer); return pGNMLayer; }
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'"); } }
void SaveGeometry(const CPLString &path, const OGRPolygon &polygon, const OGRSpatialReference &spaRef) { const char *pszDriverName = "ESRI Shapefile"; GDALDriver *poDriver = GetGDALDriverManager()->GetDriverByName(pszDriverName ); if( poDriver == NULL ) { printf( "%s driver not available.\n", pszDriverName ); exit( 1 ); } GDALDataset *poDS = poDriver->Create( path, 0, 0, 0, GDT_Unknown, NULL ); if( poDS == NULL ) { printf( "Creation of output file failed.\n" ); exit( 1 ); } const char* pszLayerName = CPLGetBasename(path); OGRLayer *poLayer = poDS->CreateLayer( pszLayerName, spaRef.Clone(), wkbPolygon, NULL ); if( poLayer == NULL ) { printf( "Layer creation failed.\n" ); exit( 1 ); } OGRFieldDefn oField( "Name", OFTString ); oField.SetWidth(32); if( poLayer->CreateField( &oField ) != OGRERR_NONE ) { printf( "Creating Name field failed.\n" ); exit( 1 ); } OGRFeature *poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() ); //poFeature->SetField( "Name", szName ); poFeature->SetGeometry( polygon.clone() ); if( poLayer->CreateFeature( poFeature ) != OGRERR_NONE ) { printf( "Failed to create feature in shapefile.\n" ); exit( 1 ); } OGRFeature::DestroyFeature( poFeature ); GDALClose( poDS ); }
void ShapefileWriter::writePoints(shared_ptr<const OsmMap> map, const QString& path) { OGRRegisterAll(); _removeShapefile(path); const char *pszDriverName = "ESRI Shapefile"; OGRSFDriver *poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(pszDriverName); if( poDriver == NULL ) { throw HootException(QString("%1 driver not available.").arg(pszDriverName)); } OGRDataSource* poDS = poDriver->CreateDataSource(path.toAscii(), NULL ); if( poDS == NULL ) { throw HootException(QString("Data source creation failed. %1").arg(path)); } OgrOptions options; options["ENCODING"] = "UTF-8"; OGRLayer *poLayer; QString layerName; layerName = QFileInfo(path).baseName(); poLayer = poDS->CreateLayer(layerName.toAscii(), map->getProjection().get(), wkbPoint, options.getCrypticOptions()); if( poLayer == NULL ) { throw HootException(QString("Layer creation failed. %1").arg(path)); } QStringList shpColumns; QStringList columns = getColumns(map, ElementType::Node); for (int i = 0; i < columns.size(); i++) { OGRFieldDefn oField(columns[i].toAscii(), OFTString); oField.SetWidth(64); if( poLayer->CreateField( &oField ) != OGRERR_NONE ) { throw HootException(QString("Error creating field (%1).").arg(columns[i])); } shpColumns.append(poLayer->GetLayerDefn()->GetFieldDefn(i)->GetNameRef()); } if (_includeInfo) { OGRFieldDefn oField("error_circ", OFTReal); if( poLayer->CreateField( &oField ) != OGRERR_NONE ) { throw HootException(QString("Error creating field (error:circular).")); } _circularErrorIndex = poLayer->GetLayerDefn()->GetFieldCount() - 1; } const NodeMap& nodes = map->getNodeMap(); for (NodeMap::const_iterator it = nodes.begin(); it != nodes.end(); ++it) { const shared_ptr<Node>& node = it->second; if (node->getTags().getNonDebugCount() > 0) { OGRFeature* poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() ); // set all the column values. for (int i = 0; i < columns.size(); i++) { if (node->getTags().contains(columns[i])) { QByteArray c = shpColumns[i].toAscii(); QByteArray v = node->getTags()[columns[i]].toUtf8(); poFeature->SetField(c.constData(), v.constData()); } } if (_includeInfo) { poFeature->SetField(_circularErrorIndex, node->getCircularError()); } // convert the geometry. OGRGeometry* geom = new OGRPoint(node->getX(), node->getY()); if (poFeature->SetGeometryDirectly(geom) != OGRERR_NONE) { throw HootException(QString("Error setting geometry")); } if (poLayer->CreateFeature(poFeature) != OGRERR_NONE) { throw HootException(QString("Error creating feature")); } OGRFeature::DestroyFeature(poFeature); } } OGRDataSource::DestroyDataSource(poDS); }
void ShapefileWriter::writeLines(shared_ptr<const OsmMap> map, const QString& path) { OGRRegisterAll(); _removeShapefile(path); const char *pszDriverName = "ESRI Shapefile"; OGRSFDriver *poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(pszDriverName); if( poDriver == NULL ) { throw HootException(QString("%1 driver not available.").arg(pszDriverName)); } OGRDataSource* poDS = poDriver->CreateDataSource(path.toAscii(), NULL ); if( poDS == NULL ) { throw HootException(QString("Data source creation failed. %1").arg(path)); } OGRLayer *poLayer; OgrOptions options; options["ENCODING"] = "UTF-8"; QString layerName; layerName = QFileInfo(path).baseName(); poLayer = poDS->CreateLayer(layerName.toAscii(), map->getProjection().get(), wkbLineString, options.getCrypticOptions()); if( poLayer == NULL ) { throw HootException(QString("Layer creation failed. %1").arg(path)); } QStringList shpColumns; QStringList columns = getColumns(map, ElementType::Way); for (int i = 0; i < columns.size(); i++) { OGRFieldDefn oField(columns[i].toAscii(), OFTString); oField.SetWidth(64); if( poLayer->CreateField( &oField ) != OGRERR_NONE ) { throw HootException(QString("Error creating field (%1).").arg(columns[i])); } shpColumns.append(poLayer->GetLayerDefn()->GetFieldDefn(i)->GetNameRef()); } if (_includeInfo) { OGRFieldDefn oField("error_circ", OFTReal); if( poLayer->CreateField( &oField ) != OGRERR_NONE ) { throw HootException(QString("Error creating field (error:circular).")); } _circularErrorIndex = poLayer->GetLayerDefn()->GetFieldCount() - 1; } const WayMap& ways = map->getWays(); for (WayMap::const_iterator it = ways.begin(); it != ways.end(); it++) { shared_ptr<Way> way = it->second; if (OsmSchema::getInstance().isArea(way) == false) { OGRFeature* poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() ); // set all the column values. for (int i = 0; i < columns.size(); i++) { if (way->getTags().contains(columns[i])) { QByteArray c = shpColumns[i].toAscii(); QByteArray v = way->getTags()[columns[i]].toUtf8(); poFeature->SetField(c.constData(), v.constData()); } } if (_includeInfo) { poFeature->SetField(_circularErrorIndex, way->getCircularError()); } // convert the geometry. std::string wkt = ElementConverter(map).convertToLineString(way)->toString(); char* t = (char*)wkt.data(); OGRGeometry* geom; if (OGRGeometryFactory::createFromWkt(&t, poLayer->GetSpatialRef(), &geom) != OGRERR_NONE) { throw HootException(QString("Error parsing WKT (%1)").arg(QString::fromStdString(wkt))); } if (poFeature->SetGeometryDirectly(geom) != OGRERR_NONE) { throw HootException(QString("Error setting geometry")); } if (poLayer->CreateFeature(poFeature) != OGRERR_NONE) { throw HootException(QString("Error creating feature")); } OGRFeature::DestroyFeature(poFeature); } } OGRDataSource::DestroyDataSource(poDS); }
OGRLayer *OGRDataSource::CopyLayer( OGRLayer *poSrcLayer, const char *pszNewName, char **papszOptions ) { OGRFeatureDefn *poSrcDefn = poSrcLayer->GetLayerDefn(); OGRLayer *poDstLayer = NULL; /* -------------------------------------------------------------------- */ /* Create the layer. */ /* -------------------------------------------------------------------- */ if( !TestCapability( ODsCCreateLayer ) ) { CPLError( CE_Failure, CPLE_NotSupported, "This datasource does not support creation of layers." ); return NULL; } CPLErrorReset(); poDstLayer = CreateLayer( pszNewName, poSrcLayer->GetSpatialRef(), poSrcDefn->GetGeomType(), papszOptions ); if( poDstLayer == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* Add fields. Default to copy all field. */ /* If only a subset of all fields requested, then output only */ /* the selected fields, and in the order that they were */ /* selected. */ /* -------------------------------------------------------------------- */ int iField; for( iField = 0; iField < poSrcDefn->GetFieldCount(); iField++ ) poDstLayer->CreateField( poSrcDefn->GetFieldDefn(iField) ); /* -------------------------------------------------------------------- */ /* Transfer features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature; poSrcLayer->ResetReading(); while( TRUE ) { OGRFeature *poDstFeature = NULL; poFeature = poSrcLayer->GetNextFeature(); if( poFeature == NULL ) break; CPLErrorReset(); poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() ); if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE ) { delete poFeature; CPLError( CE_Failure, CPLE_AppDefined, "Unable to translate feature %d from layer %s.\n", poFeature->GetFID(), poSrcDefn->GetName() ); return poDstLayer; } poDstFeature->SetFID( poFeature->GetFID() ); OGRFeature::DestroyFeature( poFeature ); CPLErrorReset(); if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE ) { OGRFeature::DestroyFeature( poDstFeature ); return poDstLayer; } OGRFeature::DestroyFeature( poDstFeature ); } return poDstLayer; }
TestHandler(OGRDataSource* data_source) : m_data_source(data_source), m_out("multipolygon-tests.json") { OGRSpatialReference sparef; sparef.SetWellKnownGeogCS("WGS84"); /**************/ m_layer_point = m_data_source->CreateLayer("points", &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_type("type", OFTString); layer_point_field_type.SetWidth(30); if (m_layer_point->CreateField(&layer_point_field_type) != OGRERR_NONE) { std::cerr << "Creating type field failed.\n"; exit(1); } /**************/ m_layer_linestring = m_data_source->CreateLayer("lines", &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_polygon = m_data_source->CreateLayer("multipolygons", &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_from_type("from_type", OFTString); layer_polygon_field_from_type.SetWidth(1); if (m_layer_polygon->CreateField(&layer_polygon_field_from_type) != OGRERR_NONE) { std::cerr << "Creating from_type field failed.\n"; exit(1); } }
void writePolygons(RegionMap* regionMap) { char* driverName = (char *)ogrDriver->c_str(); char* outFilePath = (char *)outFile->c_str(); cout << "Creating output file \"" << outFilePath << "\" (\"" << driverName << "\" format)..."; OGRSFDriver* driver = (OGRSFDriver*)OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(ogrDriver->c_str()); if (driver == NULL) { localExit(new string(string("FATAL: OGR driver \"") + string(driverName) + string("\" is not available.\n")), 1); } char* dataSourceName = NULL; bool cleanupDataSource = false; if (ogrDriver->compare("KML") == 0 && kmlStyleFile != NULL) { dataSourceName = tmpnam(NULL); //mkstemp(dataSourceName); cleanupDataSource = true; } else if (ogrDriver->compare("ESRI Shapefile") == 0) { string* dsStr = removeFromLastOccurrence(outFilePath, '/'); dsStr = removeFromLastOccurrence((char *)dsStr->c_str(), '\\'); dataSourceName = (char *)dsStr->c_str(); } else { dataSourceName = outFilePath; } OGRDataSource* ds = driver->CreateDataSource(dataSourceName); if(ds == NULL) { localExit(new string(string("FATAL: Unable to create output file \"") + string(outFilePath) + string("\"\n")), 1); } cout << "[ok]\n"; OGRCoordinateTransformation* transform = NULL; const string* rmSpatialRefStr = regionMap->getSpatialRef(); if (rmSpatialRefStr != NULL && rmSpatialRefStr->compare("") != 0) { OGRSpatialReference* spatialRef = new OGRSpatialReference(rmSpatialRefStr->c_str()); transform = OGRCreateCoordinateTransformation(spatialRef, outSpatialRef); } char* layerName = (char *)pointToFilename(outFilePath, true)->c_str(); OGRLayer* layer = ds->CreateLayer(layerName, outSpatialRef, wkbPolygon); layer->CreateField(new OGRFieldDefn("RegionID", OFTInteger), 0); layer->CreateField(new OGRFieldDefn("Category", OFTString), 0); layer->CreateField(new OGRFieldDefn("Threshold", OFTReal), 0); cout << "Writing polygon data to file..."; int count = 0; int currRegionID = 0; int numRegions = regionMap->getNumRegions(); while (currRegionID < numRegions) { Region *currRegion = regionMap->getRegion(currRegionID); Polygon* poly = currRegion->toPolygon(); if(poly == NULL) { currRegionID += 1; continue; } count++; OGRFeature* feature = new OGRFeature(layer->GetLayerDefn()); feature->SetField(feature->GetFieldIndex("RegionID"), currRegionID); feature->SetField(feature->GetFieldIndex("Category"), currRegion->getCategory()->getName()->c_str()); feature->SetField(feature->GetFieldIndex("Threshold"), currRegion->getCategory()->minThreshold()); OGRGeometry* geom = BuildOgrPolygon(poly, transform); feature->SetGeometry(geom); if (layer->CreateFeature(feature) != OGRERR_NONE) localExit(new string("ERROR: Unable to create feature for region #\n"), 2); //OGRFeature::DestroyFeature(feature); currRegionID += 1; if (currRegionID % 100 == 0) cout << "."; } //CPLFree(transform); //CPLFree(layer); OGRDataSource::DestroyDataSource(ds); cout << "[ok] Wrote "<< count << " polygons\n"; if(kmlStyleFile != NULL) { #ifdef USE_XALAN XALAN_USING_XERCES(XMLPlatformUtils) XALAN_USING_XALAN(XalanTransformer) XMLPlatformUtils::Initialize(); XalanTransformer::initialize(); XalanTransformer theXalanTransformer; cout << "Transforing KML file ..." << outFile->c_str(); if(theXalanTransformer.transform(dataSourceName, kmlStyleFile->c_str(), outFile->c_str()) != 0) { cout << "[!!]\n"; cout << "ERROR doing XSLT transform using " << kmlStyleFile->c_str() << "\n"; } else { cout << "...[ok]\n"; } #endif /* USE_XALAN */ #ifdef USE_LIBXSLT xsltStylesheetPtr cur = NULL; xmlDocPtr doc, res; const char *params[16 + 1]; params[0] = NULL; xmlSubstituteEntitiesDefault(1); xmlLoadExtDtdDefaultValue = 1; cur = xsltParseStylesheetFile((const xmlChar *) kmlStyleFile->c_str()); doc = xmlParseFile(dataSourceName); res = xsltApplyStylesheet(cur, doc, params); FILE* f = fopen(outFile->c_str(), "w"); xsltSaveResultToFile(f, res, cur); fclose(f); xsltFreeStylesheet(cur); xmlFreeDoc(res); xmlFreeDoc(doc); xsltCleanupGlobals(); xmlCleanupParser(); #endif /* USE_LIBXSLT */ } if(cleanupDataSource) { if(!remove(dataSourceName)) { fprintf(stderr, "Error deleting temporary file: %s\n", dataSourceName); } } }
TestOverviewHandler(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.SetWellKnownGeogCS("WGS84"); // nodes layer m_layer_nodes = m_data_source->CreateLayer("nodes", &sparef, wkbPoint, nullptr); if (!m_layer_nodes) { std::cerr << "Layer creation failed.\n"; exit(1); } OGRFieldDefn layer_nodes_field_id("id", OFTReal); layer_nodes_field_id.SetWidth(10); if (m_layer_nodes->CreateField(&layer_nodes_field_id) != OGRERR_NONE) { std::cerr << "Creating id field failed.\n"; exit(1); } // labels layer m_layer_labels = m_data_source->CreateLayer("labels", &sparef, wkbPoint, nullptr); if (!m_layer_labels) { std::cerr << "Layer creation failed.\n"; exit(1); } OGRFieldDefn layer_labels_field_id("id", OFTReal); layer_labels_field_id.SetWidth(10); if (m_layer_labels->CreateField(&layer_labels_field_id) != OGRERR_NONE) { std::cerr << "Creating id field failed.\n"; exit(1); } OGRFieldDefn layer_labels_field_label("label", OFTString); layer_labels_field_label.SetWidth(30); if (m_layer_labels->CreateField(&layer_labels_field_label) != OGRERR_NONE) { std::cerr << "Creating label field failed.\n"; exit(1); } // ways layer m_layer_ways = m_data_source->CreateLayer("ways", &sparef, wkbLineString, nullptr); if (!m_layer_ways) { std::cerr << "Layer creation failed.\n"; exit(1); } OGRFieldDefn layer_way_field_id("id", OFTReal); layer_way_field_id.SetWidth(10); if (m_layer_ways->CreateField(&layer_way_field_id) != OGRERR_NONE) { std::cerr << "Creating id field failed.\n"; exit(1); } OGRFieldDefn layer_way_field_test("test", OFTInteger); layer_way_field_test.SetWidth(3); if (m_layer_ways->CreateField(&layer_way_field_test) != OGRERR_NONE) { std::cerr << "Creating test field failed.\n"; exit(1); } }
bool Shape::save(const std::string& filename) { if (shapeType == -1) { std::cout << "Shape type is not set." << std::endl; return false; } if (shapeObjects.size() == 0) { std::cout << "No shape exists." << std::endl; return false; } const char *pszDriverName = "ESRI Shapefile"; GDALDriver *poDriver; GDALAllRegister(); poDriver = GetGDALDriverManager()->GetDriverByName(pszDriverName); if (poDriver == NULL) { printf("%s driver not available.\n", pszDriverName); return false; } GDALDataset *poDS; poDS = poDriver->Create(filename.c_str(), 0, 0, 0, GDT_Unknown, NULL); if (poDS == NULL) { printf("Creation of output file failed.\n"); return false; } OGRLayer *poLayer; if (shapeType == wkbPoint) { poLayer = poDS->CreateLayer("point_out", NULL, wkbPoint, NULL); } else if (shapeType == wkbLineString) { poLayer = poDS->CreateLayer("point_out", NULL, wkbLineString, NULL); } else if (shapeType == wkbPolygon) { poLayer = poDS->CreateLayer("point_out", NULL, wkbPolygon, NULL); } if (poLayer == NULL) { printf("Layer creation failed.\n"); return false; } for (auto it = shapeObjects[0].attributes.begin(); it != shapeObjects[0].attributes.end(); ++it) { OGRFieldDefn oField(it->first.c_str(), static_cast<OGRFieldType>(it->second.type)); if (it->second.type == OFTString) { oField.SetWidth(it->second.stringValue().size()); } if (poLayer->CreateField(&oField) != OGRERR_NONE) { printf("Creating Name field failed.\n"); return false; } } for (int i = 0; i < shapeObjects.size(); ++i) { if (shapeObjects[i].parts.size() == 0) continue; OGRFeature *poFeature; poFeature = OGRFeature::CreateFeature(poLayer->GetLayerDefn()); // 属性をセット for (auto it = shapeObjects[i].attributes.begin(); it != shapeObjects[i].attributes.end(); ++it) { poFeature->SetField(it->first.c_str(), it->second.stringValue().c_str()); } // ジオメトリ情報をセット if (shapeType == wkbPoint) { OGRPoint point; point.setX(shapeObjects[i].parts[0].points[0].x); point.setY(shapeObjects[i].parts[0].points[0].y); point.setZ(shapeObjects[i].parts[0].points[0].z); poFeature->SetGeometry(&point); } else if (shapeType == wkbLineString) { OGRLineString lineString; for (int k = 0; k < shapeObjects[i].parts[0].points.size(); ++k) { lineString.addPoint(shapeObjects[i].parts[0].points[k].x, shapeObjects[i].parts[0].points[k].y, shapeObjects[i].parts[0].points[k].z); } poFeature->SetGeometry(&lineString); } else if (shapeType == wkbPolygon) { OGRPolygon polygon; for (int j = 0; j < shapeObjects[i].parts.size(); ++j) { OGRLinearRing linearRing; for (int k = 0; k < shapeObjects[i].parts[j].points.size(); ++k) { linearRing.addPoint(shapeObjects[i].parts[j].points[k].x, shapeObjects[i].parts[j].points[k].y, shapeObjects[i].parts[j].points[k].z); } polygon.addRing(&linearRing); } poFeature->SetGeometry(&polygon); } if (poLayer->CreateFeature(poFeature) != OGRERR_NONE) { printf("Failed to create feature in shapefile.\n"); return false; } OGRFeature::DestroyFeature(poFeature); } GDALClose(poDS); return true; }
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"); }
// export bool ImportExportGdal::export_(const QList<Feature *>& featList) { const char *pszDriverName = "SQLite"; OGRSFDriver *poDriver; OGRRegisterAll(); poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(pszDriverName); if( poDriver == NULL ) { qDebug( "%s driver not available.", pszDriverName ); return false; } OGRDataSource *poDS; QFile::remove(QString(HOMEDIR + "/test.sqlite")); poDS = poDriver->CreateDataSource( QString(HOMEDIR + "/test.sqlite").toUtf8().constData(), NULL ); if( poDS == NULL ) { qDebug( "Creation of output file failed." ); return false; } poDS->ExecuteSQL("PRAGMA synchronous = OFF", NULL, NULL); OGRSpatialReference *poSRS; poSRS = new OGRSpatialReference(); poSRS->importFromEPSG(4326); char **papszOptions = NULL; papszOptions = CSLSetNameValue( papszOptions, "SPATIALITE", "YES" ); papszOptions = CSLSetNameValue( papszOptions, "FORMAT", "SPATIALITE" ); papszOptions = CSLSetNameValue( papszOptions, "SPATIAL_INDEX", "YES" ); OGRLayer *poLayer; poLayer = poDS->CreateLayer( "osm", poSRS, wkbUnknown, papszOptions); CSLDestroy( papszOptions ); if( poLayer == NULL ) { qDebug( "Layer creation failed." ); return false; } OGRFieldDefn oField("osm_id", OFTReal); if( poLayer->CreateField( &oField ) != OGRERR_NONE ) { qDebug( "Creating field failed." ); return false; } oField.Set("osm_version", OFTInteger ); poLayer->CreateField( &oField ); oField.Set("osm_timestamp", OFTInteger ); poLayer->CreateField( &oField ); OGRFeature *poFeature; foreach (Feature* F, featList) { poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() ); poFeature->SetField( "osm_id", (qreal)(F->id().numId)); #ifndef FRISIUS_BUILD poFeature->SetField( "osm_version", F->versionNumber()); poFeature->SetField( "osm_timestamp", (int)F->time().toTime_t()); #endif if (CHECK_NODE(F)) { Node* N = STATIC_CAST_NODE(F); OGRPoint pt; pt.setX(N->position().x()); pt.setY(N->position().y()); poFeature->SetGeometry( &pt ); } else if (CHECK_WAY(F)) { Way* W = STATIC_CAST_WAY(F); OGRLineString ls; ls.setNumPoints(W->size()); for (int i=0; i<W->size(); ++i) { ls.setPoint(i, W->getNode(i)->position().x(), W->getNode(i)->position().y(), 0); } poFeature->SetGeometry( &ls ); } if( poLayer->CreateFeature( poFeature ) != OGRERR_NONE ) { qDebug( "Failed to create feature in output." ); return false; } OGRFeature::DestroyFeature( poFeature ); }
void CDlg_GISDataExchange::ExportToGISFile(LPCTSTR lpszCSVFileName,LPCTSTR lpszShapeFileName, CString GISTypeString ) { #ifndef _WIN64 m_MessageList.ResetContent (); CWaitCursor wait; CCSVParser parser; int i= 0; // open csv file if (parser.OpenCSVFile(lpszCSVFileName)) { CString message_str; OGRSFDriver *poDriver; OGRRegisterAll(); poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(GISTypeString ); if( poDriver == NULL ) { message_str.Format ( "%s driver not available.", GISTypeString ); m_MessageList.AddString (message_str); return; } OGRDataSource *poDS; poDS = poDriver->CreateDataSource(lpszShapeFileName, NULL ); if( poDS == NULL ) { message_str.Format ( "Creation of GIS output file %s failed.\nPlease do not overwrite the exiting file and please select a new file name.", lpszShapeFileName ); m_MessageList.AddString (message_str); return; } ///// export to link layer // link layer OGRLayer *poLayer; poLayer = poDS->CreateLayer( "link", NULL, wkbLineString, NULL ); if( poLayer == NULL ) { m_MessageList.AddString ("link Layer creation failed"); return; } vector<string> HeaderVector = parser.GetHeaderVector(); std::vector <CString> LongFieldVector; for(unsigned int i = 0; i < HeaderVector.size(); i++) { if(HeaderVector[i].find ("geometry") != string::npos|| HeaderVector[i].find ("name") != string::npos || HeaderVector[i].find ("code") != string::npos) { OGRFieldDefn oField (HeaderVector[i].c_str (), OFTString); CString str; if( poLayer->CreateField( &oField ) != OGRERR_NONE ) { str.Format("Creating field %s failed", oField.GetNameRef()); m_MessageList.AddString (str); return; } }else { CString field_string = HeaderVector[i].c_str (); OGRFieldDefn oField (field_string, OFTReal); CString str; if( poLayer->CreateField( &oField ) != OGRERR_NONE ) { str.Format("Creating field %s failed", oField.GetNameRef()); m_MessageList.AddString (str); return; } } if(HeaderVector[i].size()>=11) { LongFieldVector.push_back (HeaderVector[i].c_str ()); } } message_str.Format ("%d fields have been created.",HeaderVector.size()); m_MessageList.AddString (message_str); if(LongFieldVector.size() >=1) { message_str.Format("Warning: Arc GIS file only supports field names with not more than 10 characters.\nThe following fields have long field names. "); m_MessageList.AddString (message_str); for(unsigned l = 0; l< LongFieldVector.size(); l++) { message_str.Format ("%s",LongFieldVector[l]); m_MessageList.AddString (message_str); } } int count = 0 ; while(parser.ReadRecord()) { //create feature OGRFeature *poFeature; poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() ); //step 1: write all fields except geometry for(unsigned int i = 0; i < HeaderVector.size(); i++) { if(HeaderVector[i]!="geometry") { if(HeaderVector[i].find ("name") != string::npos || HeaderVector[i].find ("code") != string::npos) { std::string str_value; parser.GetValueByFieldName(HeaderVector[i],str_value); // TRACE("field: %s, value = %s\n",HeaderVector[i].c_str (),str_value.c_str ()); poFeature->SetField(i,str_value.c_str ()); }else { double value = 0; parser.GetValueByFieldName(HeaderVector[i],value); // TRACE("field: %s, value = %f\n",HeaderVector[i].c_str (),value); CString field_name = HeaderVector[i].c_str (); poFeature->SetField(i,value); } } } string geo_string; std::vector<CCoordinate> CoordinateVector; if(parser.GetValueByFieldName("geometry",geo_string)) { // overwrite when the field "geometry" exists CGeometry geometry(geo_string); CoordinateVector = geometry.GetCoordinateList(); if( m_GIS_data_type == GIS_Point_Type && CoordinateVector.size ()==1) { OGRPoint pt; pt.setX( CoordinateVector[0].X ); pt.setY( CoordinateVector[0].Y); poFeature->SetGeometry( &pt ); } if( m_GIS_data_type == GIS_Line_Type) { OGRLineString line; for(unsigned int si = 0; si< CoordinateVector.size(); si++) { line.addPoint (CoordinateVector[si].X , CoordinateVector[si].Y); } poFeature->SetGeometry( &line ); } if( m_GIS_data_type == GIS_Polygon_Type) { OGRPolygon polygon; OGRLinearRing ring; for(unsigned int si = 0; si< CoordinateVector.size(); si++) { ring.addPoint (CoordinateVector[si].X , CoordinateVector[si].Y,1); } polygon.addRing(&ring); poFeature->SetGeometry( &polygon ); } } else { // no geometry field /// create geometry data from m_GIS_data_type == GIS_Point_Type if( m_GIS_data_type == GIS_Point_Type ) { double x, y; if(parser.GetValueByFieldName("x",x) && parser.GetValueByFieldName("y",y) ) { OGRPoint pt; pt.setX( CoordinateVector[0].X ); pt.setY( CoordinateVector[0].Y); poFeature->SetGeometry( &pt ); }else { AfxMessageBox("Pleaes prepare fields x and y in the csv file in order to create a node GIS layer.", MB_ICONINFORMATION); return; } } ///create geometry if( m_GIS_data_type == GIS_Line_Type) { int number_of_shape_points = 0; if(parser.GetValueByFieldName("number_of_shape_points", number_of_shape_points)) { if(number_of_shape_points>=2) { OGRLineString line; for(int s= 1; s<= number_of_shape_points; s++) { CString str_x, str_y; str_x.Format ("x%d",s); str_y.Format ("y%d",s); double x = 0; double y = 0; string string_x, string_y; string_x = m_pDoc->CString2StdString (str_x); string_y = m_pDoc->CString2StdString (str_y); if(parser.GetValueByFieldName(string_x, x) && parser.GetValueByFieldName(string_y, y)) { line.addPoint(x,y); }else { AfxMessageBox("Pleaes prepare fields x1,y1,x2,y2,...,xn,yn in the csv file in order to create a link GIS layer.", MB_ICONINFORMATION); return; } } poFeature->SetGeometry( &line ); } }else { AfxMessageBox("Pleaes prepare fields number_of_shape_points, x1,y1,x2,y2,...,xn,yn in the csv file in order to create a link GIS layer.", MB_ICONINFORMATION); return; } } // if( m_GIS_data_type == GIS_Polygon_Type) { OGRPolygon polygon; OGRLinearRing ring; int number_of_shape_points = 0; if(parser.GetValueByFieldName("number_of_shape_points", number_of_shape_points)) { if(number_of_shape_points>=2) { OGRLineString line; for(int s= 0; s< number_of_shape_points; s++) { CString str_x, str_y; str_x.Format ("x%d",str_x); str_y.Format ("y%d",str_y); double x = 0; double y = 0; string string_x, string_y; string_x = m_pDoc->CString2StdString (str_x); string_y = m_pDoc->CString2StdString (str_y); if(parser.GetValueByFieldName(string_x, x) && parser.GetValueByFieldName(string_y, y)) { ring.addPoint (x,y,1); }else { AfxMessageBox("Pleaes prepare fields x1,y1,x2,y2,...,xn,yn in the csv file in order to create a zone GIS layer.", MB_ICONINFORMATION); return; } } polygon.addRing(&ring); poFeature->SetGeometry( &polygon ); } } } } if( poLayer->CreateFeature( poFeature ) != OGRERR_NONE ) { AfxMessageBox("Failed to create line feature in shapefile.\n"); return; } OGRFeature::DestroyFeature( poFeature ); count++; } message_str.Format ("%d records have been created.",count); m_MessageList.AddString (message_str); OGRDataSource::DestroyDataSource( poDS ); CString ShapeFile = lpszShapeFileName; CString ShapeFileFolder = ShapeFile.Left(ShapeFile.ReverseFind('\\') + 1); ShellExecute( NULL, "explore", ShapeFileFolder, NULL, NULL, SW_SHOWNORMAL ); } #endif }
bool NgwGdalIo::createLayer (int &new_layer_id, const NgwLayerInfo &layer_info, QString base_url, int resource_group_id, QString base_url_copy_features, int layer_id_copy_features) { GDALDatasetPtr dataset_p; u_openDataset(dataset_p, base_url, resource_group_id, false); if (dataset_p.data() == NULL) { error = QObject::tr("Unable to open NGW dataset via GDAL"); return false; } QByteArray ba_name(layer_info.name.toUtf8()); OGRwkbGeometryType geom_type = Core::g_findGeomTypeGdal(layer_info.geom_type); OGRSpatialReference *srs = new OGRSpatialReference(); srs->importFromEPSG(3857); char **papszOptions = NULL; papszOptions = CSLAddString(papszOptions, "OVERWRITE=NO"); OGRLayer *layer = dataset_p.data()->CreateLayer(ba_name.data(), srs, geom_type, papszOptions); CSLDestroy(papszOptions); OSRRelease(srs); if (layer == NULL) { error = QObject::tr("Unable to create NGW layer via GDAL"); error += QString("\nGDAL error: %1").arg(CPLGetLastErrorMsg()); return false; } for (int i = 0; i < layer_info.fields.size(); i++) { QByteArray ba_field_name = std::get<0>(layer_info.fields[i]).toUtf8(); OGRFieldType field_type = Core::g_findFieldTypeGdal(std::get<2>(layer_info.fields[i])); OGRFieldDefn field_defn(ba_field_name.data(), field_type); layer->CreateField(&field_defn); // TEMP. There may be another way to create field aliases via GDAL in future. QString s_field_alias = QString("FIELD_%1_ALIAS").arg(i); layer->SetMetadataItem(s_field_alias.toUtf8().data(), std::get<1>(layer_info.fields[i]).toUtf8().data()); // TODO: delete layer if the creation of field was not successfull? What if at the time // between creation and this deletion some other layer have been created outside? How to // remove layer in GDAL not by layer index & how to properly get index of a layer in // GDALDataset? } layer->SyncToDisk(); // otherwise NGW id of created resource will not be assigned to the new layer auto metadata = layer->GetMetadata(""); QString s_new_layer_id = {CSLFetchNameValue(metadata, "id")}; new_layer_id = s_new_layer_id.toInt(); if (base_url_copy_features != "" && layer_id_copy_features != -1) { // TODO (important): here we need own credentioals for dataset_p2 ! GDALDatasetPtr dataset_p2; u_openDataset(dataset_p2, base_url_copy_features.toUtf8().data(), layer_id_copy_features, true); if (dataset_p2.data() == NULL) { // TODO: warning error = QObject::tr("Unable to open NGW dataset to copy features from"); //return false; } else { OGRLayer *layer2 = dataset_p2.data()->GetLayer(0); if (layer2 == NULL) { // TODO: warning error = QObject::tr("Unable to open NGW layer to copy features from"); //return false; } else { layer2->ResetReading(); OGRFeature *feature; while ((feature = layer2->GetNextFeature()) != NULL) { layer->CreateFeature(feature); OGRFeature::DestroyFeature(feature); } layer->SyncToDisk(); } } } return true; }
void processSerie(GeoVectorSerie& Serie) { QString IndexStr = "init"; openfluid::base::SimulationStatus::SimulationStage CurrentStage = OPENFLUID_GetCurrentStage(); bool OKToWrite = false; if (CurrentStage == openfluid::base::SimulationStatus::INITIALIZERUN) { OKToWrite = Serie.WhenMode == GeoVectorSerie::WHENINIT || Serie.WhenMode == GeoVectorSerie::WHENCONTINUOUS; } else if (CurrentStage == openfluid::base::SimulationStatus::RUNSTEP) { if (Serie.WhenMode == GeoVectorSerie::WHENCONTINUOUS) { openfluid::core::TimeIndex_t CurrentIndex = OPENFLUID_GetCurrentTimeIndex(); IndexStr = QString("%1").arg(CurrentIndex); if (Serie.LatestContinuousIndex + Serie.WhenContinuousDelay < CurrentIndex) { OKToWrite = true; Serie.LatestContinuousIndex = CurrentIndex; } } } else if (CurrentStage == openfluid::base::SimulationStatus::FINALIZERUN) { IndexStr = "final"; OKToWrite = Serie.WhenMode == GeoVectorSerie::WHENCONTINUOUS || Serie.WhenMode == GeoVectorSerie::WHENFINAL; } else { OPENFLUID_LogWarning("Internal stage error when processing geographic series"); return; } if (OKToWrite) { std::string FullFilePath = m_OutputPath + "/" + QString(QString::fromStdString(Serie.OutfilePattern).arg(IndexStr)).toStdString(); GDALDriver_COMPAT* Driver = GDALGetDriverByName_COMPAT(m_GDALFormat.c_str()); if (openfluid::tools::Filesystem::isFile(FullFilePath)) { // deletion of an existing file or files set GDALDelete_COMPAT(Driver,FullFilePath.c_str()); } GDALDataset_COMPAT* CreatedFile = GDALCreate_COMPAT(Driver,FullFilePath.c_str()); std::string CreatedLayerName = QFileInfo(QString::fromStdString(FullFilePath)).completeBaseName().toStdString(); OGRLayer* CreatedLayer = CreatedFile->CreateLayer(CreatedLayerName.c_str(),nullptr, Serie.GeoLayer->GetLayerDefn()->GetGeomType(), nullptr); OGRFieldDefn IDField("OFLD_ID",OFTInteger); CreatedLayer->CreateField(&IDField); GeoVectorSerie::VariablesSet_t::const_iterator itV; GeoVectorSerie::VariablesSet_t::const_iterator itVb = Serie.VariablesSet.begin(); GeoVectorSerie::VariablesSet_t::const_iterator itVe = Serie.VariablesSet.end(); for (itV = itVb; itV != itVe; ++itV) { std::string FieldName = (*itV).second; OGRFieldDefn VarField(FieldName.c_str(),OFTReal); VarField.SetWidth(24); VarField.SetPrecision(15); CreatedLayer->CreateField(&VarField); } OGRFeature* SourceFeature; openfluid::core::SpatialUnit* UU; Serie.GeoLayer->ResetReading(); while ((SourceFeature = Serie.GeoLayer->GetNextFeature()) != nullptr) { int SourceID = SourceFeature->GetFieldAsInteger(Serie.OFLDIDFieldIndex); UU = OPENFLUID_GetUnit(Serie.UnitsClass,SourceID); if (UU) { CreatedLayer->GetLayerDefn(); OGRFeature* CreatedFeature = OGRFeature::CreateFeature(CreatedLayer->GetLayerDefn()); CreatedFeature->SetGeometry(SourceFeature->GetGeometryRef()->clone()); CreatedFeature->SetField("OFLD_ID",SourceID); for (itV = itVb; itV != itVe; ++itV) { std::string VarName = (*itV).first; std::string FieldName = (*itV).second; openfluid::core::DoubleValue CreatedValue = 0.0; bool IsValueCreated = false; if (FieldName.empty()) FieldName = VarName; openfluid::core::IndexedValue VarValue; if (OPENFLUID_IsVariableExist(UU,VarName)) { OPENFLUID_GetLatestVariable(UU,VarName,VarValue); if (VarValue.value()->isDoubleValue()) // OpenFLUID value is double { CreatedValue = VarValue.value()->asDoubleValue(); IsValueCreated = true; } else if (VarValue.value()->convert(CreatedValue)) // OpenFLUID value can be converted to double { IsValueCreated = true; } else { QString Msg = QString("Variable %1 on unit %2#%3 is not a double or a compatible type") .arg(VarName.c_str()).arg(UU->getClass().c_str()).arg(UU->getID()); OPENFLUID_LogWarning(Msg.toStdString()); } } else { QString Msg = QString("Variable %1 does not exist on unit %2#%3") .arg(VarName.c_str()).arg(UU->getClass().c_str()).arg(UU->getID()); OPENFLUID_LogWarning(Msg.toStdString()); } if (IsValueCreated) // OpenFLUID value is written to GIS file only if it is double or converted to double CreatedFeature->SetField(FieldName.c_str(),CreatedValue); } if (CreatedLayer->CreateFeature(CreatedFeature) != OGRERR_NONE) { QString Msg = QString("Feature for unit %1#%2 cannot be created") .arg(UU->getClass().c_str()).arg(UU->getID()); OPENFLUID_LogWarning(Msg.toStdString()); } OGRFeature::DestroyFeature(CreatedFeature); } } GDALClose_COMPAT(CreatedFile); } }
bool GdaCache::CacheLayer(std::string ext_ds_name, OGRLayerProxy* ext_layer_proxy) { OGRLayer* poSrcLayer = ext_layer_proxy->layer; // get information from current layer: geomtype, layer_name // (NOTE: we don't consider coodinator system and translation here) OGRFeatureDefn *poSrcFDefn = poSrcLayer->GetLayerDefn(); int eGType = poSrcFDefn->GetGeomType(); const char* pszNewLayerName = poSrcLayer->GetName(); int bForceToPolygon = FALSE; int bForceToMultiPolygon = FALSE; int bForceToMultiLineString = FALSE; if( wkbFlatten(eGType) == wkbPolygon ) bForceToPolygon = TRUE; else if( wkbFlatten(eGType) == wkbMultiPolygon ) bForceToMultiPolygon = TRUE; else if( wkbFlatten(eGType) == wkbMultiLineString ) bForceToMultiLineString = TRUE; //Setup coordinate transformation if we need it. OGRCoordinateTransformation *poCT = NULL; bool bTransform = FALSE; OGRSpatialReference *poSourceSRS = NULL; // todo OGRSpatialReference *poOutputSRS = new OGRSpatialReference("EPSG:4326"); // Cache char *papszLCO[] = {"OVERWRITE=yes","FORMAT=Spatialite"}; std::string cache_layer_name = ext_ds_name + "_"+ext_layer_proxy->name; OGRDataSource *poDstDS = cach_ds_proxy->ds; OGRLayer *poDstLayer = poDstDS->CreateLayer(cache_layer_name.c_str(), poOutputSRS, (OGRwkbGeometryType)eGType, papszLCO); if (poDstLayer == NULL) { // raise create cache failed. return false; } // Process Layer style table poDstLayer->SetStyleTable( poSrcLayer->GetStyleTable () ); // Add fields. here to copy all field. int nSrcFieldCount = poSrcFDefn->GetFieldCount(); int iField; OGRFeatureDefn *poDstFDefn = poDstLayer->GetLayerDefn(); for( iField = 0; iField < nSrcFieldCount; iField++ ) { OGRFieldDefn* poSrcFieldDefn = poSrcFDefn->GetFieldDefn(iField); OGRFieldDefn oFieldDefn( poSrcFieldDefn ); // The field may have been already created at layer creation if (poDstLayer->CreateField( &oFieldDefn ) == OGRERR_NONE) { // now that we've created a field, GetLayerDefn() won't return NULL if (poDstFDefn == NULL) poDstFDefn = poDstLayer->GetLayerDefn(); } } // Transfer feature from Source Layer to Dest Layer OGRFeature *poFeature; GIntBig nFeaturesWritten = 0; poSrcLayer->ResetReading(); while (poFeature = poSrcLayer->GetNextFeature()) { OGRFeature *poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() ); poDstFeature->SetFrom(poFeature); OGRGeometry *poDstGeometry = poDstFeature->GetGeometryRef(); if (poDstGeometry != NULL) { if( bForceToPolygon ) { poDstFeature->SetGeometryDirectly( OGRGeometryFactory::forceToPolygon( poDstFeature->StealGeometry())); } else if( bForceToMultiPolygon ) { poDstFeature->SetGeometryDirectly( OGRGeometryFactory::forceToMultiPolygon( poDstFeature->StealGeometry() ) ); } else if ( bForceToMultiLineString ) { poDstFeature->SetGeometryDirectly( OGRGeometryFactory::forceToMultiLineString( poDstFeature->StealGeometry() ) ); } } if( poDstLayer->CreateFeature( poDstFeature ) == OGRERR_NONE ) { nFeaturesWritten ++; } OGRFeature::DestroyFeature( poDstFeature ); OGRFeature::DestroyFeature( poFeature ); } OGRDataSource::DestroyDataSource(poDstDS); // XXX // delete poDstLayer; return true; }
void ShapefileWriter::writePolygons(shared_ptr<const OsmMap> map, const QString& path) { OGRRegisterAll(); _removeShapefile(path); const char *pszDriverName = "ESRI Shapefile"; OGRSFDriver *poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(pszDriverName); if( poDriver == NULL ) { throw HootException(QString("%1 driver not available.").arg(pszDriverName)); } OGRDataSource* poDS = poDriver->CreateDataSource(path.toAscii(), NULL ); if( poDS == NULL ) { throw HootException(QString("Data source creation failed. %1").arg(path)); } OgrOptions options; options["ENCODING"] = "UTF-8"; OGRLayer *poLayer; QString layerName; layerName = QFileInfo(path).baseName(); poLayer = poDS->CreateLayer(layerName.toAscii(), map->getProjection().get(), wkbMultiPolygon, options.getCrypticOptions()); if( poLayer == NULL ) { throw HootException(QString("Layer creation failed. %1").arg(path)); } QStringList shpColumns; QStringList columns = getColumns(map, ElementType::Unknown); for (int i = 0; i < columns.size(); i++) { OGRFieldDefn oField(columns[i].toAscii(), OFTString); oField.SetWidth(64); if( poLayer->CreateField( &oField ) != OGRERR_NONE ) { throw HootException(QString("Error creating field (%1).").arg(columns[i])); } shpColumns.append(poLayer->GetLayerDefn()->GetFieldDefn(i)->GetNameRef()); } if (_includeInfo) { OGRFieldDefn oField("error_circ", OFTReal); if( poLayer->CreateField( &oField ) != OGRERR_NONE ) { throw HootException(QString("Error creating field (error:circular).")); } _circularErrorIndex = poLayer->GetLayerDefn()->GetFieldCount() - 1; } const WayMap& ways = map->getWays(); for (WayMap::const_iterator it = ways.begin(); it != ways.end(); it++) { shared_ptr<Way> way = it->second; if (OsmSchema::getInstance().isArea(way)) { _writeWayPolygon(map, way, poLayer, columns, shpColumns); } } const RelationMap& relations = map->getRelationMap(); for (RelationMap::const_iterator it = relations.begin(); it != relations.end(); it++) { shared_ptr<Relation> relation = it->second; if (relation->isMultiPolygon()) { _writeRelationPolygon(map, relation, poLayer, columns, shpColumns); } } OGRDataSource::DestroyDataSource(poDS); }
OGRDataSource *AoIIntersection::intersectAoIWithLayers ( OGRDataSource *ogrSourceData, OGRPolygon *aoiPoly, IntersectionSummary *summary, const char *outFmt ) { OGRDataSource *ogrIntersection = NULL; // Spatial reference setup // make a spatial reference for the area of interest polygon OGRSpatialReference aoiRef; aoiRef.SetWellKnownGeogCS( "WGS84" ); // make a spatial reference for the coord sys we will use to calculate area in acres - Albers USA equal area conic bool acreageCalcAvailable = true; char *aecWkt = "PROJCS[\"USA_Contiguous_Lambert_Conformal_Conic\",GEOGCS[\"GCS_North_American_1983\",DATUM[\"North_American_Datum_1983\",SPHEROID[\"GRS_1980\",6378137,298.257222101]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]],PROJECTION[\"Lambert_Conformal_Conic_2SP\"],PARAMETER[\"False_Easting\",0],PARAMETER[\"False_Northing\",0],PARAMETER[\"Central_Meridian\",-96],PARAMETER[\"Standard_Parallel_1\",33],PARAMETER[\"Standard_Parallel_2\",45],PARAMETER[\"Latitude_Of_Origin\",39],UNIT[\"Meter\",1],AUTHORITY[\"EPSG\",\"102004\"]]"; OGRSpatialReference aecRef; OGRErr ogrErr = aecRef.importFromWkt( &aecWkt ); if ( ogrErr != OGRERR_NONE ) { setError ( NO_SPATIAL_REFERENCE ); acreageCalcAvailable = false; } // begin creating the output data structure // OGRDataSource is the root ogrIntersection = buildIntersectionDataSource( outFmt ); if (! ogrIntersection ) { setError( NO_OUTPUT_DATASOURCE ); return 0; } int acreIndex = 0, areaIndex = 0; OGRFieldDefn *acreFldDefn = NULL, *areaPctFldDefn = NULL; OGRFeatureDefn *featureDefn = buildFeatureDefinition( acreIndex, areaIndex, acreFldDefn, areaPctFldDefn ); // walk the layers in the input data // OGRLayer *inputLayer; summary->numLayers = ogrSourceData->GetLayerCount(); for (int layerCt = 0; layerCt < summary->numLayers; ++layerCt) { inputLayer = ogrSourceData->GetLayer( layerCt ); if ( inputLayer == NULL ) { setError( NO_INPUT_LAYER ); // clean up delete ogrIntersection; return 0; } // make a clone of aoi polygon to be manipulated OGRPolygon *aoiClone = (OGRPolygon *)aoiPoly->clone(); if ( ! aoiClone ) { setError( NO_AOI_CLONE ); // clean up delete ogrIntersection; return 0; } // ensure that the area of interest polygon is in the same spatial reference as the data layer // find the spatial reference for the layer OGRSpatialReference *dataRef = inputLayer->GetSpatialRef(); if ( dataRef ) { OGRCoordinateTransformation *aoiTransform = OGRCreateCoordinateTransformation( &aoiRef, dataRef ); if( aoiTransform == NULL ) { setError( NO_AOI_TRANSFORM ); // clean up delete ogrIntersection; delete aoiClone; return 0; } aoiClone->transform( aoiTransform ); delete aoiTransform; } // find the transform from data layer's CS to Albers USA // for acreage calculation OGRCoordinateTransformation *aecTransform = NULL; acreageCalcAvailable = false; if ( dataRef ) { aecTransform = OGRCreateCoordinateTransformation( dataRef, &aecRef ); if( aecTransform == NULL ) { setError( NO_ACRE_TRANSFORM ); } else acreageCalcAvailable = true; } // the area enclosed by the AoI // used for computing the percentage of the AoI intersected by polygons summary->aoiArea = aoiClone->getExteriorRing()->get_Area(); // create a layer for outputting the intersecting polygons OGRLayer *intersectionLayer = ogrIntersection->CreateLayer( inputLayer->GetLayerDefn()->GetName(), dataRef, wkbPolygon, 0 ); if ( ! intersectionLayer ) { setError( NO_OUTPUT_LAYER ); // clean up delete ogrIntersection; delete aoiClone; delete aecTransform; return 0; } // add fields to layer ogrErr = intersectionLayer->CreateField( acreFldDefn ); if ( ogrErr != OGRERR_NONE ) { setError( NO_ACRE_FIELD ); // clean up delete ogrIntersection; delete aoiClone; delete aecTransform; return 0; } ogrErr = intersectionLayer->CreateField( areaPctFldDefn ); if ( ogrErr != OGRERR_NONE ) { setError( NO_AREA_FIELD ); // clean up delete ogrIntersection; delete aoiClone; delete aecTransform; return 0; } // march through the geometry in the layer seeking overlap with area of interest // inputLayer->ResetReading(); OGRFeature *inputFeature; while( (inputFeature = inputLayer->GetNextFeature()) != NULL ) { // get the geometry part of the feature OGRGeometry *inputGeometry = inputFeature->GetGeometryRef(); // test for polygon type - the only type we read if( inputGeometry != NULL && wkbFlatten(inputGeometry->getGeometryType()) == wkbPolygon ) { OGRPolygon *inputPolygon = (OGRPolygon *) inputGeometry; ++summary->totalInputPolyCt; double inputPolyArea = inputPolygon->get_Area(); summary->totalInputPolyArea += inputPolyArea; // here's the important test - does this polygon intersect our area of interest? if (aoiClone->Intersects( inputGeometry )) { // generate a polygon that represents the intersection of the polygon with the AoI OGRGeometry *intersectionGeometry = aoiClone->Intersection( inputGeometry ); if ( intersectionGeometry && wkbFlatten(intersectionGeometry->getGeometryType()) == wkbPolygon ) { double intersectionArea = ((OGRPolygon *)intersectionGeometry)->get_Area(); summary->totalIntersectionArea += intersectionArea; ++summary->intersectionCt; if (intersectionArea < inputPolyArea) ++summary->partEnclosedCt; // create a feature with feature definition, add geometry to it and add it to our layer OGRFeature *intersectionFeature = new OGRFeature( featureDefn ); if (! intersectionFeature ) { setError( NO_OUTPUT_FEATURE ); // clean up delete ogrIntersection; delete aoiClone; delete aecTransform; return 0; } intersectionFeature->SetGeometry( intersectionGeometry ); double percentOfAoI = intersectionArea / summary->aoiArea; intersectionFeature->SetField( areaIndex, percentOfAoI); summary->totalPercentOfAoI += percentOfAoI; if ( acreageCalcAvailable ) { OGRGeometry *intersectionCopy = intersectionGeometry->clone(); if ( intersectionCopy ) { ogrErr = intersectionCopy->transform( aecTransform ); if ( ogrErr != OGRERR_NONE ) { setError( NO_ACRE_TRANSFORMATION ); // clean up delete ogrIntersection; delete aoiClone; delete aecTransform; delete intersectionCopy; return 0; } // get area in known metric CS double intersectionAcreage = ((OGRPolygon *)intersectionCopy)->get_Area(); // convert sq m to acres double MetersToFt = 3.28084; double SqFtPerAcre = 43560.0; intersectionAcreage *= ((MetersToFt * MetersToFt) / SqFtPerAcre); intersectionFeature->SetField( acreIndex, intersectionAcreage ); summary->totalIntersectionAcres += intersectionAcreage; delete intersectionCopy; } else { setError( NO_ACRE_OBJECT ); // clean up delete ogrIntersection; delete aoiClone; delete aecTransform; return 0; } } intersectionLayer->CreateFeature( intersectionFeature ); if ( ogrErr != OGRERR_NONE ) { setError( NO_FEATURE_ADDED ); // clean up delete ogrIntersection; delete aoiClone; delete aecTransform; return 0; } } else { } } } else { printf( "no polygon geometry\n" ); } OGRFeature::DestroyFeature( inputFeature ); } delete aoiClone; delete aecTransform; } return ogrIntersection; }
void OgrWriter::_createLayer(shared_ptr<const Layer> layer) { OGRLayer *poLayer; OGRwkbGeometryType gtype; switch(layer->getGeometryType()) { case GEOS_POINT: gtype = wkbPoint; break; case GEOS_LINESTRING: gtype = wkbLineString; break; case GEOS_POLYGON: gtype = wkbPolygon; break; default: throw HootException("Unexpected geometry type."); } OgrOptions options; if (_ds->GetDriver()) { // if this is a CSV file if (_ds->GetDriver()->GetName() == QString("CSV")) { // if we're exporting point data, then export with x/y at the front if (gtype == wkbPoint) { options["GEOMETRY"] = "AS_XY"; } // if we're exporting other geometries then export w/ WKT at the front. else { options["GEOMETRY"] = "AS_WKT"; } options["CREATE_CSVT"] = "YES"; } if (_ds->GetDriver()->GetName() == QString("ESRI Shapefile")) { options["ENCODING"] = "UTF-8"; } // Add a Feature Dataset to a ESRI File GeoDatabase if requested if (_ds->GetDriver()->GetName() == QString("FileGDB")) { if (layer->getFdName() != "") { options["FEATURE_DATASET"] = layer->getFdName(); // speed up bulk inserts. options["FGDB_BULK_LOAD"] = "YES"; } } } QString layerName = _prependLayerName + layer->getName(); // Check if the layer exists in the output. poLayer = _ds->GetLayerByName(layerName.toAscii()); // We only want to add to a layer IFF the config option "ogr.append.data" set if (poLayer != NULL && _appendData) { // Layer exists _layers[layer->getName()] = poLayer; // Loop through the fields making sure that they exist in the output. Print a warning if // they don't exist OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn(); shared_ptr<const FeatureDefinition> fd = layer->getFeatureDefinition(); for (size_t i = 0; i < fd->getFieldCount(); i++) { shared_ptr<const FieldDefinition> f = fd->getFieldDefinition(i); if (poFDefn->GetFieldIndex(f->getName().toAscii()) == -1) { // throw HootException(QString("Error: Unable to find output field: %1 in layer %2.").arg(f->getName()).arg(layerName)); LOG_WARN("Unable to find field: " << QString(f->getName()) << " in layer " << layerName); } } } else { // Layer does not exist poLayer = _ds->CreateLayer(layerName.toAscii(), MapReprojector::createWgs84Projection()->Clone(), gtype, options.getCrypticOptions()); if( poLayer == NULL ) { throw HootException(QString("Layer creation failed. %1").arg(layerName)); } _layers[layer->getName()] = poLayer; shared_ptr<const FeatureDefinition> fd = layer->getFeatureDefinition(); for (size_t i = 0; i < fd->getFieldCount(); i++) { shared_ptr<const FieldDefinition> f = fd->getFieldDefinition(i); OGRFieldDefn oField(f->getName().toAscii(), toOgrFieldType(f->getType())); if (f->getWidth() > 0) { oField.SetWidth(f->getWidth()); } int errCode = poLayer->CreateField(&oField); if (errCode != OGRERR_NONE) { throw HootException( QString("Error creating field (%1) OGR Error Code: (%2).").arg(f->getName()).arg(QString::number(errCode))); } } } // End layer does not exist }
//--------------------------------------------------------- bool COGR_DataSource::Write_Shapes(CSG_Shapes *pShapes) { OGRLayer *pLayer; //----------------------------------------------------- if( m_pDataSource && pShapes && pShapes->is_Valid() && (pLayer = m_pDataSource->CreateLayer(SG_STR_SGTOMB(pShapes->Get_Name()), NULL, g_OGR_Driver.Get_Type(pShapes->Get_Type()))) != NULL ) { bool bResult = true; int iField; //------------------------------------------------- for(iField=0; iField<pShapes->Get_Field_Count() && bResult; iField++) { OGRFieldDefn DefField(SG_STR_SGTOMB(pShapes->Get_Field_Name(iField)), g_OGR_Driver.Get_Type(pShapes->Get_Field_Type(iField))); // DefField.SetWidth(32); if( pLayer->CreateField(&DefField) != OGRERR_NONE ) { bResult = false; } } //------------------------------------------------- for(int iShape=0; iShape<pShapes->Get_Count() && bResult && SG_UI_Process_Set_Progress(iShape, pShapes->Get_Count()); iShape++) { CSG_Shape *pShape = pShapes->Get_Shape(iShape); OGRFeature *pFeature = OGRFeature::CreateFeature(pLayer->GetLayerDefn()); for(iField=0; iField<pShapes->Get_Field_Count(); iField++) { switch( pShapes->Get_Field_Type(iField) ) { default: case SG_DATATYPE_Char: case SG_DATATYPE_String: case SG_DATATYPE_Date: pFeature->SetField(iField, SG_STR_SGTOMB(pShape->asString(iField))); break; case SG_DATATYPE_Short: case SG_DATATYPE_Int: case SG_DATATYPE_Long: case SG_DATATYPE_Color: pFeature->SetField(iField, pShape->asInt(iField)); break; case SG_DATATYPE_Float: case SG_DATATYPE_Double: pFeature->SetField(iField, pShape->asDouble(iField)); break; } } if( !_Write_Geometry(pShape, pFeature) || pLayer->CreateFeature(pFeature) != OGRERR_NONE ) { bResult = false; } OGRFeature::DestroyFeature(pFeature); } //------------------------------------------------- return( bResult ); } return( false ); }
OGRLayer *GNMFileNetwork::ICreateLayer(const char *pszName, CPL_UNUSED OGRSpatialReference *poSpatialRef, OGRwkbGeometryType eGType, char **papszOptions) { if(NULL == m_poLayerDriver) { CPLError( CE_Failure, CPLE_AppDefined, "The network storage format driver is not defined." ); return NULL; } //check if layer with such name exist for(int i = 0; i < GetLayerCount(); ++i) { OGRLayer* pLayer = GetLayer(i); if(NULL == pLayer) continue; if(EQUAL(pLayer->GetName(), pszName)) { CPLError( CE_Failure, CPLE_IllegalArg, "The network layer '%s' already exist.", pszName ); return NULL; } } //form path const char* pszExt = m_poLayerDriver->GetMetadataItem(GDAL_DMD_EXTENSION); CPLString soPath = CPLFormFilename(m_soNetworkFullName, pszName ,pszExt); GDALDataset *poDS = m_poLayerDriver->Create( soPath, 0, 0, 0, GDT_Unknown, papszOptions ); if( poDS == NULL ) { CPLError( CE_Failure, CPLE_FileIO, "Creation of output file failed." ); return NULL; } OGRSpatialReference oSpaRef(m_soSRS); OGRLayer *poLayer = poDS->CreateLayer( pszName, &oSpaRef, eGType, papszOptions ); if( poLayer == NULL ) { CPLError( CE_Failure, CPLE_FileIO, "Layer creation failed." ); GDALClose(poDS); return NULL; } OGRFieldDefn oField( GNM_SYSFIELD_GFID, GNMGFIDInt ); if( poLayer->CreateField( &oField ) != OGRERR_NONE ) { CPLError( CE_Failure, CPLE_FileIO, "Creating global identificator field failed." ); GDALClose(poDS); return NULL; } OGRFieldDefn oFieldBlock(GNM_SYSFIELD_BLOCKED, OFTInteger); if( poLayer->CreateField( &oFieldBlock ) != OGRERR_NONE ) { CPLError( CE_Failure, CPLE_FileIO, "Creating is blocking field failed." ); GDALClose(poDS); return NULL; } GNMGenericLayer* pGNMLayer = new GNMGenericLayer(poLayer, this); m_apoLayers.push_back(pGNMLayer); m_mpLayerDatasetMap[pGNMLayer] = poDS; return pGNMLayer; }
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(); }
OGRLayer *OGRDataSource::CopyLayer( OGRLayer *poSrcLayer, const char *pszNewName, char **papszOptions ) { OGRFeatureDefn *poSrcDefn = poSrcLayer->GetLayerDefn(); OGRLayer *poDstLayer = NULL; /* -------------------------------------------------------------------- */ /* Create the layer. */ /* -------------------------------------------------------------------- */ if( !TestCapability( ODsCCreateLayer ) ) { CPLError( CE_Failure, CPLE_NotSupported, "This datasource does not support creation of layers." ); return NULL; } CPLErrorReset(); poDstLayer = CreateLayer( pszNewName, poSrcLayer->GetSpatialRef(), poSrcDefn->GetGeomType(), papszOptions ); if( poDstLayer == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* Add fields. Default to copy all field. */ /* If only a subset of all fields requested, then output only */ /* the selected fields, and in the order that they were */ /* selected. */ /* -------------------------------------------------------------------- */ int iField; for( iField = 0; iField < poSrcDefn->GetFieldCount(); iField++ ) poDstLayer->CreateField( poSrcDefn->GetFieldDefn(iField) ); /* -------------------------------------------------------------------- */ /* Check if the destination layer supports transactions and set a */ /* default number of features in a single transaction. */ /* -------------------------------------------------------------------- */ int nGroupTransactions = 0; if( poDstLayer->TestCapability( OLCTransactions ) ) nGroupTransactions = 128; /* -------------------------------------------------------------------- */ /* Transfer features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature; poSrcLayer->ResetReading(); if( nGroupTransactions <= 0 ) { while( TRUE ) { OGRFeature *poDstFeature = NULL; poFeature = poSrcLayer->GetNextFeature(); if( poFeature == NULL ) break; CPLErrorReset(); poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() ); if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE ) { delete poFeature; CPLError( CE_Failure, CPLE_AppDefined, "Unable to translate feature %ld from layer %s.\n", poFeature->GetFID(), poSrcDefn->GetName() ); return poDstLayer; } poDstFeature->SetFID( poFeature->GetFID() ); OGRFeature::DestroyFeature( poFeature ); CPLErrorReset(); if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE ) { OGRFeature::DestroyFeature( poDstFeature ); return poDstLayer; } OGRFeature::DestroyFeature( poDstFeature ); } } else { int i, bStopTransfer = FALSE, bStopTransaction = FALSE; int nFeatCount = 0; // Number of features in the temporary array int nFeaturesToAdd = 0; while( !bStopTransfer ) { OGRFeature **papoDstFeature = (OGRFeature **)CPLCalloc(sizeof(OGRFeature *), nGroupTransactions); /* -------------------------------------------------------------------- */ /* Fill the array with features */ /* -------------------------------------------------------------------- */ for( nFeatCount = 0; nFeatCount < nGroupTransactions; nFeatCount++ ) { poFeature = poSrcLayer->GetNextFeature(); if( poFeature == NULL ) { bStopTransfer = 1; break; } CPLErrorReset(); papoDstFeature[nFeatCount] = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() ); if( papoDstFeature[nFeatCount]->SetFrom( poFeature, TRUE ) != OGRERR_NONE ) { OGRFeature::DestroyFeature( poFeature ); CPLError( CE_Failure, CPLE_AppDefined, "Unable to translate feature %ld from layer %s.\n", poFeature->GetFID(), poSrcDefn->GetName() ); bStopTransfer = TRUE; break; } papoDstFeature[nFeatCount]->SetFID( poFeature->GetFID() ); OGRFeature::DestroyFeature( poFeature ); } nFeaturesToAdd = nFeatCount; CPLErrorReset(); bStopTransaction = FALSE; while( !bStopTransaction ) { bStopTransaction = TRUE; poDstLayer->StartTransaction(); for( i = 0; i < nFeaturesToAdd; i++ ) { if( poDstLayer->CreateFeature( papoDstFeature[i] ) != OGRERR_NONE ) { nFeaturesToAdd = i; bStopTransfer = TRUE; bStopTransaction = FALSE; } } if( bStopTransaction ) poDstLayer->CommitTransaction(); else poDstLayer->RollbackTransaction(); } for( i = 0; i < nFeatCount; i++ ) OGRFeature::DestroyFeature( papoDstFeature[i] ); } } return poDstLayer; }
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; }
void SavePolygons( const std::vector< std::string > InFilenames, const char *OutFilename, const cv::Mat klabels, const std::vector< cv::Mat > raster, const std::vector< u_int32_t > labelpixels, const std::vector< std::vector <double> > sumCH, const std::vector< std::vector <double> > avgCH, const std::vector< std::vector <double> > stdCH, std::vector< std::vector< LINE > >& linelists ) { CPLLocaleC oLocaleCForcer(); CPLErrorReset(); const char *pszDriverName = "ESRI Shapefile"; GDALDriver *liDriver; liDriver = GetGDALDriverManager()->GetDriverByName(pszDriverName ); if( liDriver == NULL ) { printf( "\nERROR: %s driver not available.\n", pszDriverName ); exit( 1 ); } const size_t m_bands = raster.size(); const size_t m_labels = labelpixels.size(); GDALDataset *liDS; liDS = liDriver->Create( OutFilename, 0, 0, 0, GDT_Unknown, NULL ); if( liDS == NULL ) { printf( "\nERROR: Creation of output file failed.\n" ); exit( 1 ); } // dataset GDALDataset* piDataset; piDataset = (GDALDataset*) GDALOpen(InFilenames[0].c_str(), GA_ReadOnly); // spatialref OGRSpatialReference oSRS; oSRS.SetProjCS( piDataset->GetProjectionRef() ); OGRLayer *liLayer; liLayer = liDS->CreateLayer( "segments", &oSRS, wkbPolygon, NULL ); if( liLayer == NULL ) { printf( "\nERROR: Layer creation failed.\n" ); exit( 1 ); } // spatial transform double adfGeoTransform[6]; double oX = 0.0f; double oY = 0.0f; double mX = 1.0f; double mY = -1.0f; if( piDataset->GetGeoTransform( adfGeoTransform ) == CE_None ) { oX = adfGeoTransform[0]; oY = adfGeoTransform[3]; mX = adfGeoTransform[1]; mY = adfGeoTransform[5]; } GDALClose( (GDALDatasetH) piDataset ); OGRFieldDefn *clsIdField = new OGRFieldDefn( "CLASS", OFTInteger ); liLayer->CreateField( clsIdField ); OGRFieldDefn *pixArField = new OGRFieldDefn( "AREA", OFTInteger ); liLayer->CreateField( pixArField ); for ( size_t b = 0; b < m_bands; b++ ) { stringstream value; value << b+1; std::string FieldName = value.str() + "_AVERAGE"; OGRFieldDefn *lavrgField = new OGRFieldDefn( FieldName.c_str(), OFTReal ); liLayer->CreateField( lavrgField ); } for ( size_t b = 0; b < m_bands; b++ ) { stringstream value; value << b+1; std::string FieldName = value.str() + "_STDDEV"; OGRFieldDefn *lavrgField = new OGRFieldDefn( FieldName.c_str(), OFTReal ); liLayer->CreateField( lavrgField ); } int multiring = 0; printf ("Write File: %s (polygon)\n", OutFilename); for (size_t k = 0; k < m_labels; k++) { if (multiring == 1) { k = k - 1; multiring = 0; } if (linelists[k].size() == 0) continue; // insert field data OGRFeature *liFeature; liFeature = OGRFeature::CreateFeature( liLayer->GetLayerDefn() ); liFeature->SetField( "CLASS", (int) k ); liFeature->SetField( "AREA", (int) labelpixels.at(k) ); for ( size_t b = 0; b < m_bands; b++ ) { stringstream value; value << b+1; std::string FieldName = value.str() + "_AVERAGE"; liFeature->SetField( FieldName.c_str(), (double) avgCH[b].at(k) ); } for ( size_t b = 0; b < m_bands; b++ ) { stringstream value; value << b+1; std::string FieldName = value.str() + "_STDDEV"; liFeature->SetField( FieldName.c_str(), stdCH[b].at(k) ); } // initiate polygon start OGRLinearRing linestring; linestring.setCoordinateDimension(2); linestring.addPoint( oX + (double) linelists[k][0].sX * mX, oY + mY * (double) linelists[k][0].sY ); linestring.addPoint( oX + (double) linelists[k][0].eX * mX, oY + mY * (double) linelists[k][0].eY ); linelists[k].erase( linelists[k].begin() ); // construct polygon from lines while ( linelists[k].size() > 0 ) { if (multiring == 1) break; vector<LINE>::iterator it = linelists[k].begin(); for (; it != linelists[k].end(); ++it) { double ltX = linestring.getX(linestring.getNumPoints()-1); double ltY = linestring.getY(linestring.getNumPoints()-1); double csX = oX + (double) it->sX * mX; double csY = oY + mY * (double) it->sY; double ceX = oX + (double) it->eX * mX; double ceY = oY + mY * (double) it->eY; if ( ( csX == ltX ) && ( csY == ltY ) ) { linestring.addPoint(ceX, ceY); linelists[k].erase(it); break; } if ( ( ceX == ltX ) && ( ceY == ltY ) ) { linestring.addPoint(csX, csY); linelists[k].erase(it); break; } if (it == linelists[k].end()-1) { multiring = 1; break; } } } OGRPolygon polygon; linestring.closeRings(); // simplify poligons // remove colinear vertices OGRLinearRing linesimple; float pointPrevX = 0, pointPrevY = 0; for (int i = 0; i < linestring.getNumPoints(); i++) { OGRPoint point; linestring.getPoint(i, &point); // start if ( i == 0) { linesimple.addPoint( &point ); pointPrevX = point.getX(); pointPrevY = point.getY(); continue; } // end vertex if ( i == linestring.getNumPoints() - 1 ) { linesimple.addPoint( &point ); continue; } OGRPoint pointNext; linestring.getPoint(i+1, &pointNext); // | x1 y1 1 | // det | x2 y2 1 | = 0 => p1,p2,p3 are colinear // | x3 y3 1 | // x1*(y2-y3) + x2*(y3-y1) + x3*(y1-y2) == 0 // only if not colinear with previous and next if ( pointPrevX*(point.getY()-pointNext.getY()) + point.getX()*(pointNext.getY()-pointPrevY) + pointNext.getX()*(pointPrevY-point.getY()) != 0 ) { linesimple.addPoint( &point ); pointPrevX = point.getX(); pointPrevY = point.getY(); } } // as polygon geometry polygon.addRing( &linesimple ); liFeature->SetGeometry( &polygon ); if( liLayer->CreateFeature( liFeature ) != OGRERR_NONE ) { printf( "\nERROR: Failed to create feature in shapefile.\n" ); exit( 1 ); } OGRFeature::DestroyFeature( liFeature ); GDALTermProgress( (float)(k+1) / (float)(m_labels), NULL, NULL ); } GDALTermProgress( 1.0f, NULL, NULL ); GDALClose( liDS ); }