NIImporter_OpenStreetMap Class Reference

#include <NIImporter_OpenStreetMap.h>

---

Detailed Description

Importer for networks stored in OpenStreetMap format.

Definition at line 59 of file NIImporter_OpenStreetMap.h.

Static Public Member Functions
static void	loadNetwork (const OptionsCont &oc, NBNetBuilder &nb)
	Loads content of the optionally given OSM file.
Static Private Member Functions
static void	insertEdge (Edge *e, int index, NBNode *from, NBNode *to, const std::vector< int > &passed, const std::map< int, NIOSMNode * > &osmNodes, NBNodeCont &nc, NBEdgeCont &ec, NBTypeCont &tc) throw (ProcessError)
	Builds an NBEdge.
static NBNode *	insertNodeChecking (int id, const std::map< int, NIOSMNode * > &osmNodes, NBNodeCont &nc, NBTrafficLightLogicCont &tlsc) throw (ProcessError)
	Builds an NBNode.
Data Structures
class	CompareNodesInPairs
	Functor which compares two NIOSMNodes according to their coordinates. More...
struct	Edge
	An internal definition of a loaded edge. More...
class	EdgesHandler
	A class which extracts OSM-edges from a parsed OSM-file. More...
struct	NIOSMNode
	An internal representation of an OSM-node. More...
class	NodesHandler
	A class which extracts OSM-nodes from a parsed OSM-file. More...
class	SimilarEdge
	Functor which compares two Edges according to all values but id. More...
class	SubstituteNode
	A functor to substitute a node in the node list of an Edge. More...

---

Member Function Documentation

void NIImporter_OpenStreetMap::insertEdge	(	Edge *	e,
		int	index,
		NBNode *	from,
		NBNode *	to,
		const std::vector< int > &	passed,
		const std::map< int, NIOSMNode * > &	osmNodes,
		NBNodeCont &	nc,
		NBEdgeCont &	ec,
		NBTypeCont &	tc
	)			throw (ProcessError) [static, private]

Builds an NBEdge.

Parameters:

[in]	e	The definition of the edge
[in]	index	The index of the edge (in the case it is split along her nodes)
[in]	from	The origin node of the edge
[in]	to	The destination node of the edge
[in]	passed	The list of passed nodes (geometry information)
[in]	osmNodes	Container of node definitions for getting information about nodes from
[in]	nc	The container for built nodes
[in,out]	The	edge container to add the built edge to
[in]	tc	The type container to get information about the edge from

Exceptions:

ProcessError

If the edge could not be added to the container

Definition at line 397 of file NIImporter_OpenStreetMap.cpp.

References NBEdge::LANESPREAD_CENTER, NBEdge::LANESPREAD_RIGHT, NIImporter_OpenStreetMap::NIOSMNode::lat, NIImporter_OpenStreetMap::NIOSMNode::lon, Position2DVector::push_back_noDoublePos(), Position2DVector::reverse(), NBEdge::setVehicleClasses(), SUMOReal, toString(), WRITE_WARNING, and GeoConvHelper::x2cartesian().

