NIImporter_OpenDrive.h

Go to the documentation of this file.

/****************************************************************************/
// Importer for networks stored in openDrive format
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright 2001-2010 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program is free software; you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation; either version 2 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef NIImporter_OpenDrive_h
#define NIImporter_OpenDrive_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <string>
#include <map>
#include <utils/xml/SUMOSAXHandler.h>
#include <utils/geom/Position2DVector.h>


// ===========================================================================
// class declarations
// ===========================================================================
class NBNetBuilder;
class NBEdge;
class OptionsCont;
class NBNode;
class NBNodeCont;


#define UNSET_CONNECTION 100000

// ===========================================================================
// class definitions
// ===========================================================================
class NIImporter_OpenDrive : public SUMOSAXHandler {
public:
    static void loadNetwork(const OptionsCont &oc, NBNetBuilder &nb);


protected:
    enum LinkType {
        OPENDRIVE_LT_SUCCESSOR,
        OPENDRIVE_LT_PREDECESSOR
    };

    enum ElementType {
        OPENDRIVE_ET_UNKNOWN,
        OPENDRIVE_ET_ROAD,
        OPENDRIVE_ET_JUNCTION
    };

    enum ContactPoint {
        OPENDRIVE_CP_UNKNOWN,
        OPENDRIVE_CP_START,
        OPENDRIVE_CP_END
    };

    enum GeometryType {
        OPENDRIVE_GT_UNKNOWN,
        OPENDRIVE_GT_LINE,
        OPENDRIVE_GT_SPIRAL,
        OPENDRIVE_GT_ARC,
        OPENDRIVE_GT_POLY3
    };

    struct OpenDriveLink {
        OpenDriveLink(LinkType linkTypeArg, const std::string &elementIDArg)
                : linkType(linkTypeArg), elementID(elementIDArg),
                elementType(OPENDRIVE_ET_UNKNOWN), contactPoint(OPENDRIVE_CP_UNKNOWN) { }

        LinkType linkType;
        std::string elementID;
        ElementType elementType;
        ContactPoint contactPoint;
    };


    struct OpenDriveGeometry {
        OpenDriveGeometry(SUMOReal lengthArg, SUMOReal sArg, SUMOReal xArg, SUMOReal yArg, SUMOReal hdgArg)
                : length(lengthArg), s(sArg), x(xArg), y(yArg), hdg(hdgArg),
                type(OPENDRIVE_GT_UNKNOWN) { }

        SUMOReal length;
        SUMOReal s;
        SUMOReal x;
        SUMOReal y;
        SUMOReal hdg;
        GeometryType type;
        std::vector<SUMOReal> params;
    };


    struct OpenDriveLane {
        OpenDriveLane(int idArg, int levelArg, const std::string &typeArg)
                : id(idArg), level(levelArg), type(typeArg), successor(UNSET_CONNECTION), predecessor(UNSET_CONNECTION) { }

        int id;
        int level;
        std::string type;
        int successor;
        int predecessor;
    };


    struct OpenDriveLaneSection {
        OpenDriveLaneSection(SUMOReal sArg)
                : s(sArg) {
            lanesByDir[SUMO_TAG_OPENDRIVE_LEFT] = std::vector<OpenDriveLane>();
            lanesByDir[SUMO_TAG_OPENDRIVE_RIGHT] = std::vector<OpenDriveLane>();
            lanesByDir[SUMO_TAG_OPENDRIVE_CENTER] = std::vector<OpenDriveLane>();
        }

        unsigned int getLaneNumber(SumoXMLTag dir) const throw() {
            unsigned int laneNum = 0;
            const std::vector<OpenDriveLane> &dirLanes = lanesByDir.find(dir)->second;
            for (std::vector<OpenDriveLane>::const_iterator i=dirLanes.begin(); i!=dirLanes.end(); ++i) {
                if ((*i).type=="driving") {
                    ++laneNum;
                }
            }
            return laneNum;
        }

        std::map<int, int> buildLaneMapping(SumoXMLTag dir) {
            std::map<int, int> ret;
            unsigned int sumoLane = 0;
            const std::vector<OpenDriveLane> &dirLanes = lanesByDir.find(dir)->second;
            if (dir==SUMO_TAG_OPENDRIVE_RIGHT) {
                for (std::vector<OpenDriveLane>::const_reverse_iterator i=dirLanes.rbegin(); i!=dirLanes.rend(); ++i) {
                    if ((*i).type=="driving") {
                        ret[(*i).id] = sumoLane++;
                    }
                }
            } else {
                for (std::vector<OpenDriveLane>::const_iterator i=dirLanes.begin(); i!=dirLanes.end(); ++i) {
                    if ((*i).type=="driving") {
                        ret[(*i).id] = sumoLane++;
                    }
                }
            }
            return ret;
        }

        SUMOReal s;
        std::map<SumoXMLTag, std::vector<OpenDriveLane> > lanesByDir;
    };


    struct OpenDriveEdge {
        OpenDriveEdge(const std::string &idArg, const std::string &junctionArg, SUMOReal lengthArg)
                : id(idArg), junction(junctionArg), length(lengthArg),
                from(0), to(0) { }

