NIImporter_Vissim.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Importer for networks stored in Vissim format
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <map>
#include <vector>
#include <utils/common/RGBColor.h>
#include <utils/geom/Position.h>
#include "tempstructs/NIVissimExtendedEdgePoint.h"
#include "NIVissimElements.h"
#include <utils/xml/SUMOSAXHandler.h>
#include "tempstructs/NIVissimEdge.h"
#include "tempstructs/NIVissimConnection.h"
#include "tempstructs/NIVissimConflictArea.h"
 
#include <utils/common/SequentialStringBijection.h>
#include <utils/common/StringTokenizer.h>
#include <list>
 
// ===========================================================================
// class declarations
// ===========================================================================
class OptionsCont;
class NBNetBuilder;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NIImporter_Vissim {
public:
    static void loadNetwork(const OptionsCont& oc, NBNetBuilder& nb);
 
 
 
private:
 
    typedef std::map<std::string, std::list<std::string> > nodeMap;
    nodeMap elementData;
 
    class NIVissimXMLHandler_Streckendefinition : public GenericSAXHandler {
    public:
        //NIVissimXMLHandler_Streckendefinition(std::map<int, VissimXMLEdge>& toFill);
        NIVissimXMLHandler_Streckendefinition(nodeMap& elemData);
 
 
        ~NIVissimXMLHandler_Streckendefinition();
 
    protected:
 
 
        void myStartElement(int element, const SUMOSAXAttributes& attrs);
 
        void myEndElement(int element);
 
    private:
 
        //std::map<int, VissimXMLEdge> myToFill;
        nodeMap& myElemData;
 
        int myHierarchyLevel;
 
        bool isConnector;
 
        int myLastNodeID;
 
        NIVissimXMLHandler_Streckendefinition(const NIVissimXMLHandler_Streckendefinition& s);
 
        NIVissimXMLHandler_Streckendefinition& operator=(const NIVissimXMLHandler_Streckendefinition& s);
    };
 
 
private:
    class NIVissimXMLHandler_Zuflussdefinition : public GenericSAXHandler {
    public:
        NIVissimXMLHandler_Zuflussdefinition();
 
 
        ~NIVissimXMLHandler_Zuflussdefinition();
 
    protected:
 
 
        void myStartElement(int element, const SUMOSAXAttributes& attrs);
 
 
    private:
 
 
 
        NIVissimXMLHandler_Zuflussdefinition(const NIVissimXMLHandler_Zuflussdefinition& z);
 
        NIVissimXMLHandler_Zuflussdefinition& operator=(const NIVissimXMLHandler_Zuflussdefinition& z);
    };
 
 
private:
    class NIVissimXMLHandler_Parkplatzdefinition : public GenericSAXHandler {
    public:
        NIVissimXMLHandler_Parkplatzdefinition();
 
 
        ~NIVissimXMLHandler_Parkplatzdefinition();
 
    protected:
 
 
        void myStartElement(int element, const SUMOSAXAttributes& attrs);
 
 
    private:
 
 
 
        NIVissimXMLHandler_Parkplatzdefinition(const NIVissimXMLHandler_Parkplatzdefinition& z);
 
        NIVissimXMLHandler_Parkplatzdefinition& operator=(const NIVissimXMLHandler_Parkplatzdefinition& z);
    };
 
 
private:
    class NIVissimXMLHandler_Fahrzeugklassendefinition : public GenericSAXHandler {
    public:
        NIVissimXMLHandler_Fahrzeugklassendefinition(nodeMap& elemData);
 
 
        ~NIVissimXMLHandler_Fahrzeugklassendefinition();
 
    protected:
 
 
        void myStartElement(int element, const SUMOSAXAttributes& attrs);
 
        void myEndElement(int element);
 
    private:
 
        //std::map<int, VissimXMLEdge> myToFill;
        nodeMap& myElemData;
 
        int myHierarchyLevel;
 
        int myLastNodeID;
 
