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; }
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'"); } }
JNIEXPORT jlong JNICALL Java_es_gva_cit_jogr_OGRDataSource_createLayerNat (JNIEnv *env, jobject obj, jlong cPtr, jstring pszName, jlong poSpatialRef, jstring eGType, jobjectArray papszOptions){ OGRDataSource *ds = (OGRDataSource *) 0 ; int longitud; char **opciones; OGRLayer *layer_dstno; OGRSpatialReference *spatialRef; long ptr_dtno=-1; OGRwkbGeometryType geomtype; ds = *(OGRDataSource **)&cPtr; spatialRef = *(OGRSpatialReference **)&poSpatialRef; if(ds!=NULL){ longitud = env->GetArrayLength( papszOptions); opciones = (char **)malloc(sizeof(char *)*longitud); for(int i=0;i<longitud;i++){ jstring el = (jstring)env->GetObjectArrayElement(papszOptions,i); const char *simple_option = env->GetStringUTFChars( el, 0); opciones[i]=(char *)malloc(strlen(simple_option)); strcpy(opciones[i],simple_option); env->ReleaseStringUTFChars( el, simple_option); } const char *type = env->GetStringUTFChars( eGType, 0); const char *name = env->GetStringUTFChars( pszName, 0); if(strcmp(type,"wkbUnknown")==0)geomtype = wkbUnknown; else if(strcmp(type,"wkbPoint")==0)geomtype = wkbPoint; else if(strcmp(type,"wkbLineString")==0)geomtype = wkbLineString; else if(strcmp(type,"wkbPolygon")==0)geomtype = wkbPolygon; else if(strcmp(type,"wkbMultiPoint")==0)geomtype = wkbMultiPoint; else if(strcmp(type,"wkbMultiLineString")==0)geomtype = wkbMultiLineString; else if(strcmp(type,"wkbMultiPolygon")==0)geomtype = wkbMultiPolygon; else if(strcmp(type,"wkbGeometryCollection")==0)geomtype = wkbGeometryCollection; else if(strcmp(type,"wkbNone")==0)geomtype = wkbNone; else if(strcmp(type,"wkbLinearRing")==0)geomtype = wkbLinearRing; else if(strcmp(type,"wkbPoint25D")==0)geomtype = wkbPoint25D; else if(strcmp(type,"wkbLineString25D")==0)geomtype = wkbLineString25D; else if(strcmp(type,"wkbPolygon25D")==0)geomtype = wkbPolygon25D; else if(strcmp(type,"wkbMultiPoint25D")==0)geomtype = wkbMultiPoint25D; else if(strcmp(type,"wkbMultiLineString25D")==0)geomtype = wkbMultiLineString25D; else if(strcmp(type,"wkbMultiPolygon25D")==0)geomtype = wkbMultiPolygon25D; else if(strcmp(type,"wkbGeometryCollection25D")==0)geomtype = wkbGeometryCollection25D; layer_dstno = ds->CreateLayer(name, spatialRef, geomtype, opciones); env->ReleaseStringUTFChars( eGType, type); env->ReleaseStringUTFChars( pszName, name); } for(int i=0;i<longitud;i++)free(opciones[i]); free(opciones); if(layer_dstno==NULL)return -1; ptr_dtno = (long)&(*layer_dstno); return (jlong)ptr_dtno; }
OGRLayer *OGRDataSourceWithTransaction::ICreateLayer( const char *pszName, OGRSpatialReference *poSpatialRef, OGRwkbGeometryType eGType, char ** papszOptions) { if( !m_poBaseDataSource ) return NULL; return WrapLayer(m_poBaseDataSource->CreateLayer(pszName, poSpatialRef, eGType, papszOptions)); }
OGRDataSource * VectorCreate( const char * pszFormat, const char * pszFilename, char ** papszOptions/*=NULL*/ ) { OGRSFDriver * poDriver = GetVectorDriver(pszFormat); OGRDataSource * poOGRDataSource = poDriver->CreateDataSource(pszFilename, papszOptions); #ifdef TRACEON //测试时使用文件型数据库,没有图层时打开有问题,因此在这里放一个图层 //这样才能打开,不用测试可以关闭,在release中没有 poOGRDataSource->CreateLayer("TEMP", NULL, wkbUnknown, NULL); #endif return poOGRDataSource; }
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; }
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); }
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); }
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(); }
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 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 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; }
// 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 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); } } }
int main(int argc, char *argv[]) { LogPolicy::GetInstance().Unmute(); try { // enable logging if (argc < 3) { SimpleLogger().Write(logWARNING) << "usage:\n" << argv[0] << " <osrm> <osrm.restrictions>"; return -1; } SimpleLogger().Write() << "Using restrictions from file: " << argv[2]; std::ifstream restriction_ifstream(argv[2], std::ios::binary); const FingerPrint fingerprint_orig; FingerPrint fingerprint_loaded; restriction_ifstream.read((char *)&fingerprint_loaded, sizeof(FingerPrint)); // check fingerprint and warn if necessary if (!fingerprint_loaded.TestGraphUtil(fingerprint_orig)) { SimpleLogger().Write(logWARNING) << argv[2] << " was prepared with a different build. " "Reprocess to get rid of this warning."; } if (!restriction_ifstream.good()) { throw osrm::exception("Could not access <osrm-restrictions> files"); } uint32_t usable_restrictions = 0; restriction_ifstream.read((char *)&usable_restrictions, sizeof(uint32_t)); restriction_list.resize(usable_restrictions); // load restrictions if (usable_restrictions > 0) { restriction_ifstream.read((char *)&(restriction_list[0]), usable_restrictions * sizeof(TurnRestriction)); } restriction_ifstream.close(); std::ifstream input_stream(argv[1], std::ifstream::in | std::ifstream::binary); if (!input_stream.is_open()) { throw osrm::exception("Cannot open osrm file"); } // load graph data std::vector<ImportEdge> edge_list; const NodeID number_of_nodes = readBinaryOSRMGraphFromStream(input_stream, edge_list, bollard_node_list, traffic_lights_list, &coordinate_list, restriction_list); input_stream.close(); BOOST_ASSERT_MSG(restriction_list.size() == usable_restrictions, "size of restriction_list changed"); SimpleLogger().Write() << restriction_list.size() << " restrictions, " << bollard_node_list.size() << " bollard nodes, " << traffic_lights_list.size() << " traffic lights"; traffic_lights_list.clear(); traffic_lights_list.shrink_to_fit(); // Building an node-based graph DeallocatingVector<TarjanEdge> graph_edge_list; for (const NodeBasedEdge &input_edge : edge_list) { if (input_edge.source == input_edge.target) { continue; } if (input_edge.forward) { graph_edge_list.emplace_back(input_edge.source, input_edge.target, (std::max)((int)input_edge.weight, 1), input_edge.name_id); } if (input_edge.backward) { graph_edge_list.emplace_back(input_edge.target, input_edge.source, (std::max)((int)input_edge.weight, 1), input_edge.name_id); } } edge_list.clear(); edge_list.shrink_to_fit(); BOOST_ASSERT_MSG(0 == edge_list.size() && 0 == edge_list.capacity(), "input edge vector not properly deallocated"); tbb::parallel_sort(graph_edge_list.begin(), graph_edge_list.end()); auto graph = std::make_shared<TarjanDynamicGraph>(number_of_nodes, graph_edge_list); edge_list.clear(); edge_list.shrink_to_fit(); SimpleLogger().Write() << "Starting SCC graph traversal"; RestrictionMap restriction_map(restriction_list); auto tarjan = osrm::make_unique<TarjanSCC<TarjanDynamicGraph>>(graph, restriction_map, bollard_node_list); tarjan->run(); SimpleLogger().Write() << "identified: " << tarjan->get_number_of_components() << " many components"; SimpleLogger().Write() << "identified " << tarjan->get_size_one_count() << " SCCs of size 1"; // output TIMER_START(SCC_RUN_SETUP); // remove files from previous run if exist DeleteFileIfExists("component.dbf"); DeleteFileIfExists("component.shx"); DeleteFileIfExists("component.shp"); Percent p(graph->GetNumberOfNodes()); OGRRegisterAll(); const char *pszDriverName = "ESRI Shapefile"; OGRSFDriver *poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(pszDriverName); if (nullptr == poDriver) { throw osrm::exception("ESRI Shapefile driver not available"); } OGRDataSource *poDS = poDriver->CreateDataSource("component.shp", nullptr); if (nullptr == poDS) { throw osrm::exception("Creation of output file failed"); } OGRSpatialReference *poSRS = new OGRSpatialReference(); poSRS->importFromEPSG(4326); OGRLayer *poLayer = poDS->CreateLayer("component", poSRS, wkbLineString, nullptr); if (nullptr == poLayer) { throw osrm::exception("Layer creation failed."); } TIMER_STOP(SCC_RUN_SETUP); SimpleLogger().Write() << "shapefile setup took " << TIMER_MSEC(SCC_RUN_SETUP)/1000. << "s"; uint64_t total_network_distance = 0; p.reinit(graph->GetNumberOfNodes()); TIMER_START(SCC_OUTPUT); for (const NodeID source : osrm::irange(0u, graph->GetNumberOfNodes())) { p.printIncrement(); for (const auto current_edge : graph->GetAdjacentEdgeRange(source)) { const TarjanDynamicGraph::NodeIterator target = graph->GetTarget(current_edge); if (source < target || graph->EndEdges(target) == graph->FindEdge(target, source)) { total_network_distance += 100 * FixedPointCoordinate::ApproximateEuclideanDistance( coordinate_list[source].lat, coordinate_list[source].lon, coordinate_list[target].lat, coordinate_list[target].lon); BOOST_ASSERT(current_edge != SPECIAL_EDGEID); BOOST_ASSERT(source != SPECIAL_NODEID); BOOST_ASSERT(target != SPECIAL_NODEID); const unsigned size_of_containing_component = std::min(tarjan->get_component_size(source), tarjan->get_component_size(target)); // edges that end on bollard nodes may actually be in two distinct components if (size_of_containing_component < 1000) { OGRLineString lineString; lineString.addPoint(coordinate_list[source].lon / COORDINATE_PRECISION, coordinate_list[source].lat / COORDINATE_PRECISION); lineString.addPoint(coordinate_list[target].lon / COORDINATE_PRECISION, coordinate_list[target].lat / COORDINATE_PRECISION); OGRFeature *poFeature = OGRFeature::CreateFeature(poLayer->GetLayerDefn()); poFeature->SetGeometry(&lineString); if (OGRERR_NONE != poLayer->CreateFeature(poFeature)) { throw osrm::exception("Failed to create feature in shapefile."); } OGRFeature::DestroyFeature(poFeature); } } } } OGRSpatialReference::DestroySpatialReference(poSRS); OGRDataSource::DestroyDataSource(poDS); TIMER_STOP(SCC_OUTPUT); SimpleLogger().Write() << "generating output took: " << TIMER_MSEC(SCC_OUTPUT)/1000. << "s"; SimpleLogger().Write() << "total network distance: " << (uint64_t)total_network_distance / 100 / 1000. << " km"; SimpleLogger().Write() << "finished component analysis"; } catch (const std::exception &e) { SimpleLogger().Write(logWARNING) << "[exception] " << e.what(); } return 0; }
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); } }
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; }
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); } }