Referenced by loadNetwork().

                                                                                                         {
    // patch the id
    std::string id = e->id;
    if (index>=0) {
        id = id + "#" + toString(index);
    }
    // convert the shape
    Position2DVector shape;
    for (std::vector<int>::const_iterator i=passed.begin(); i!=passed.end(); ++i) {
        NIOSMNode *n = osmNodes.find(*i)->second;
        Position2D pos(n->lon, n->lat);
        if (!GeoConvHelper::x2cartesian(pos, true, n->lon, n->lat)) {
            throw ProcessError("Unable to project coordinates for edge " + id + ".");
        }
        shape.push_back_noDoublePos(pos);
    }
    if (!tc.knows(e->myHighWayType)) {
        // we do not know the type -> something else, ignore
        return;
    }
    // otherwise it is not an edge and will be ignored
    int noLanes = tc.getNoLanes(e->myHighWayType);
    SUMOReal speed = tc.getSpeed(e->myHighWayType);
    bool defaultsToOneWay = tc.getIsOneWay(e->myHighWayType);
    std::vector<SUMOVehicleClass> allowedClasses = tc.getAllowedClasses(e->myHighWayType);
    std::vector<SUMOVehicleClass> disallowedClasses = tc.getDisallowedClasses(e->myHighWayType);
    // check directions
    bool addSecond = true;
    if (e->myIsOneWay=="true"||e->myIsOneWay=="yes"||e->myIsOneWay=="1"||(defaultsToOneWay && e->myIsOneWay!="no" && e->myIsOneWay!="false" && e->myIsOneWay!="0")) {
        addSecond = false;
    }
    // if we had been able to extract the number of lanes, override the highway type default
    if (e->myNoLanes >= 0) {
        if (!addSecond) {
            noLanes = e->myNoLanes;
        } else {
            noLanes = e->myNoLanes / 2;
        }
    }
    // if we had been able to extract the maximum speed, override the highway type default
    if (e->myMaxSpeed >= 0) {
        speed = (SUMOReal)(e->myMaxSpeed / 3.6);
    }

    if (noLanes!=0&&speed!=0) {
        if (e->myIsOneWay!=""&&e->myIsOneWay!="false"&&e->myIsOneWay!="no"&&e->myIsOneWay!="true"&&e->myIsOneWay!="yes"&&e->myIsOneWay!="-1"&&e->myIsOneWay!="1") {
            WRITE_WARNING("New value for oneway found: " + e->myIsOneWay);
        }
        NBEdge::LaneSpreadFunction lsf = addSecond ? NBEdge::LANESPREAD_RIGHT : NBEdge::LANESPREAD_CENTER;
        if (e->myIsOneWay!="-1") {
            NBEdge *nbe = new NBEdge(id, from, to, e->myHighWayType, speed, noLanes, tc.getPriority(e->myHighWayType), shape, lsf);
            nbe->setVehicleClasses(allowedClasses, disallowedClasses);
            if (!ec.insert(nbe)) {
                delete nbe;
                throw ProcessError("Could not add edge '" + id + "'.");
            }
        }
        if (addSecond) {
            if (e->myIsOneWay!="-1") {
                id = "-" + id;
            }
            NBEdge *nbe = new NBEdge(id, to, from, e->myHighWayType, speed, noLanes, tc.getPriority(e->myHighWayType), shape.reverse(), lsf);
            nbe->setVehicleClasses(allowedClasses, disallowedClasses);
            if (!ec.insert(nbe)) {
                delete nbe;
                throw ProcessError("Could not add edge '-" + id + "'.");
            }
        }
    }
}

NBNode * NIImporter_OpenStreetMap::insertNodeChecking	(	int	id,
		const std::map< int, NIOSMNode * > &	osmNodes,
		NBNodeCont &	nc,
		NBTrafficLightLogicCont &	tlsc
	)			throw (ProcessError) [static, private]

Builds an NBNode.

If a node with the given id is already known, nothing is done. Otherwise, the position and other information of the node is retrieved from the given node map, the node is built and added to the given node container. If the node is controlled by a tls, the according tls is built and added to the tls container.

Parameters:

[in]	id	The id of the node to build
[in]	osmNodes	Map of node ids to information about these
[in,out]	nc	The node container to add the built node to
[in,out]	tlsc	The traffic lights logic container to add the built tls to

Returns:

The built/found node

Exceptions:

ProcessError

If the tls could not be added to the container

Definition at line 364 of file NIImporter_OpenStreetMap.cpp.

References MsgHandler::getErrorInstance(), MsgHandler::inform(), NIImporter_OpenStreetMap::NIOSMNode::lat, NIImporter_OpenStreetMap::NIOSMNode::lon, NIImporter_OpenStreetMap::NIOSMNode::tlsControlled, toString(), and GeoConvHelper::x2cartesian().

Referenced by loadNetwork().

                                                           {
    NBNode *from = nc.retrieve(toString(id));
    if (from==0) {
        NIOSMNode *n = osmNodes.find(id)->second;
        Position2D pos(n->lon, n->lat);
        if (!GeoConvHelper::x2cartesian(pos, true, n->lon, n->lat)) {
            MsgHandler::getErrorInstance()->inform("Unable to project coordinates for node " + toString(id) + ".");
            delete from;
            return 0;
        }
        from = new NBNode(toString(id), pos);
        if (!nc.insert(from)) {
            MsgHandler::getErrorInstance()->inform("Could not insert node '" + toString(id) + "').");
            delete from;
            return 0;
        }
        if (n->tlsControlled) {
            // ok, this node is a traffic light node where no other nodes
            //  participate
            NBOwnTLDef *tlDef = new NBOwnTLDef(toString(id), from);
            if (!tlsc.insert(tlDef)) {
                // actually, nothing should fail here
                delete tlDef;
                throw ProcessError("Could not allocate tls '" + toString(id) + "'.");
            }
        }
    }
    return from;
}

