NIImporter_VISUM.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
/****************************************************************************/
// 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, bool warn = false, SVCPermissions unknown = SVCAll);
 
    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_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;
 
    typedef std::map<std::string, std::string> 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;
 
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_NO // must be the last one
    };
 
    static StringBijection<VISUM_KEY>::Entry KEYS_DE[];
 
    static StringBijection<VISUM_KEY> KEYS;
 
    void loadLanguage(const std::string& file);
};