void node(const osmium::Node& node) {
const char* label = node.tags().get_value_by_key("label");
if (label) {
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_labels->GetLayerDefn());
std::unique_ptr<OGRPoint> ogr_point = m_factory.create_point(node);
feature->SetGeometry(ogr_point.get());
feature->SetField("id", static_cast<double>(node.id()));
feature->SetField("label", label);
if (m_layer_labels->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
} else {
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_nodes->GetLayerDefn());
std::unique_ptr<OGRPoint> ogr_point = m_factory.create_point(node);
feature->SetGeometry(ogr_point.get());
feature->SetField("id", static_cast<double>(node.id()));
if (m_layer_nodes->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
}
}
void GDALMergeFaces::run()
{
OGRGeometry * geo;
leadingView.resetReading();
OGRFeature * f;
std::set<int> indizes;
while (f = leadingView.getNextFeature()) {
indizes.insert(f->GetFieldAsInteger(this->attriubteName.c_str()));
}
//int cluster_id = 1;
int counter = 1;
foreach (int cluster_id, indizes) {
//while(geo = joinCluster(cluster_id)) {
//cluster_id++;
geo = joinCluster(cluster_id);
if (counter % 100 == 0) {
DM::Logger(DM::Standard) << "merged " << counter << "/" << indizes.size();
}
counter++;
if (!geo)
continue;
if (wkbMultiPolygon == geo->getGeometryType()){
geo = geo->UnionCascaded();
OGRMultiPolygon * mgeo = (OGRMultiPolygon*) geo;
if (mgeo->getNumGeometries() == 0) {
continue;
}
geo = mgeo->getGeometryRef(0);
int n = mgeo->getNumGeometries();
for (int i = 0; i < n; i++) {
OGRFeature * f = combinedView.createFeature();
f->SetGeometry(mgeo->getGeometryRef(i));
f->SetField("test_id", counter);
}
continue;
}
OGRFeature * f = combinedView.createFeature();
f->SetGeometry(geo);
}
void node(const shared_ptr<Osmium::OSM::Node const>& node) {
if (!node->tags().empty()) {
std::string tags = Osmium::filter_and_accumulate(node->tags(), m_filter, std::string(), m_tohstore);
if (!tags.empty()) {
try {
Osmium::Geometry::Point point(*node);
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_point->GetLayerDefn());
OGRPoint* ogrpoint = Osmium::Geometry::create_ogr_geometry(point);
feature->SetGeometry(ogrpoint);
feature->SetField("id", boost::lexical_cast<std::string>(node->id()).c_str());
feature->SetField("tags", tags.c_str());
if (m_layer_point->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
delete ogrpoint;
} catch (Osmium::Geometry::IllegalGeometry) {
std::cerr << "Ignoring illegal geometry for node " << node->id() << ".\n";
}
}
}
}
void GDALParceling::addToSystem(SFCGAL::Polygon & poly)
{
std::string wkt = poly.asText(9).c_str();
char * writable_wr = new char[wkt.size() + 1]; //Note not sure if memeory hole?
std::copy(wkt.begin(), wkt.end(), writable_wr);
writable_wr[wkt.size()] = '\0';
OGRGeometry * ogr_poly;
OGRErr err = OGRGeometryFactory::createFromWkt(&writable_wr, 0, &ogr_poly);
if (!ogr_poly->IsValid()) {
DM::Logger(DM::Warning) << "Geometry is not valid!";
return;
}
if (ogr_poly->IsEmpty()) {
DM::Logger(DM::Warning) << "Geometry is empty ";
DM::Logger(DM::Warning) << "OGR Error " << err;
DM::Logger(DM::Warning) << poly.asText(9);
return;
}
//Create Feature
OGRFeature * parcel = parcels.createFeature();
parcel->SetGeometry(ogr_poly);
OGRGeometryFactory::destroyGeometry(ogr_poly);
counter_added++;
}
void area(const osmium::Area& area) {
const char* building = area.tags()["building"];
if (building) {
try {
std::unique_ptr<OGRMultiPolygon> ogr_polygon = m_factory.create_multipolygon(area);
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_polygon->GetLayerDefn());
feature->SetGeometry(ogr_polygon.get());
feature->SetField("id", static_cast<int>(area.id()));
feature->SetField("type", building);
std::string type = "";
if (area.from_way()) {
type += "w";
} else {
type += "r";
}
feature->SetField("type", type.c_str());
if (m_layer_polygon->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
} catch (osmium::geometry_error&) {
std::cerr << "Ignoring illegal geometry for area " << area.id() << " created from " << (area.from_way() ? "way" : "relation") << " with id=" << area.orig_id() << ".\n";
}
}
}
void write_point(const char* problem_type, osmium::object_id_type id1, osmium::object_id_type id2, osmium::Location location) {
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_perror->GetLayerDefn());
std::unique_ptr<OGRPoint> ogr_point = m_ogr_factory.create_point(location);
feature->SetGeometry(ogr_point.get());
feature->SetField("id1", static_cast<double>(id1));
feature->SetField("id2", static_cast<double>(id2));
feature->SetField("problem_type", problem_type);
if (m_layer_perror->CreateFeature(feature) != OGRERR_NONE) {
std::runtime_error("Failed to create feature on layer 'perrors'");
}
OGRFeature::DestroyFeature(feature);
}
OGRFeature *OGRFeature::Clone()
{
OGRFeature *poNew = new OGRFeature( poDefn );
poNew->SetGeometry( poGeometry );
for( int i = 0; i < poDefn->GetFieldCount(); i++ )
{
poNew->SetField( i, pauFields + i );
}
return poNew;
}
void area(const osmium::Area& area) {
if (m_first_out) {
m_out << "[\n";
m_first_out = false;
} else {
m_out << ",\n";
}
m_out << "{\n \"test_id\": " << (area.orig_id() / 1000) << ",\n \"area_id\": " << area.id() << ",\n \"from_id\": " << area.orig_id() << ",\n \"from_type\": \"" << (area.from_way() ? "way" : "relation") << "\",\n \"wkt\": \"";
try {
std::string wkt = m_wkt_factory.create_multipolygon(area);
m_out << wkt << "\",\n \"tags\": {";
auto tagmap = create_map(area.tags());
bool first = true;
for (auto& tag : tagmap) {
if (first) {
first = false;
} else {
m_out << ", ";
}
m_out << '"' << tag.first << "\": \"" << tag.second << '"';
}
m_out << "}\n}";
} catch (osmium::geometry_error&) {
m_out << "INVALID\"\n}";
}
try {
std::unique_ptr<OGRMultiPolygon> ogr_polygon = m_ogr_factory.create_multipolygon(area);
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_polygon->GetLayerDefn());
feature->SetGeometry(ogr_polygon.get());
feature->SetField("id", static_cast<int>(area.orig_id()));
std::string from_type;
if (area.from_way()) {
from_type = "w";
} else {
from_type = "r";
}
feature->SetField("from_type", from_type.c_str());
if (m_layer_polygon->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
} catch (osmium::geometry_error&) {
std::cerr << "Ignoring illegal geometry for area " << area.id() << " created from " << (area.from_way() ? "way" : "relation") << " with id=" << area.orig_id() << ".\n";
}
}
void GDALAddComponentViewContainer::run()
{
int counter = 0;
for (int i = 0; i < elements; i++) {
OGRFeature * f = this->components.createFeature();
f->SetField("persons", "that is me");
OGRPoint pt;
pt.setX( i );
pt.setY( i );
f->SetGeometry(&pt);
if (counter == 100000) {
counter = 0;
}
counter++;
}
}
void node(const osmium::Node& node) {
const char* amenity = node.tags()["amenity"];
if (amenity && !strcmp(amenity, "post_box")) {
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_point->GetLayerDefn());
std::unique_ptr<OGRPoint> ogr_point = m_factory.create_point(node);
feature->SetGeometry(ogr_point.get());
feature->SetField("id", static_cast<double>(node.id()));
feature->SetField("operator", node.tags()["operator"]);
if (m_layer_point->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
}
}
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 write_line(const char* problem_type, osmium::object_id_type id1, osmium::object_id_type id2, osmium::Location loc1, osmium::Location loc2) {
std::unique_ptr<OGRPoint> ogr_point1 = m_ogr_factory.create_point(loc1);
std::unique_ptr<OGRPoint> ogr_point2 = m_ogr_factory.create_point(loc2);
std::unique_ptr<OGRLineString> ogr_linestring = std::unique_ptr<OGRLineString>(new OGRLineString());
ogr_linestring->addPoint(ogr_point1.get());
ogr_linestring->addPoint(ogr_point2.get());
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_lerror->GetLayerDefn());
feature->SetGeometry(ogr_linestring.get());
feature->SetField("id1", static_cast<double>(id1));
feature->SetField("id2", static_cast<double>(id2));
feature->SetField("problem_type", problem_type);
if (m_layer_lerror->CreateFeature(feature) != OGRERR_NONE) {
std::runtime_error("Failed to create feature on layer 'lerrors'");
}
OGRFeature::DestroyFeature(feature);
}
void way(const osmium::Way& way) {
try {
std::unique_ptr<OGRLineString> ogr_linestring = m_ogr_factory.create_linestring(way);
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_linestring->GetLayerDefn());
feature->SetGeometry(ogr_linestring.get());
feature->SetField("id", static_cast<double>(way.id()));
feature->SetField("type", way.tags().get_value_by_key("type"));
if (m_layer_linestring->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
} catch (osmium::geometry_error&) {
std::cerr << "Ignoring illegal geometry for way " << way.id() << ".\n";
}
}
void feed_way(const osmium::Way& way) {
try {
const char* building = way.tags().get_value_by_key("building");
if (building && way.is_closed()) {
std::unique_ptr<OGRLineString> ogr_linestring = m_factory.create_linestring(way);
OGRFeature* feature = OGRFeature::CreateFeature(m_layer->GetLayerDefn());
OGRPolygon polygon;
polygon.addRing(static_cast<OGRLinearRing*>(ogr_linestring.get()));
feature->SetGeometry(static_cast<OGRGeometry*>(&polygon));
feature->SetField("way_id", static_cast<double>(way.id())); //TODO: node.id() is of type int64_t. is this ok?
feature->SetField("lastchange", way.timestamp().to_iso().c_str());
create_feature(feature);
}
} catch (osmium::geom::geometry_error& e) {
catch_geometry_error(e, way);
}
}
void feed_way(const osmium::Way& way) {
try {
const char* building = way.tags().get_value_by_key("building");
if (building && way.is_closed()) {
const char* street = way.tags().get_value_by_key("addr:street");
const char* houseno = way.tags().get_value_by_key("addr:housenumber");
if (street || houseno) {
std::unique_ptr<OGRLineString> ogr_linestring = m_factory.create_linestring(way);
OGRFeature* feature = OGRFeature::CreateFeature(m_layer->GetLayerDefn());
OGRPolygon polygon;
polygon.addRing(static_cast<OGRLinearRing*>(ogr_linestring.get()));
feature->SetGeometry(static_cast<OGRGeometry*>(&polygon));
feature->SetField("way_id", static_cast<double>(way.id())); //TODO: node.id() is of type int64_t. is this ok?
feature->SetField("lastchange", way.timestamp().to_iso().c_str());
const char* postcode = way.tags().get_value_by_key("addr:postcode");
const char* city = way.tags().get_value_by_key("addr:city");
const char* country = way.tags().get_value_by_key("addr:country");
const char* fulladdr = way.tags().get_value_by_key("addr:full");
const char* place = way.tags().get_value_by_key("addr:place");
if (street) { feature->SetField("street" , street); }
if (houseno) { feature->SetField("houseno" , houseno); }
if (postcode) { feature->SetField("postcode", postcode); }
if (city) { feature->SetField("city", city); }
if (country) { feature->SetField("country", country); }
if (fulladdr) { feature->SetField("fulladdr", fulladdr); }
if (place) { feature->SetField("place", place); }
create_feature(feature);
}
}
}
catch (osmium::geometry_error& e) {
catch_geometry_error(e, way);
}
}
void GDALParcelSplit::addToSystem(QString poly)
{
QMutexLocker ml(&mMutex);
std::string wkt = poly.toStdString();
char * writable_wr = new char[wkt.size() + 1]; //Note not sure if memeory hole?
std::copy(wkt.begin(), wkt.end(), writable_wr);
writable_wr[wkt.size()] = '\0';
OGRGeometry * ogr_poly;
OGRErr err = OGRGeometryFactory::createFromWkt(&writable_wr, 0, &ogr_poly);
//delete writable_wr;
if (err != OGRERR_NONE) {
DM::Logger(DM::Warning) << "Geometry is not valid!";
return;
}
//delete writable_wr;
if (!ogr_poly->IsValid()) {
DM::Logger(DM::Warning) << "Geometry is not valid!";
return;
}
if (ogr_poly->IsEmpty()) {
DM::Logger(DM::Warning) << "Geometry is empty ";
DM::Logger(DM::Warning) << "OGR Error " << err;
DM::Logger(DM::Warning) << poly.toStdString();
return;
}
//Create Feature
OGRFeature * parcel = parcels.createFeature();
parcel->SetGeometry(ogr_poly);
OGRGeometryFactory::destroyGeometry(ogr_poly);
counter_added++;
}
bool TeOGRDriver::addElement(TeSTInstance* e)
{
if(e == 0)
return false;
TePropertyVector properties = e->getPropertyVector();
OGRFeature* poFeature = OGRFeature::CreateFeature(ogrLayer_->GetLayerDefn());
TePropertyVector::iterator itProp;
for(itProp=properties.begin(); itProp != properties.end(); ++itProp)
{
const char* constName=(const char*)(*itProp).attr_.rep_.name_.c_str();
poFeature->SetField(constName, (*itProp).value_.c_str());
}
TeMultiGeometry& geoms = e->geometries();
TeGeometry* geom = 0;
if(geoms.hasPoints())
geom = (TeGeometry*)&geoms.getPoints()[0];
else if(geoms.hasLines())
geom = (TeGeometry*)&geoms.getLines()[0];
else if(geoms.hasPolygons())
geom = (TeGeometry*)&geoms.getPolygons()[0];
OGRGeometry* ogrGeom = Convert2OGR(geom);
poFeature->SetGeometry(ogrGeom);
if(ogrLayer_->CreateFeature(poFeature) != OGRERR_NONE)
{
OGRFeature::DestroyFeature(poFeature);
return false;
}
OGRFeature::DestroyFeature( poFeature );
OGRGeometryFactory::destroyGeometry(ogrGeom);
return true;
}
void GDALAddComponent::run()
{
DM::GDALSystem * sys = this->getGDALData("city");
sys->updateView(components);
this->components.setCurrentGDALSystem(sys);
int counter = 0;
for (int i = 0; i < elements; i++) {
OGRFeature * f = this->components.createFeature();
if (addAttributes) {
std::vector<double> double_vector;
f->SetField("double_attribute", 10.5);
double_vector.push_back(10.5);
double_vector.push_back(20.5);
double_vector.push_back(30.5);
DM::DMFeature::SetDoubleList( f, "double_vector_attribute", double_vector);
}
//f->SetField("persons", "that is me");
OGRPoint pt;
pt.setX( i );
pt.setY( i );
f->SetGeometry(&pt);
if (counter == 100000) {
components.syncAlteredFeatures();
counter = 0;
}
counter++;
}
this->components.syncAlteredFeatures();
}
/**********************************************************************
* IMapInfoFile::CreateFeature()
*
* Standard OGR CreateFeature implementation. This method is used
* to create a new feature in current dataset
**********************************************************************/
OGRErr IMapInfoFile::CreateFeature(OGRFeature *poFeature)
{
TABFeature *poTABFeature;
OGRGeometry *poGeom;
OGRwkbGeometryType eGType;
OGRErr eErr;
TABPoint *poTABPointFeature = NULL;
TABRegion *poTABRegionFeature = NULL;
TABPolyline *poTABPolylineFeature = NULL;
/*-----------------------------------------------------------------
* MITAB won't accept new features unless they are in a type derived
* from TABFeature... so we have to do our best to map to the right
* feature type based on the geometry type.
*----------------------------------------------------------------*/
poGeom = poFeature->GetGeometryRef();
if( poGeom != NULL )
eGType = poGeom->getGeometryType();
else
eGType = wkbNone;
switch( wkbFlatten(eGType) )
{
/*-------------------------------------------------------------
* POINT
*------------------------------------------------------------*/
case wkbPoint:
poTABFeature = new TABPoint(poFeature->GetDefnRef());
if(poFeature->GetStyleString())
{
poTABPointFeature = (TABPoint*)poTABFeature;
poTABPointFeature->SetSymbolFromStyleString(
poFeature->GetStyleString());
}
break;
/*-------------------------------------------------------------
* REGION
*------------------------------------------------------------*/
case wkbPolygon:
case wkbMultiPolygon:
poTABFeature = new TABRegion(poFeature->GetDefnRef());
if(poFeature->GetStyleString())
{
poTABRegionFeature = (TABRegion*)poTABFeature;
poTABRegionFeature->SetPenFromStyleString(
poFeature->GetStyleString());
poTABRegionFeature->SetBrushFromStyleString(
poFeature->GetStyleString());
}
break;
/*-------------------------------------------------------------
* LINE/PLINE/MULTIPLINE
*------------------------------------------------------------*/
case wkbLineString:
case wkbMultiLineString:
poTABFeature = new TABPolyline(poFeature->GetDefnRef());
if(poFeature->GetStyleString())
{
poTABPolylineFeature = (TABPolyline*)poTABFeature;
poTABPolylineFeature->SetPenFromStyleString(
poFeature->GetStyleString());
}
break;
/*-------------------------------------------------------------
* Collection types that are not directly supported... convert
* to multiple features in output file through recursive calls.
*------------------------------------------------------------*/
case wkbGeometryCollection:
case wkbMultiPoint:
{
OGRErr eStatus = OGRERR_NONE;
int i;
OGRGeometryCollection *poColl = (OGRGeometryCollection*)poGeom;
OGRFeature *poTmpFeature = poFeature->Clone();
for (i=0; eStatus==OGRERR_NONE && i<poColl->getNumGeometries(); i++)
{
poTmpFeature->SetGeometry(poColl->getGeometryRef(i));
eStatus = CreateFeature(poTmpFeature);
}
delete poTmpFeature;
return eStatus;
}
break;
/*-------------------------------------------------------------
* Unsupported type.... convert to MapInfo geometry NONE
*------------------------------------------------------------*/
case wkbUnknown:
default:
poTABFeature = new TABFeature(poFeature->GetDefnRef());
break;
}
if( poGeom != NULL )
poTABFeature->SetGeometryDirectly(poGeom->clone());
for (int i=0; i< poFeature->GetDefnRef()->GetFieldCount(); i++)
{
poTABFeature->SetField(i,poFeature->GetRawFieldRef( i ));
}
eErr = CreateFeature(poTABFeature);
delete poTABFeature;
return eErr;
}
OGRFeature *OGRDWGBlocksLayer::GetNextUnfilteredFeature()
{
OGRFeature *poFeature = NULL;
/* -------------------------------------------------------------------- */
/* Are we out of features? */
/* -------------------------------------------------------------------- */
if( oIt == poDS->GetBlockMap().end() )
return NULL;
/* -------------------------------------------------------------------- */
/* Are we done reading the current blocks features? */
/* -------------------------------------------------------------------- */
DWGBlockDefinition *psBlock = &(oIt->second);
unsigned int nSubFeatureCount = psBlock->apoFeatures.size();
if( psBlock->poGeometry != NULL )
nSubFeatureCount++;
if( iNextSubFeature >= nSubFeatureCount )
{
oIt++;
iNextSubFeature = 0;
if( oIt == poDS->GetBlockMap().end() )
return NULL;
psBlock = &(oIt->second);
}
/* -------------------------------------------------------------------- */
/* Is this a geometry based block? */
/* -------------------------------------------------------------------- */
if( psBlock->poGeometry != NULL
&& iNextSubFeature == psBlock->apoFeatures.size() )
{
poFeature = new OGRFeature( poFeatureDefn );
poFeature->SetGeometry( psBlock->poGeometry );
iNextSubFeature++;
}
/* -------------------------------------------------------------------- */
/* Otherwise duplicate the next sub-feature. */
/* -------------------------------------------------------------------- */
else
{
poFeature = new OGRFeature( poFeatureDefn );
poFeature->SetFrom( psBlock->apoFeatures[iNextSubFeature] );
iNextSubFeature++;
}
/* -------------------------------------------------------------------- */
/* Set FID and block name. */
/* -------------------------------------------------------------------- */
poFeature->SetFID( iNextFID++ );
poFeature->SetField( "BlockName", oIt->first.c_str() );
m_nFeaturesRead++;
return poFeature;
}
void OGRILI1Layer::PolygonizeAreaLayer()
{
if (poAreaLineLayer == 0) return;
//add all lines from poAreaLineLayer to collection
OGRGeometryCollection *gc = new OGRGeometryCollection();
poAreaLineLayer->ResetReading();
while (OGRFeature *feature = poAreaLineLayer->GetNextFeatureRef())
gc->addGeometry(feature->GetGeometryRef());
//polygonize lines
CPLDebug( "OGR_ILI", "Polygonizing layer %s with %d multilines", poAreaLineLayer->GetLayerDefn()->GetName(), gc->getNumGeometries());
OGRMultiPolygon* polys = Polygonize( gc , false);
CPLDebug( "OGR_ILI", "Resulting polygons: %d", polys->getNumGeometries());
if (polys->getNumGeometries() != poAreaReferenceLayer->GetFeatureCount())
{
CPLDebug( "OGR_ILI", "Feature count of layer %s: %d", poAreaReferenceLayer->GetLayerDefn()->GetName(), GetFeatureCount());
CPLDebug( "OGR_ILI", "Polygonizing again with crossing line fix");
delete polys;
polys = Polygonize( gc, true ); //try again with crossing line fix
}
delete gc;
//associate polygon feature with data row according to centroid
#if defined(HAVE_GEOS)
int i;
OGRPolygon emptyPoly;
GEOSGeom *ahInGeoms = NULL;
CPLDebug( "OGR_ILI", "Associating layer %s with area polygons", GetLayerDefn()->GetName());
ahInGeoms = (GEOSGeom *) CPLCalloc(sizeof(void*),polys->getNumGeometries());
for( i = 0; i < polys->getNumGeometries(); i++ )
{
ahInGeoms[i] = polys->getGeometryRef(i)->exportToGEOS();
if (!GEOSisValid(ahInGeoms[i])) ahInGeoms[i] = NULL;
}
poAreaReferenceLayer->ResetReading();
while (OGRFeature *feature = poAreaReferenceLayer->GetNextFeatureRef())
{
GEOSGeom point = (GEOSGeom)feature->GetGeometryRef()->exportToGEOS();
for (i = 0; i < polys->getNumGeometries(); i++ )
{
if (ahInGeoms[i] && GEOSWithin(point, ahInGeoms[i]))
{
OGRFeature* areaFeature = feature->Clone();
areaFeature->SetGeometry( polys->getGeometryRef(i) );
AddFeature(areaFeature);
break;
}
}
if (i == polys->getNumGeometries())
{
CPLDebug( "OGR_ILI", "Association between area and point failed.");
feature->SetGeometry( &emptyPoly );
}
GEOSGeom_destroy( point );
}
for( i = 0; i < polys->getNumGeometries(); i++ )
GEOSGeom_destroy( ahInGeoms[i] );
CPLFree( ahInGeoms );
#endif
poAreaReferenceLayer = 0;
poAreaLineLayer = 0;
}
void OGRPDFLayer::Fill( GDALPDFArray* poArray )
{
for(int i=0;i<poArray->GetLength();i++)
{
GDALPDFObject* poFeatureObj = poArray->Get(i);
if (poFeatureObj->GetType() != PDFObjectType_Dictionary)
continue;
GDALPDFObject* poA = poFeatureObj->GetDictionary()->Get("A");
if (!(poA != NULL && poA->GetType() == PDFObjectType_Dictionary))
continue;
GDALPDFObject* poP = poA->GetDictionary()->Get("P");
if (!(poP != NULL && poP->GetType() == PDFObjectType_Array))
continue;
GDALPDFObject* poK = poFeatureObj->GetDictionary()->Get("K");
int nK = -1;
if (poK != NULL && poK->GetType() == PDFObjectType_Int)
nK = poK->GetInt();
GDALPDFArray* poPArray = poP->GetArray();
int j;
for(j = 0;j<poPArray->GetLength();j++)
{
GDALPDFObject* poKV = poPArray->Get(j);
if (poKV->GetType() == PDFObjectType_Dictionary)
{
GDALPDFObject* poN = poKV->GetDictionary()->Get("N");
GDALPDFObject* poV = poKV->GetDictionary()->Get("V");
if (poN != NULL && poN->GetType() == PDFObjectType_String &&
poV != NULL)
{
int nIdx = GetLayerDefn()->GetFieldIndex( poN->GetString().c_str() );
OGRFieldType eType = OFTString;
if (poV->GetType() == PDFObjectType_Int)
eType = OFTInteger;
else if (poV->GetType() == PDFObjectType_Real)
eType = OFTReal;
if (nIdx < 0)
{
OGRFieldDefn oField(poN->GetString().c_str(), eType);
CreateField(&oField);
}
else if (GetLayerDefn()->GetFieldDefn(nIdx)->GetType() != eType &&
GetLayerDefn()->GetFieldDefn(nIdx)->GetType() != OFTString)
{
OGRFieldDefn oField(poN->GetString().c_str(), OFTString);
AlterFieldDefn( nIdx, &oField, ALTER_TYPE_FLAG );
}
}
}
}
OGRFeature* poFeature = new OGRFeature(GetLayerDefn());
for(j = 0;j<poPArray->GetLength();j++)
{
GDALPDFObject* poKV = poPArray->Get(j);
if (poKV->GetType() == PDFObjectType_Dictionary)
{
GDALPDFObject* poN = poKV->GetDictionary()->Get("N");
GDALPDFObject* poV = poKV->GetDictionary()->Get("V");
if (poN != NULL && poN->GetType() == PDFObjectType_String &&
poV != NULL)
{
if (poV->GetType() == PDFObjectType_String)
poFeature->SetField(poN->GetString().c_str(), poV->GetString().c_str());
else if (poV->GetType() == PDFObjectType_Int)
poFeature->SetField(poN->GetString().c_str(), poV->GetInt());
else if (poV->GetType() == PDFObjectType_Real)
poFeature->SetField(poN->GetString().c_str(), poV->GetReal());
}
}
}
if (nK >= 0)
{
OGRGeometry* poGeom = poDS->GetGeometryFromMCID(nK);
if (poGeom)
{
poGeom->assignSpatialReference(GetSpatialRef());
poFeature->SetGeometry(poGeom);
}
}
OGRGeometry* poGeom = poFeature->GetGeometryRef();
if( !bGeomTypeMixed && poGeom != NULL )
{
if (!bGeomTypeSet)
{
bGeomTypeSet = TRUE;
GetLayerDefn()->SetGeomType(poGeom->getGeometryType());
}
else if (GetLayerDefn()->GetGeomType() != poGeom->getGeometryType())
{
bGeomTypeMixed = TRUE;
GetLayerDefn()->SetGeomType(wkbUnknown);
}
}
ICreateFeature(poFeature);
delete poFeature;
}
}
void feed_way(const osmium::Way& way) {
try {
const char* interpolation = way.tags().get_value_by_key("addr:interpolation");
if (interpolation) {
std::unique_ptr<OGRLineString> ogr_linestring = m_factory.create_linestring(way);
OGRFeature* feature = OGRFeature::CreateFeature(m_layer->GetLayerDefn());
const osmium::object_id_type first_node_id = m_geometry_helper.get_first_node_id(way);
const osmium::object_id_type last_node_id = m_geometry_helper.get_last_node_id(way);
feature->SetGeometry(ogr_linestring.get());
feature->SetField("way_id", static_cast<double>(way.id())); //TODO: node.id() is of type int64_t. is this ok?
feature->SetField("typename", interpolation);
feature->SetField("firstid", static_cast<double>(first_node_id)); //TODO: node.id() is of type int64_t. is cast do double ok?
feature->SetField("lastid", static_cast<double>(last_node_id)); //TODO: node.id() is of type int64_t. is cast do double ok?
feature->SetField("lastchange", way.timestamp().to_iso().c_str());
AltTagList first_taglist = m_addr_interpolation_node_map->get(first_node_id);
AltTagList last_taglist = m_addr_interpolation_node_map->get(last_node_id);
std::string first_node_housenumber = first_taglist.get_value_by_key(std::string("addr:housenumber"));
std::string last_node_housenumber = last_taglist.get_value_by_key(std::string("addr:housenumber"));
unsigned int first;
unsigned int last;
if (first_node_housenumber != "") {
feature->SetField("firstno", first_node_housenumber.c_str());
first = atoi(first_node_housenumber.c_str());
} else {
first = 0;
}
if (last_node_housenumber != "") {
feature->SetField("lastno", last_node_housenumber.c_str());
last = atoi(last_node_housenumber.c_str());
} else {
last = 0;
}
if (!(!strcmp(interpolation,"all") || !strcmp(interpolation,"even") || !strcmp(interpolation,"odd"))) { // TODO: add support for 'alphabetic'
feature->SetField("error", "unknown interpolation type");
} else if (
first == 0 ||
last == 0 ||
first_node_housenumber.length() != floor(log10(first))+1 || // make sure 123%& is not recognized as 123
last_node_housenumber.length() != floor(log10(last) )+1 //
) {
feature->SetField("error", "endpoint hast wrong format");
} else if (abs(first-last) > 1000) {
feature->SetField("error", "range too large");
} else if (((!strcmp(interpolation,"even") || !strcmp(interpolation,"odd")) && abs(first-last)==2) ||
(!strcmp(interpolation,"all") && abs(first-last)==1) ) {
feature->SetField("error", "needless interpolation");
} else if (!strcmp(interpolation,"even") && ( first%2==1 || last%2==1 )) {
feature->SetField("error", "interpolation even but number odd");
} else if (!strcmp(interpolation,"odd") && ( first%2==0 || last%2==0 )) {
feature->SetField("error", "interpolation odd but number even");
} else if (
(first_taglist.get_value_by_key(std::string("addr:street")) != last_taglist.get_value_by_key(std::string("addr:street"))) ||
(first_taglist.get_value_by_key(std::string("addr:postcode")) != last_taglist.get_value_by_key(std::string("addr:postcode"))) ||
(first_taglist.get_value_by_key(std::string("addr:city")) != last_taglist.get_value_by_key(std::string("addr:city"))) ||
(first_taglist.get_value_by_key(std::string("addr:country")) != last_taglist.get_value_by_key(std::string("addr:country"))) ||
(first_taglist.get_value_by_key(std::string("addr:full")) != last_taglist.get_value_by_key(std::string("addr:full"))) ||
(first_taglist.get_value_by_key(std::string("addr:place")) != last_taglist.get_value_by_key(std::string("addr:place"))) ) {
feature->SetField("error", "different tags on endpoints");
} else if ( // no interpolation error
(!strcmp(interpolation, "all")) ||
(!strcmp(interpolation, "odd")) ||
(!strcmp(interpolation, "even")) ) {
double length = ogr_linestring.get()->get_Length();
int increment;
if (strcmp(interpolation, "all")) {
increment = 2;
} else {
increment = 1;
}
double fraction;
unsigned int lower, upper;
if (first < last) {
fraction = 1/static_cast<double>(last-first);
lower = first;
upper = last;
} else {
fraction = 1/static_cast<double>(first-last);
increment *= -1;
lower = last;
upper = first;
}
for (unsigned int nr=first+increment; nr<upper && nr>lower; nr+=increment) {
std::unique_ptr<OGRPoint> point (new OGRPoint);
if (increment > 0) {
ogr_linestring.get()->Value((nr-lower)*fraction*length, point.get());
} else {
ogr_linestring.get()->Value((1-((nr-lower)*fraction))*length, point.get());
}
std::string road_id("");
m_clpp.process_interpolated_node(
*(point.get()),
road_id,
first_taglist.get_value_by_key(std::string("addr:street"))
);
m_nwa_writer.process_interpolated_node(
*(point.get()),
nr,
first_taglist.get_value_by_key(std::string("addr:street")),
first_taglist.get_value_by_key(std::string("addr:postcode")),
first_taglist.get_value_by_key(std::string("addr:city")),
first_taglist.get_value_by_key(std::string("addr:country")),
first_taglist.get_value_by_key(std::string("addr:full")),
first_taglist.get_value_by_key(std::string("addr:place")),
road_id
);
}
}
create_feature(feature);
}
} catch (osmium::geom::geometry_error& e) {
catch_geometry_error(e, way);
}
}
// 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
}
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 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);
}
}
}
void OGRILI1Layer::PolygonizeAreaLayer( OGRILI1Layer* poAreaLineLayer, int nAreaFieldIndex, int nPointFieldIndex )
{
//add all lines from poAreaLineLayer to collection
OGRGeometryCollection *gc = new OGRGeometryCollection();
poAreaLineLayer->ResetReading();
while (OGRFeature *feature = poAreaLineLayer->GetNextFeatureRef())
gc->addGeometry(feature->GetGeometryRef());
//polygonize lines
CPLDebug( "OGR_ILI", "Polygonizing layer %s with %d multilines", poAreaLineLayer->GetLayerDefn()->GetName(), gc->getNumGeometries());
poAreaLineLayer = 0;
OGRMultiPolygon* polys = Polygonize( gc , false);
CPLDebug( "OGR_ILI", "Resulting polygons: %d", polys->getNumGeometries());
if (polys->getNumGeometries() != GetFeatureCount())
{
CPLDebug( "OGR_ILI", "Feature count of layer %s: " CPL_FRMT_GIB, GetLayerDefn()->GetName(), GetFeatureCount());
CPLDebug( "OGR_ILI", "Polygonizing again with crossing line fix");
delete polys;
polys = Polygonize( gc, true ); //try again with crossing line fix
CPLDebug( "OGR_ILI", "Resulting polygons: %d", polys->getNumGeometries());
}
delete gc;
//associate polygon feature with data row according to centroid
#if defined(HAVE_GEOS)
int i;
OGRPolygon emptyPoly;
GEOSGeom *ahInGeoms = NULL;
CPLDebug( "OGR_ILI", "Associating layer %s with area polygons", GetLayerDefn()->GetName());
ahInGeoms = (GEOSGeom *) CPLCalloc(sizeof(void*), polys->getNumGeometries());
GEOSContextHandle_t hGEOSCtxt = OGRGeometry::createGEOSContext();
for( i = 0; i < polys->getNumGeometries(); i++ )
{
ahInGeoms[i] = polys->getGeometryRef(i)->exportToGEOS(hGEOSCtxt);
if (!GEOSisValid_r(hGEOSCtxt, ahInGeoms[i])) ahInGeoms[i] = NULL;
}
for ( int nFidx = 0; nFidx < nFeatures; nFidx++)
{
OGRFeature *feature = papoFeatures[nFidx];
OGRGeometry* geomRef = feature->GetGeomFieldRef(nPointFieldIndex);
if( !geomRef )
{
continue;
}
GEOSGeom point = (GEOSGeom)(geomRef->exportToGEOS(hGEOSCtxt));
for (i = 0; i < polys->getNumGeometries(); i++ )
{
if (ahInGeoms[i] && GEOSWithin_r(hGEOSCtxt, point, ahInGeoms[i]))
{
feature->SetGeomField(nAreaFieldIndex, polys->getGeometryRef(i));
break;
}
}
if (i == polys->getNumGeometries())
{
CPLDebug( "OGR_ILI", "Association between area and point failed.");
feature->SetGeometry( &emptyPoly );
}
GEOSGeom_destroy_r( hGEOSCtxt, point );
}
for( i = 0; i < polys->getNumGeometries(); i++ )
GEOSGeom_destroy_r( hGEOSCtxt, ahInGeoms[i] );
CPLFree( ahInGeoms );
OGRGeometry::freeGEOSContext( hGEOSCtxt );
#endif
poAreaLineLayer = 0;
delete polys;
}
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;
}
void feed_way(const osmium::Way& way) {
try {
const char* interpolation = way.tags().get_value_by_key("addr:interpolation");
if (interpolation) {
std::unique_ptr<OGRLineString> ogr_linestring = m_factory.create_linestring(way);
OGRFeature* feature = OGRFeature::CreateFeature(m_layer->GetLayerDefn());
const osmium::object_id_type first_node_id = m_geometry_helper.get_first_node_id(way);
const osmium::object_id_type last_node_id = m_geometry_helper.get_last_node_id(way);
feature->SetGeometry(ogr_linestring.get());
feature->SetField("way_id", static_cast<double>(way.id())); //TODO: node.id() is of type int64_t. is this ok?
feature->SetField("typename", interpolation);
feature->SetField("firstid", static_cast<double>(first_node_id)); //TODO: node.id() is of type int64_t. is cast do double ok?
feature->SetField("lastid", static_cast<double>(last_node_id)); //TODO: node.id() is of type int64_t. is cast do double ok?
feature->SetField("lastchange", way.timestamp().to_iso().c_str());
AltTagList first_taglist =
m_addr_interpolation_node_map->get(first_node_id);
AltTagList last_taglist =
m_addr_interpolation_node_map->get(last_node_id);
// the raw expression given in the first addr:housenumber= entry
std::string first_raw =
first_taglist.get_value_by_key("addr:housenumber");
// the raw expression given in the last addr:housenumber= entry
std::string last_raw =
last_taglist.get_value_by_key("addr:housenumber");
unsigned int first;
unsigned int last;
std::string first_numeric; // the numeric part of the first housenumber
std::string last_numeric; // the numeric part of the last housenumber
bool is_alphabetic_ip_correct = false;
if (first_raw != "") {
feature->SetField("firstno", first_raw.c_str());
first = atoi(first_raw.c_str());
} else {
first = 0;
}
if (last_raw != "") {
feature->SetField("lastno", last_raw.c_str());
last = atoi(last_raw.c_str());
} else {
last = 0;
}
if (!strcmp(interpolation, "alphabetic") &&
// second last characters are numbers?
!isalpha(first_raw[first_raw.length()-2]) &&
!isalpha(last_raw[last_raw.length()-2])){
// last characters are letters?
if (isalpha(first_raw[first_raw.length()-1]) &&
isalpha(last_raw[last_raw.length()-1])) {
first_numeric = std::string(first_raw.begin(), first_raw.end() - 1);
last_numeric = std::string(last_raw.begin(), last_raw.end() - 1);
if (first_numeric == last_numeric) {
first = first_raw[first_raw.length() - 1];
last = last_raw[last_raw.length() - 1];
is_alphabetic_ip_correct = true;
} else {
is_alphabetic_ip_correct = false;
feature->SetField("error", "numeric parts of housenumbers not identical");
}
} else {
is_alphabetic_ip_correct = false;
feature->SetField("error", "no alphabetic part in addr:housenumber");
}
}
if (!(
!strcmp(interpolation, "all") ||
!strcmp(interpolation, "even") ||
!strcmp(interpolation, "odd") ||
!strcmp(interpolation, "alphabetic"))) {
feature->SetField("error", "unknown interpolation type");
} else if (
strcmp(interpolation, "alphabetic") && // don't overwrite more precise error messages set before
(first == 0 ||
last == 0 ||
first_raw.length() != floor(log10(first))+1 || // make sure 123%& is not recognized as 123
last_raw.length() != floor(log10(last) )+1 //
)) {
feature->SetField("error", "endpoint has wrong format");
} else if (abs_diff(first,last) > 1000) {
feature->SetField("error", "range too large");
} else if (((!strcmp(interpolation,"even") || !strcmp(interpolation,"odd")) && abs_diff(first,last)==2) ||
(!strcmp(interpolation,"all") && abs_diff(first,last)==1) ) {
feature->SetField("error", "needless interpolation");
} else if (!strcmp(interpolation,"even") && ( first%2==1 || last%2==1 )) {
feature->SetField("error", "interpolation even but number odd");
} else if (!strcmp(interpolation,"odd") && ( first%2==0 || last%2==0 )) {
feature->SetField("error", "interpolation odd but number even");
} else if (
(first_taglist.get_value_by_key("addr:street") != last_taglist.get_value_by_key("addr:street")) ||
(first_taglist.get_value_by_key("addr:postcode") != last_taglist.get_value_by_key("addr:postcode")) ||
(first_taglist.get_value_by_key("addr:city") != last_taglist.get_value_by_key("addr:city")) ||
(first_taglist.get_value_by_key("addr:country") != last_taglist.get_value_by_key("addr:country")) ||
(first_taglist.get_value_by_key("addr:full") != last_taglist.get_value_by_key("addr:full")) ||
(first_taglist.get_value_by_key("addr:place") != last_taglist.get_value_by_key("addr:place")) ) {
feature->SetField("error", "different tags on endpoints");
} else if (way.is_closed()) {
feature->SetField("error", "interpolation is a closed way");
} else if ( // no interpolation error
(!strcmp(interpolation, "all")) ||
(!strcmp(interpolation, "odd")) ||
(!strcmp(interpolation, "even")) ||
(is_alphabetic_ip_correct == true)) {
double length = ogr_linestring.get()->get_Length();
int increment;
if (strcmp(interpolation, "all") && strcmp(interpolation, "alphabetic")) {
increment = 2; // even , odd
} else {
increment = 1; //all , alphabetic
}
double fraction;
unsigned int lower, upper;
if (first < last) {
fraction = 1/static_cast<double>(last-first);
lower = first;
upper = last;
} else {
fraction = 1/static_cast<double>(first-last);
increment *= -1;
lower = last;
upper = first;
}
for (unsigned int nr=first+increment; nr<upper && nr>lower; nr+=increment) {
std::unique_ptr<OGRPoint> point (new OGRPoint);
if (increment > 0) {
ogr_linestring.get()->Value((nr-lower)*fraction*length, point.get());
} else {
ogr_linestring.get()->Value((1-((nr-lower)*fraction))*length, point.get());
}
std::string road_id("");
std::string nrstr;
if(strcmp(interpolation, "alphabetic")) {
nrstr = std::to_string(nr);
} else { // is alphabetic
// std::string strend = printf("%d", nr);
nrstr = first_numeric + static_cast<char>(nr);
}
m_clpp.process_interpolated_node( // osmi_addresses_connection_line
*(point.get()),
road_id,
first_taglist.get_value_by_key("addr:street")
);
m_nwa_writer.process_interpolated_node( //osmi_addresses_nodes_with_addresses
*(point.get()),
nrstr,
//nr,
//std::to_string(nr),
first_taglist.get_value_by_key("addr:street"),
first_taglist.get_value_by_key("addr:postcode"),
first_taglist.get_value_by_key("addr:city"),
first_taglist.get_value_by_key("addr:country"),
first_taglist.get_value_by_key("addr:full"),
first_taglist.get_value_by_key("addr:place"),
road_id
);
}
}
create_feature(feature);
}
} catch (osmium::geometry_error& e) {
catch_geometry_error(e, way);
}
}