void NIImporter_OpenStreetMap::loadNetwork	(	const OptionsCont &	oc,
		NBNetBuilder &	nb
	)			[static]

Loads content of the optionally given OSM file.

If the option "osm-files" is set, the file(s) stored therein is read and the network definition stored therein is stored within the given network builder.

If the option "osm-files" is not set, this method simply returns.

Parameters:

[in]	oc	The options to use
[in]	nb	The network builder to fill

Definition at line 182 of file NIImporter_OpenStreetMap.cpp.

References MsgHandler::beginProcessMsg(), MsgHandler::endProcessMsg(), FileHelpers::exists(), NBNetBuilder::getEdgeCont(), MsgHandler::getErrorInstance(), MsgHandler::getMessageInstance(), NBNetBuilder::getNodeCont(), OptionsCont::getStringVector(), NBNetBuilder::getTLLogicCont(), NBNetBuilder::getTypeCont(), MsgHandler::inform(), NBTypeCont::insert(), insertEdge(), insertNodeChecking(), OptionsCont::isSet(), NIImporter_OpenStreetMap::Edge::myCurrentIsRoad, NIImporter_OpenStreetMap::Edge::myCurrentNodes, XMLSubSys::runParser(), GenericSAXHandler::setFileName(), SUMOReal, SVC_BICYCLE, SVC_BUS, SVC_CITYRAIL, SVC_DELIVERY, SVC_LIGHTRAIL, SVC_PEDESTRIAN, SVC_RAIL_FAST, SVC_UNKNOWN, and toString().