        unsigned int getMaxLaneNumber(SumoXMLTag dir) const throw() {
            unsigned int maxLaneNum = 0;
            for (std::vector<OpenDriveLaneSection>::const_iterator i=laneSections.begin(); i!=laneSections.end(); ++i) {
                maxLaneNum = MAX2(maxLaneNum, (*i).getLaneNumber(dir));
            }
            return maxLaneNum;
        }

        std::string id;
        std::string junction;
        SUMOReal length;
        std::vector<OpenDriveLink> links;
        std::vector<OpenDriveGeometry> geometries;
        NBNode *from;
        NBNode *to;
        std::map<int, int> beginLaneMap;
        std::map<int, int> endLaneMap;
        Position2DVector geom;
        std::vector<OpenDriveLaneSection> laneSections;
    };


    struct Connection {
        Connection(NBEdge *fromArg, const std::string &viaArg, NBEdge *toArg)
                : from(fromArg), via(viaArg), to(toArg) { }
        NBEdge *from;
        NBEdge *to;
        std::string via;
        std::vector<std::pair<int, int> > lanes;
    };

protected:
    NIImporter_OpenDrive(NBNodeCont &nc, std::vector<OpenDriveEdge> &innerEdges, std::vector<OpenDriveEdge> &outerEdges);


    ~NIImporter_OpenDrive() throw();





    void myStartElement(SumoXMLTag element,
                        const SUMOSAXAttributes &attrs) throw(ProcessError);


    void myCharacters(SumoXMLTag element,
                      const std::string &chars) throw(ProcessError);


    void myEndElement(SumoXMLTag element) throw(ProcessError);



private:
    void addLink(LinkType lt, const std::string &elementType, const std::string &elementID,
                 const std::string &contactPoint) throw(ProcessError);

    void addGeometryShape(GeometryType type, const std::vector<SUMOReal> &vals) throw(ProcessError);

    OpenDriveEdge myCurrentEdge;

    std::vector<OpenDriveEdge> &myInnerEdges;
    std::vector<OpenDriveEdge> &myOuterEdges;
    std::vector<SumoXMLTag> myElementStack;
    SumoXMLTag myCurrentLaneDirection;


protected:
    static NBNode *getOrBuildNode(const std::string &id, Position2D &pos, NBNodeCont &nc) throw(ProcessError);


    static std::vector<Position2D> geomFromLine(const OpenDriveEdge &e, const OpenDriveGeometry &g) throw();
    static std::vector<Position2D> geomFromSpiral(const OpenDriveEdge &e, const OpenDriveGeometry &g) throw();
    static std::vector<Position2D> geomFromArc(const OpenDriveEdge &e, const OpenDriveGeometry &g) throw();
    static std::vector<Position2D> geomFromPoly(const OpenDriveEdge &e, const OpenDriveGeometry &g) throw();
    static Position2D calculateStraightEndPoint(double hdg, double length, const Position2D &start) throw();
    static void calculateCurveCenter(SUMOReal *ad_x, SUMOReal *ad_y, SUMOReal ad_radius, SUMOReal ad_hdg) throw();
    static void calcPointOnCurve(SUMOReal *ad_x, SUMOReal *ad_y, SUMOReal ad_centerX, SUMOReal ad_centerY,
                                 SUMOReal ad_r, SUMOReal ad_length) throw();
    static NBEdge *getOutgoingDirectionalEdge(const NBEdgeCont &ec, const NBNodeCont &nc,
            const std::string &edgeID, const std::string &nodeID) throw();
    static NBEdge *getIncomingDirectionalEdge(const NBEdgeCont &ec,const NBNodeCont &nc,
            const std::string &edgeID, const std::string &nodeID) throw();

    static void computeShapes(std::vector<OpenDriveEdge> &edges) throw();
    static void setNodeSecure(NBNodeCont &nc, OpenDriveEdge &e,
                              const std::string &nodeID, NIImporter_OpenDrive::LinkType lt) throw(ProcessError);

    static void addE2EConnectionsSecure(const NBEdgeCont &ec, const NBNode * const node,
                                        const OpenDriveEdge &from, const OpenDriveEdge &to,
                                        std::vector<NIImporter_OpenDrive::Connection> &connections);
    static void addViaConnectionSecure(const NBEdgeCont &ec, const NBNode * const node, const OpenDriveEdge &e,
                                       LinkType lt, const std::string &via,
                                       std::vector<NIImporter_OpenDrive::Connection> &connections);

    static void setLaneConnections(NIImporter_OpenDrive::Connection &c,
                                   const OpenDriveEdge &from, bool fromAtBegin, SumoXMLTag fromLaneDir,
                                   const OpenDriveEdge &to, bool toAtEnd, SumoXMLTag toLaneDir);

    static void setLaneConnections(NIImporter_OpenDrive::Connection &c,
                                   const OpenDriveEdge &from, bool fromAtBegin, SumoXMLTag fromLaneDir,
                                   const OpenDriveEdge &via, bool viaIsReversed, SumoXMLTag viaLaneDir,
                                   const OpenDriveEdge &to, bool fromAtEnd, SumoXMLTag toLaneDir);


    class edge_by_id_finder {
    public:
        explicit edge_by_id_finder(const std::string &id)
                : myEdgeID(id) { }

        bool operator()(const OpenDriveEdge &e) {
            return e.id==myEdgeID;
        }

    private:
        const std::string &myEdgeID;

    };


};


#endif

/****************************************************************************/