        NIVissimXMLHandler_Fahrzeugklassendefinition(const NIVissimXMLHandler_Fahrzeugklassendefinition& f);
 
        NIVissimXMLHandler_Fahrzeugklassendefinition& operator=(const NIVissimXMLHandler_Fahrzeugklassendefinition& f);
    };
 
private:
    class NIVissimXMLHandler_VWunschentscheidungsdefinition : public GenericSAXHandler {
    public:
        NIVissimXMLHandler_VWunschentscheidungsdefinition(nodeMap& elemData);
 
 
        ~NIVissimXMLHandler_VWunschentscheidungsdefinition();
 
    protected:
 
 
        void myStartElement(int element, const SUMOSAXAttributes& attrs);
 
        void myEndElement(int element);
 
    private:
 
        //std::map<int, VissimXMLEdge> myToFill;
        nodeMap& myElemData;
 
        int myHierarchyLevel;
 
        int myLastNodeID;
 
        NIVissimXMLHandler_VWunschentscheidungsdefinition(const NIVissimXMLHandler_VWunschentscheidungsdefinition& vW);
 
        NIVissimXMLHandler_VWunschentscheidungsdefinition& operator=(const NIVissimXMLHandler_VWunschentscheidungsdefinition& vW);
    };
 
 
 
 
private:
    class NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition : public GenericSAXHandler {
    public:
        NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition(nodeMap& elemData);
 
 
        ~NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition();
 
    protected:
 
 
        void myStartElement(int element, const SUMOSAXAttributes& attrs);
 
        void myEndElement(int element);
 
    private:
 
        //std::map<int, VissimXMLEdge> myToFill;
        nodeMap& myElemData;
 
        int myHierarchyLevel;
 
        int myLastNodeID;
 
        NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition(const NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition& vW);
 
        NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition& operator=(const NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition& vW);
    };
 
 
private:
    class NIVissimXMLHandler_Routenentscheidungsdefinition : public GenericSAXHandler {
    public:
        NIVissimXMLHandler_Routenentscheidungsdefinition(nodeMap& elemData);
 
 
        ~NIVissimXMLHandler_Routenentscheidungsdefinition();
 
    protected:
 
 
        void myStartElement(int element, const SUMOSAXAttributes& attrs);
 
        void myEndElement(int element);
 
    private:
 
        //std::map<int, VissimXMLEdge> myToFill;
        nodeMap& myElemData;
 
        int myHierarchyLevel;
 
        int myLastNodeID;
 
        NIVissimXMLHandler_Routenentscheidungsdefinition(const NIVissimXMLHandler_Routenentscheidungsdefinition& r);
 
        NIVissimXMLHandler_Routenentscheidungsdefinition& operator=(const NIVissimXMLHandler_Routenentscheidungsdefinition& r);
    };
 
 
private:
    class NIVissimXMLHandler_ConflictArea : public GenericSAXHandler {
    public:
        NIVissimXMLHandler_ConflictArea();
 
 
        ~NIVissimXMLHandler_ConflictArea();
 
 
    protected:
 
 
        void myStartElement(int element, const SUMOSAXAttributes& attrs);
 
 
    private:
 
 
        NIVissimXMLHandler_ConflictArea(const NIVissimXMLHandler_ConflictArea& c);
 
        NIVissimXMLHandler_ConflictArea& operator=(const NIVissimXMLHandler_ConflictArea& c);
    };
 
 
protected:
    NIImporter_Vissim(NBNetBuilder& nb);
 
    ~NIImporter_Vissim();
 
    void load(const OptionsCont& options);
 
    bool admitContinue(const std::string& tag);
 
public:
    class VissimSingleTypeParser {
    public:
        VissimSingleTypeParser(NIImporter_Vissim& parent);
 
        virtual ~VissimSingleTypeParser();
 
        virtual bool parse(std::istream& from) = 0;
 
    protected:
        std::string myRead(std::istream& from);
 
        std::string readEndSecure(std::istream& from,
                                  const std::string& excl = "");
 
        std::string readEndSecure(std::istream& from,
                                  const std::vector<std::string>& excl);
 
