NIVissimEdge.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 temporary storage for edges imported from Vissim
/****************************************************************************/
#pragma once
#include <config.h>
 
#include "NIVissimConnectionCluster.h"
#include <vector>
#include <string>
#include <map>
#include <netbuild/NBEdge.h>
#include <utils/geom/PositionVector.h>
#include <utils/common/UtilExceptions.h>
#include "NIVissimAbstractEdge.h"
#include "NIVissimClosedLanesVector.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class NBNode;
class NBDistrictCont;
class NIVissimDistrictConnection;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NIVissimEdge
    : public NIVissimAbstractEdge {
public:
    NIVissimEdge(int id, const std::string& name,
                 const std::string& type,
                 std::vector<double> laneWidths,
                 double zuschlag1,
                 double zuschlag2, double length,
                 const PositionVector& geom,
                 const NIVissimClosedLanesVector& clv);
 
    ~NIVissimEdge();
 
    void setNodeCluster(int nodeid);
    void buildGeom();
 
    void addIncomingConnection(int id);
 
    void addOutgoingConnection(int id);
 
    Position getBegin2D() const;
 
    Position getEnd2D() const;
 
    double getLength() const;
 
    void checkDistrictConnectionExistanceAt(double pos);
 
    void mergedInto(NIVissimConnectionCluster* old,
                    NIVissimConnectionCluster* act);
 
    void removeFromConnectionCluster(NIVissimConnectionCluster* c);
    void addToConnectionCluster(NIVissimConnectionCluster* c);
    void setSpeed(int lane, int speedDist);
    bool addToTreatAsSame(NIVissimEdge* e);
 
    NIVissimConnection* getConnectionTo(NIVissimEdge* e);
    const std::vector<NIVissimEdge*>& getToTreatAsSame() const;
 
 
    bool wasWithinAJunction() const {
        return myAmWithinJunction;
    }
 
    NIVissimEdge* getBestIncoming() const;
    NIVissimEdge* getBestOutgoing() const;
 
    friend class NIVissimNodeDef_Edges;
    friend class NIVissimNodeDef_Poly;
 
public:
    static bool dictionary(int id, const std::string& name,
                           const std::string& type, int noLanes, double zuschlag1,
                           double zuschlag2, double length,
                           const PositionVector& geom,
                           const NIVissimClosedLanesVector& clv);
 
    static bool dictionary(int id, NIVissimEdge* o);
 
    static NIVissimEdge* dictionary(int id);
 
    static void buildConnectionClusters();
 
    static void dict_buildNBEdges(NBDistrictCont& dc, NBNodeCont& nc,
                                  NBEdgeCont& ec, double offset);
 
    static void dict_propagateSpeeds();
 
    static void dict_checkEdges2Join();
 
 
    static void reportUnsetSpeeds();
 
 
private:
    typedef std::vector<NIVissimConnectionCluster*> ConnectionClusters;
 
private:
    void buildNBEdge(NBDistrictCont& dc, NBNodeCont& nc,
                     NBEdgeCont& ec, double sameNodesOffset);
 
    std::pair<NIVissimConnectionCluster*, NBNode*>
    getFromNode(NBNodeCont& nc, ConnectionClusters& clusters);
 
    std::pair<NIVissimConnectionCluster*, NBNode*>
    getToNode(NBNodeCont& nc, ConnectionClusters& clusters);
 
    std::pair<NBNode*, NBNode*> resolveSameNode(NBNodeCont& nc,
            double offset, NBNode* prevFrom, NBNode* prevTo);
 
//    double recheckSpeedPatches();
 
    std::vector<NIVissimConnection*> getOutgoingConnected(int lane) const;
 
    void propagateSpeed(double speed, std::vector<int> forLanes);
 
 
    void setDistrictSpeed();
    double getRealSpeed(int distNo);
    void checkUnconnectedLaneSpeeds();
    void propagateOwn();
 
 
 
private:
    static NBNode* getNodeSecure(int nodeid, const Position& pos,
                                 const std::string& possibleName);
 
    std::pair<NBNode*, NBNode*>
    remapOneOfNodes(NBNodeCont& nc,
                    NIVissimDistrictConnection* d,
                    NBNode* fromNode, NBNode* toNode);
 
private:
    class connection_position_sorter {
    public:
        explicit connection_position_sorter(int edgeid);
 
        int operator()(int c1id, int c2id) const;
 
    private:
        int myEdgeID;
 
    };
 
 
    class connection_cluster_position_sorter {
    public:
        explicit connection_cluster_position_sorter(int edgeid);
 
        int operator()(NIVissimConnectionCluster* cc1,
                       NIVissimConnectionCluster* cc2) const;
 
    private:
        int myEdgeID;
 
    };
 
private:
    std::string myName;
 
    std::string myType;
 
    int myNoLanes;
    std::vector<double> myLaneWidths;
 
    double myZuschlag1, myZuschlag2;
 
    NIVissimClosedLanesVector myClosedLanes;
 
    ConnectionClusters myConnectionClusters;
 
    std::vector<int> myIncomingConnections;
 
    std::vector<int> myOutgoingConnections;
 
    std::vector<double> myDistrictConnections;
 
    std::vector<int> myPatchedSpeeds;
 
    std::vector<double> myLaneSpeeds;
 
    std::vector<NIVissimEdge*> myToTreatAsSame;
 
    bool myAmWithinJunction;
 
private:
    typedef std::map<int, NIVissimEdge*> DictType;
 
    static DictType myDict;
 
    static int myMaxID;
 
    static std::vector<std::string> myLanesWithMissingSpeeds;
 
};