Referenced by NILoader::load().

                                                                             {
    // check whether the option is set (properly)
    if (!oc.isSet("osm-files")) {
        return;
    }
    // preset types
    //  for highways
    NBTypeCont &tc = nb.getTypeCont();
    tc.insert("highway.motorway", 3, (SUMOReal)(160./3.6), 13, SVC_UNKNOWN, true);
    tc.insert("highway.motorway_link", 1, (SUMOReal)(80./3.6), 12, SVC_UNKNOWN, true);
    tc.insert("highway.trunk", 2, (SUMOReal)(100./3.6), 11);  // !!! 130km/h?
    tc.insert("highway.trunk_link", 1, (SUMOReal)(80./3.6), 10);
    tc.insert("highway.primary", 2, (SUMOReal)(100./3.6), 9);
    tc.insert("highway.primary_link", 1, (SUMOReal)(80./3.6), 8);
    tc.insert("highway.secondary", 2, (SUMOReal)(100./3.6), 7);
    tc.insert("highway.tertiary", 1, (SUMOReal)(80./3.6), 6);
    tc.insert("highway.unclassified", 1, (SUMOReal)(80./3.6), 5);
    tc.insert("highway.residential", 1, (SUMOReal)(50./3.6), 4);  // actually, maybe one lane for parking would be nice...
    tc.insert("highway.living_street", 1, (SUMOReal)(10./3.6), 3);
    tc.insert("highway.service", 1, (SUMOReal)(20./3.6), 2, SVC_DELIVERY);
    tc.insert("highway.track", 1, (SUMOReal)(20./3.6), 1);
    tc.insert("highway.services", 1, (SUMOReal)(30./3.6), 1);
    tc.insert("highway.unsurfaced", 1, (SUMOReal)(30./3.6), 1);  // additional
    tc.insert("highway.footway", 1, (SUMOReal)(30./3.6), 1, SVC_PEDESTRIAN);  // additional
    tc.insert("highway.pedestrian", 1, (SUMOReal)(30./3.6), 1, SVC_PEDESTRIAN);

    tc.insert("highway.path", 1, (SUMOReal)(10./3.6), 1, SVC_PEDESTRIAN);
    tc.insert("highway.bridleway", 1, (SUMOReal)(10./3.6), 1, SVC_PEDESTRIAN);  // no horse stuff
    tc.insert("highway.cycleway", 1, (SUMOReal)(20./3.6), 1, SVC_BICYCLE);
    tc.insert("highway.footway", 1, (SUMOReal)(10./3.6), 1, SVC_PEDESTRIAN);
    tc.insert("highway.step", 1, (SUMOReal)(5./3.6), 1, SVC_PEDESTRIAN);  // additional
    tc.insert("highway.steps", 1, (SUMOReal)(5./3.6), 1, SVC_PEDESTRIAN);  // :-) do not run too fast
    tc.insert("highway.stairs", 1, (SUMOReal)(5./3.6), 1, SVC_PEDESTRIAN);  // additional
    tc.insert("highway.bus_guideway", 1, (SUMOReal)(30./3.6), 1, SVC_BUS);

    //  for railways
    tc.insert("railway.rail", 1, (SUMOReal)(30./3.6), 1, SVC_RAIL_FAST);
    tc.insert("railway.tram", 1, (SUMOReal)(30./3.6), 1, SVC_CITYRAIL);
    tc.insert("railway.light_rail", 1, (SUMOReal)(30./3.6), 1, SVC_LIGHTRAIL);
    tc.insert("railway.subway", 1, (SUMOReal)(30./3.6), 1, SVC_CITYRAIL);
    tc.insert("railway.preserved", 1, (SUMOReal)(30./3.6), 1, SVC_LIGHTRAIL);
    tc.insert("railway.monorail", 1, (SUMOReal)(30./3.6), 1, SVC_LIGHTRAIL);  // rail stuff has to be discussed


    /* Parse file(s)
     * Each file is parsed twice: first for nodes, second for edges. */
    std::vector<std::string> files = oc.getStringVector("osm-files");
    // load nodes, first
    std::map<int, NIOSMNode*> nodes;
    NodesHandler nodesHandler(nodes);
    for (std::vector<std::string>::const_iterator file=files.begin(); file!=files.end(); ++file) {
        // nodes
        if (!FileHelpers::exists(*file)) {
            MsgHandler::getErrorInstance()->inform("Could not open osm-file '" + *file + "'.");
            return;
        }
        nodesHandler.setFileName(*file);
        MsgHandler::getMessageInstance()->beginProcessMsg("Parsing nodes from osm-file '" + *file + "'...");
        XMLSubSys::runParser(nodesHandler, *file);
        MsgHandler::getMessageInstance()->endProcessMsg("done.");
    }
    // load edges, then
    std::map<std::string, Edge*> edges;
    EdgesHandler edgesHandler(nodes, edges);
    for (std::vector<std::string>::const_iterator file=files.begin(); file!=files.end(); ++file) {
        // edges
        edgesHandler.setFileName(*file);
        MsgHandler::getMessageInstance()->beginProcessMsg("Parsing edges from osm-file '" + *file + "'...");
        XMLSubSys::runParser(edgesHandler, *file);
        MsgHandler::getMessageInstance()->endProcessMsg("done.");
    }

    /* Remove duplicate nodes with the same coordinates
     *
     * Without that, insertEdge can fail, if both nodes start
     * the shape of an edge. (NBEdge::init calls Position2DVector::push_front
     * with the second, which has the same coordinates as the first.) */
    MsgHandler::getMessageInstance()->beginProcessMsg("Removing duplicate nodes...");
    if (nodes.size() > 1) {
        // The algorithm compares a node (it) with the remaining part
        // of the list ( [itnext; end()[ ).
        for (std::map<int, NIOSMNode*>::iterator it = nodes.begin(), itnext =++nodes.begin(); itnext != nodes.end(); ++it, ++itnext) {
            std::map<int, NIOSMNode*>::iterator dupNode = find_if(itnext, nodes.end(), CompareNodesInPairs(*it));
            if (dupNode != nodes.end()) {
                MsgHandler::getMessageInstance()->inform("Found duplicate nodes. Substitute " + toString(dupNode->second->id) + " with " + toString(it->second->id));
                for_each(edges.begin(), edges.end(), SubstituteNode(dupNode->second, it->second));
            }
        }
    }
    MsgHandler::getMessageInstance()->endProcessMsg(" done.");

    /* Remove duplicate edges with the same shape and attributes */
    MsgHandler::getMessageInstance()->beginProcessMsg("Removing duplicate edges...");
    if (edges.size() > 1) {
        std::set<std::string> toRemove;
        for (std::map<std::string, Edge*>::iterator it = edges.begin(), itnext =++edges.begin(); itnext != edges.end(); ++it, ++itnext) {
            std::map<std::string, Edge*>::iterator dupEdge = find_if(itnext, edges.end(), SimilarEdge(*it));
            while (dupEdge != edges.end()) {
                MsgHandler::getMessageInstance()->inform("Found duplicate edges. Removing " + toString(dupEdge->first));
                toRemove.insert(dupEdge->first);
                dupEdge = find_if(++dupEdge, edges.end(), SimilarEdge(*it));
            }
        }
        for (std::set<std::string>::iterator i=toRemove.begin(); i!=toRemove.end(); ++i) {
            std::map<std::string, Edge*>::iterator j=edges.find(*i);
            delete(*j).second;
            edges.erase(j);
        }
    }
    MsgHandler::getMessageInstance()->endProcessMsg(" done.");

    /* Mark which nodes are used (by edges or traffic lights).
     * This is necessary to detect which OpenStreetMap nodes are for
     * geometry only */
    std::map<int, int> nodeUsage;
    // Mark which nodes are used by edges (begin and end)
    for (std::map<std::string, Edge*>::const_iterator i = edges.begin(); i != edges.end(); ++i) {
        Edge *e = (*i).second;
        if (!e->myCurrentIsRoad) {
            continue;
        }
        for (std::vector<int>::const_iterator j = e->myCurrentNodes.begin(); j != e->myCurrentNodes.end(); ++j) {
            if (nodeUsage.find(*j)==nodeUsage.end()) {
                nodeUsage[*j] = 0;
            }
            nodeUsage[*j] = nodeUsage[*j] + 1;
        }
    }
    // Mark which nodes are used by traffic lights
    for (std::map<int, NIOSMNode*>::const_iterator nodesIt = nodes.begin(); nodesIt != nodes.end(); ++nodesIt) {
        if (nodesIt->second->tlsControlled) {
            // If the key is not found in the map, the value is automatically
            // initialized with 0.
            nodeUsage[nodesIt->first] += 1;
        }
    }
    /* Instantiate edges
     * Only those nodes in the middle of an edge which are used by more than
     * one edge are instantiated. Other nodes are considered as geometry nodes. */
    NBNodeCont &nc = nb.getNodeCont();
    NBEdgeCont &ec = nb.getEdgeCont();
    NBTrafficLightLogicCont &tlsc = nb.getTLLogicCont();
    for (std::map<std::string, Edge*>::iterator i=edges.begin(); i!=edges.end(); ++i) {
        Edge *e = (*i).second;
        if (!e->myCurrentIsRoad) {
            continue;
        }
        // build nodes;
        //  the from- and to-nodes must be built in any case
        //  the geometry nodes are only built if more than one edge references them
        NBNode *currentFrom = insertNodeChecking(*e->myCurrentNodes.begin(), nodes, nc, tlsc);
        NBNode *last = insertNodeChecking(*(e->myCurrentNodes.end()-1), nodes, nc, tlsc);
        int running = 0;
        std::vector<int> passed;
        for (std::vector<int>::iterator j=e->myCurrentNodes.begin(); j!=e->myCurrentNodes.end(); ++j) {
            passed.push_back(*j);
            if (nodeUsage[*j] > 1 && j != e->myCurrentNodes.end()-1 && j != e->myCurrentNodes.begin()) {
                NBNode *currentTo = insertNodeChecking(*j, nodes, nc, tlsc);
                insertEdge(e, running, currentFrom, currentTo, passed, nodes, nc, ec, tc);
                currentFrom = currentTo;
                running++;
                passed.clear();
            }
        }
        if (running==0) {
            running = -1;
        }
        insertEdge(e, running, currentFrom, last, passed, nodes, nc, ec, tc);
    }
    /* Clean up */
    // delete nodes
    for (std::map<int, NIOSMNode*>::const_iterator i=nodes.begin(); i!=nodes.end(); ++i) {
        delete(*i).second;
    }
    // delete edges
    for (std::map<std::string, Edge*>::iterator i=edges.begin(); i!=edges.end(); ++i) {
        delete(*i).second;
    }
}

---

The documentation for this class was generated from the following files:

• NIImporter_OpenStreetMap.h
• NIImporter_OpenStreetMap.cpp