        std::string overrideOptionalLabel(std::istream& from,
                                          const std::string& tag = "");
 
        Position getPosition(std::istream& from);
 
        std::vector<int> parseAssignedVehicleTypes(std::istream& from,
                const std::string& next);
 
        NIVissimExtendedEdgePoint readExtEdgePointDef(std::istream& from);
 
        std::string readName(std::istream& from);
 
        bool skipOverreading(std::istream& from, const std::string& name = "");
 
        void readUntil(std::istream& from, const std::string& name);
 
    private:
        NIImporter_Vissim& myVissimParent;
 
    private:
        VissimSingleTypeParser& operator=(const VissimSingleTypeParser&);
 
    };
 
 
    typedef std::map<std::string, RGBColor> ColorMap;
 
private:
    bool readContents(std::istream& strm);
    void postLoadBuild(double offset);
 
 
    void insertKnownElements();
 
    void buildParsers();
 
private:
    typedef std::map<std::string, NIVissimElement> ToElemIDMap;
 
    ToElemIDMap myKnownElements;
 
    typedef std::map<NIVissimElement, VissimSingleTypeParser*> ToParserMap;
 
    ToParserMap myParsers;
 
    ColorMap myColorMap;
 
    std::string myLastSecure;
 
    NBNetBuilder& myNetBuilder;
 
private:
    NIImporter_Vissim(const NIImporter_Vissim&);
 
    NIImporter_Vissim& operator=(const NIImporter_Vissim&);
 
 
 
    enum VissimXMLTag {
        VISSIM_TAG_NOTHING = 0,
        VISSIM_TAG_NETWORK,
        VISSIM_TAG_LANES,
        VISSIM_TAG_LANE,
        VISSIM_TAG_LINK,
        VISSIM_TAG_LINKS,
        VISSIM_TAG_POINTS3D,
        VISSIM_TAG_POINT3D,
        VISSIM_TAG_LINKPOLYPOINT,
        VISSIM_TAG_LINKPOLYPTS,
        VISSIM_TAG_FROM,
        VISSIM_TAG_TO,
        VISSIM_TAG_VEHICLE_INPUT,
        VISSIM_TAG_PARKINGLOT,
        VISSIM_TAG_VEHICLE_CLASS,
        VISSIM_TAG_INTOBJECTREF,
        VISSIM_TAG_SPEED_DECISION,
        VISSIM_TAG_SPEED_DIST,
        VISSIM_TAG_DATAPOINT,
        VISSIM_TAG_DECISION_STATIC,
        VISSIM_TAG_ROUTE_STATIC,
        VISSIM_TAG_CA
    };
 
 
    enum VissimXMLAttr {
        VISSIM_ATTR_NOTHING = 0,
        VISSIM_ATTR_NO,
        VISSIM_ATTR_NAME,
        VISSIM_ATTR_X,
        VISSIM_ATTR_Y,
        VISSIM_ATTR_ZOFFSET,
        VISSIM_ATTR_ZUSCHLAG1,
        VISSIM_ATTR_ZUSCHLAG2,
        VISSIM_ATTR_WIDTH,
        VISSIM_ATTR_LINKBEHAVETYPE,
        VISSIM_ATTR_LANE,
        VISSIM_ATTR_POS,
        VISSIM_ATTR_LINK,
        VISSIM_ATTR_INTLINK,
        VISSIM_ATTR_PERCENTAGE,
        VISSIM_ATTR_DISTRICT,
        VISSIM_ATTR_COLOR,
        VISSIM_ATTR_KEY,
        VISSIM_ATTR_FX,
        VISSIM_ATTR_DESTLINK,
        VISSIM_ATTR_DESTPOS,
        VISSIM_ATTR_LINK1,
        VISSIM_ATTR_LINK2,
        VISSIM_ATTR_STATUS
    };
 
    static SequentialStringBijection::Entry vissimTags[];
 
    static SequentialStringBijection::Entry vissimAttrs[];
 
 
};