NIImporter_VISUM.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2026 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
/****************************************************************************/
// A VISUM network importer
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <map>
#include <vector>
#include <netbuild/NBCapacity2Lanes.h>
#include <utils/importio/LineHandler.h>
#include <utils/importio/LineReader.h>
#include <utils/importio/NamedColumnsParser.h>
#include "NIVisumTL.h"
 
 
// ===========================================================================
// class declaration
// ===========================================================================
class OptionsCont;
class NBNetBuilder;
class NBNodeCont;
class NBEdgeCont;
class NBNode;
class NBEdge;
 
 
// ===========================================================================
// class declaration
// ===========================================================================
class NIImporter_VISUM {
public:
    static void loadNetwork(const OptionsCont& oc, NBNetBuilder& nb);
 
 
protected:
    NIImporter_VISUM(NBNetBuilder& nb, const std::string& file,
                     NBCapacity2Lanes capacity2Lanes, bool useVisumPrio,
                     const std::string& languageFile);
 

    ~NIImporter_VISUM();
 

    void load();
 
private:
    double getNamedFloat(const std::string& fieldName);

    double getNamedFloat(const std::string& fieldName1, const std::string& fieldName2);
 

    double getNamedFloat(const std::string& fieldName, double defaultValue);

    double getNamedFloat(const std::string& fieldName1, const std::string& fieldName2,
                         double defaultValue);
 

    std::string getNamedString(const std::string& fieldName);

    std::string getNamedString(const std::string& fieldName1, const std::string& fieldName2);
 

    double getWeightedFloat(const std::string& name, const std::string& suffix);

    double getWeightedFloat2(const std::string& name, const std::string& name2, const std::string& suffix);

    SVCPermissions getPermissions(const std::string& name, const std::string& edgeType, SVCPermissions unknown);

    bool getWeightedBool(const std::string& name);
 

    NBNode* getNamedNode(const std::string& fieldName);
    NBNode* getNamedNodeSecure(const std::string& fieldName, NBNode* fallback = 0);

    NBNode* getNamedNode(const std::string& fieldName1, const std::string& fieldName2);
 

    NBEdge* getNamedEdge(const std::string& fieldName);

    NBEdge* getNamedEdge(const std::string& fieldName1, const std::string& fieldName2);
 

    NBEdge* getNamedEdgeContinuating(const std::string& fieldName, NBNode* node);

    NBEdge* getNamedEdgeContinuating(const std::string& fieldName1, const std::string& fieldName2,
                                     NBNode* node);

    NBEdge* getNamedEdgeContinuating(NBEdge* begin, NBNode* node);
 

    NBEdge* getEdge(NBNode* FromNode, NBNode* ToNode);
 

    NBEdge* getReversedContinuating(NBEdge* edge, NBNode* node);
 

    NBNode* buildDistrictNode(const std::string& id, NBNode* dest, bool isSource);
 

    bool checkNodes(NBNode* from, NBNode* to);
 
 
private:
    typedef void (NIImporter_VISUM::*ParsingFunction)();

    struct TypeParser {
        std::string name;

        ParsingFunction function;

        long position;

        std::string pattern;
 
    };
 

    void parse_Network();

    void parse_VSysTypes();

    void parse_Types();

    void parse_Nodes();

    void parse_Districts();

    void parse_Point();
 

    void parse_Edges();

    void parse_PartOfArea();

    void parse_Kante();
 

    void parse_Connectors();
    void parse_Connectors_legacy();

    void parse_Turns();

    void parse_EdgePolys();

    void parse_Lanes();

    void parse_TrafficLights();

    void parse_NodesToTrafficLights();

    void parse_SignalGroups();

    void parse_TurnsToSignalGroups();

    void parse_AreaSubPartElement();

    void parse_Phases();

    void parse_SignalGroupsToPhases();

    void parse_LanesConnections();

    void parse_stopPoints();

    void addParser(const std::string& name, ParsingFunction function);
 
private:

    static bool isSplitEdge(NBEdge* edge, NBNode* node);
 
 
private:
    NBNetBuilder& myNetBuilder;

    std::string myFileName;

    LineReader myLineReader;

    NamedColumnsParser myLineParser;

    NBCapacity2Lanes myCapacity2Lanes;

    struct VSysType {
        VSysType(const std::string& _type, const std::string& _name) : type(_type), name(_name) {}
        const std::string type;
        const std::string name;
    };
    typedef std::map<std::string, VSysType> VSysTypeNames;
    VSysTypeNames myVSysTypes;

    typedef std::vector<TypeParser> ParserVector;
    ParserVector mySingleDataParsers;

    typedef std::map<std::string, NIVisumTL*> NIVisumTL_Map;
    NIVisumTL_Map myTLS;

    std::vector<std::string > myTouchedEdges;

    bool myUseVisumPrio;

    std::string myCurrentID;
 

    std::map<long long int, Position> myPoints;

    std::map<long long int, std::pair<long long int, long long int> > myEdges;

    std::map<long long int, NBDistrict*> myShapeDistrictMap;

    std::map<long long int, std::vector<long long int> > mySubPartsAreas;

    std::map<NBDistrict*, PositionVector> myDistrictShapes;
 
    SVCPermissions myDefaultPermissions;
 
protected:
    enum VISUM_KEY {
        VISUM_SYS,
        VISUM_LINKTYPE,
        VISUM_NODE,
        VISUM_DISTRICT,
        VISUM_POINT,
        VISUM_LINK,
        VISUM_V0,
        VISUM_TYPES,
        VISUM_RANK,
        VISUM_CAPACITY,
        VISUM_XCOORD,
        VISUM_YCOORD,
        VISUM_FROMNODE,
        VISUM_TONODE,
        VISUM_TYPE,
        VISUM_TYP,
        VISUM_ID,
        VISUM_CODE,
        VISUM_DISTRICT_CONNECTION,
        VISUM_SOURCE_DISTRICT,
        VISUM_FROMNODENO,
        VISUM_DIRECTION,
        VISUM_SURFACEID,
        VISUM_FACEID,
        VISUM_FROMPOINTID,
        VISUM_TOPOINTID,
        VISUM_EDGE,
        VISUM_VIANODENO,
        VISUM_NUMLANES,
        VISUM_TURN,
        VISUM_INDEX,
        VISUM_LINKPOLY,
        VISUM_SURFACEITEM,
        VISUM_FACEITEM,
        VISUM_EDGEID,
        VISUM_ORIGIN,
        VISUM_DESTINATION,
        VISUM_STOPPOINT,
        VISUM_NAME,
        VISUM_LINKNO,
        VISUM_RELPOS,
        // polyconvert keys added to avoid warnings
        VISUM_CATID,
        VISUM_EDGEITEM,
        VISUM_POICATEGORY,
        VISUM_NETWORK,
        VISUM_PROJECTIONDEFINITION,
        VISUM_PRT,
        VISUM_NO // must be the last one
    };

    static StringBijection<VISUM_KEY>::Entry KEYS_DE[];

    static StringBijection<VISUM_KEY> KEYS;
 
    void loadLanguage(const std::string& file);
};