NBEdgeCont.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
/****************************************************************************/
// Storage for edges, including some functionality operating on multiple edges
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <map>
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include "NBCont.h"
#include <utils/common/SUMOVehicleClass.h>
#include <utils/common/UtilExceptions.h>
#include <utils/geom/PositionVector.h>
#include <utils/common/NamedRTree.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class OptionsCont;
class OutputDevice;
class NBNodeCont;
class NBTypeCont;
class NBEdge;
class NBNode;
class NBDistrictCont;
class NBTrafficLightLogicCont;
class NBPTStopCont;
class NBPTLineCont;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NBEdgeCont {
 
public:
    NBEdgeCont(NBTypeCont& tc);
 
    ~NBEdgeCont();
 
    void applyOptions(OptionsCont& oc);
 
    void clear();
 
 
    bool insert(NBEdge* edge, bool ignorePrunning = false);
 
    NBEdge* retrieve(const std::string& id, bool retrieveExtracted = false) const;
 
    NBEdge* retrievePossiblySplit(const std::string& id, bool downstream) const;
 
    NBEdge* retrievePossiblySplit(const std::string& id, const std::string& hint, bool incoming) const;
 
    NBEdge* retrievePossiblySplit(const std::string& id, double pos) const;
 
    void erase(NBDistrictCont& dc, NBEdge* edge);
 
    void extract(NBDistrictCont& dc, NBEdge* edge, bool remember = false);
 
    std::map<std::string, NBEdge*>::const_iterator begin() const {
        return myEdges.begin();
    }
 
    std::map<std::string, NBEdge*>::const_iterator end() const {
        return myEdges.end();
    }
 
 
    struct Split {
        std::vector<int> lanes;
        double pos = INVALID_DOUBLE;
        double speed = INVALID_DOUBLE;
        double friction = INVALID_DOUBLE;
        NBNode* node = nullptr;
        std::string idBefore;
        std::string idAfter;
        std::string nameID;
        double offset = 0.;
        int offsetFactor = 1;
    };
 
    void processSplits(NBEdge* e, std::vector<Split> splits,
                       NBNodeCont& nc, NBDistrictCont& dc, NBTrafficLightLogicCont& tlc);
 
    bool splitAt(NBDistrictCont& dc, NBEdge* edge, NBNode* node);
 
    bool splitAt(NBDistrictCont& dc, NBEdge* edge, NBNode* node,
                 const std::string& firstEdgeName, const std::string& secondEdgeName,
                 int noLanesFirstEdge, int noLanesSecondEdge,
                 const double speed = -1., const double friction = 1., const int changedLeft = 0);
 
    bool splitAt(NBDistrictCont& dc, NBEdge* edge, double edgepos, NBNode* node,
                 const std::string& firstEdgeName, const std::string& secondEdgeName,
                 int noLanesFirstEdge, int noLanesSecondEdge,
                 const double speed = -1., const double friction = 1., const int changedLeft = 0);
    
    std::string createUnusedID(const std::string& base, const std::string& sep);
 
 
    int size() const {
        return (int) myEdges.size();
    }
 
    std::vector<std::string> getAllNames() const;
 
    const std::pair<NBEdge*, NBEdge*>* getSplit(const NBEdge* const origEdge) const {
        const auto& split = myEdgesSplit.find(origEdge);
        if (split == myEdgesSplit.end()) {
            return nullptr;
        }
        return &split->second;
    }
 
    NBEdge* getSplitBase(const std::string& edgeID) const;
 
    int getNumEdgeSplits() const {
        return (int)myEdgesSplit.size();
    }
 
 
    int removeUnwishedEdges(NBDistrictCont& dc);
 
    void splitGeometry(NBDistrictCont& dc, NBNodeCont& nc);
 
    void reduceGeometries(const double minDist);
 
    void checkGeometries(const double maxAngle, bool fixAngle, const double minRadius, bool fix, bool fixRailways, bool silent = false);
 
 
    void sortOutgoingLanesConnections();
 
    void computeEdge2Edges(bool noLeftMovers);
 
    void computeLanes2Edges();
 
    void recheckLanes();
 
    void appendTurnarounds(bool noTLSControlled, bool noFringe, bool onlyDeadends, bool onlyTurnlane, bool noGeometryLike);
 
    void appendTurnarounds(const std::set<std::string>& ids, bool noTLSControlled);
 
    void appendRailwayTurnarounds(const NBPTStopCont& sc);
 
    void computeEdgeShapes(double smoothElevationThreshold = -1);
 
    void computeLaneShapes();
 
    void clearControllingTLInformation() const;
 
    void joinSameNodeConnectingEdges(NBDistrictCont& dc,
                                     NBTrafficLightLogicCont& tlc, EdgeVector edges);
 
    void guessOpposites();
 
    void recheckLaneSpread();
 
 
    NBEdge* getOppositeByID(const std::string& edgeID) const;
 
    NBEdge* getByID(const std::string& edgeID) const;
 
    int guessRoundabouts();
 
    int extractRoundabouts();
 
    // brief ensure myRoundabouts only holds valid edges
    void cleanupRoundabouts();
 
    bool wasIgnored(std::string id) const {
        return myIgnoredEdges.count(id) != 0;
    }
 
    void ignore(std::string id) {
        myIgnoredEdges.insert(id);
    }
 
    bool wasRemoved(std::string id) const {
        return myExtractedEdges.count(id) != 0;
    }
 
    void rename(NBEdge* edge, const std::string& newID);
 
 
    void addPostProcessConnection(const std::string& from, int fromLane, const std::string& to, int toLane, bool mayDefinitelyPass,
                                  KeepClear keepClear, double contPos, double visibility,
                                  double speed, double friction, double length,
                                  const PositionVector& customShape,
                                  bool uncontrolled,
                                  bool warnOnly,
                                  SVCPermissions permissions = SVC_UNSPECIFIED,
                                  bool indirectLeft = false,
                                  const std::string& edgeType = "",
                                  SVCPermissions changeLeft = SVC_UNSPECIFIED,
                                  SVCPermissions changeRight = SVC_UNSPECIFIED);
 
    bool hasPostProcessConnection(const std::string& from, const std::string& to = "");
 
    void recheckPostProcessConnections();
 
    void generateStreetSigns();
 
    int guessSpecialLanes(SUMOVehicleClass svc, double width, double minSpeed, double maxSpeed, bool fromPermissions, const std::string& excludeOpt,
                          NBTrafficLightLogicCont& tlc);
 
    const std::set<EdgeSet> getRoundabouts() const;
 
    bool hasGuessedRoundabouts() const {
        return myGuessedRoundabouts.size() > 0;
    }
 
    void addRoundabout(const EdgeSet& roundabout);
 
    void removeRoundabout(const NBNode* node);
    void removeRoundaboutEdges(const EdgeSet& toRemove);
 
    void markRoundabouts();
 
    void patchRoundabouts(NBEdge* orig, NBEdge* part1, NBEdge* part2, std::set<EdgeSet>& roundabouts);
 
    bool ignoreFilterMatch(NBEdge* edge);
 
    int remapIDs(bool numericaIDs, bool reservedIDs, bool keptIDs, const std::string& prefix, NBPTStopCont& sc);
 
    void checkOverlap(double threshold, double zThreshold) const;
 
    void checkGrade(double threshold) const;
 
    EdgeVector getGeneratedFrom(const std::string& id) const;
 
    int joinLanes(SVCPermissions perms);
 
    int joinTramEdges(NBDistrictCont& dc, NBPTStopCont& sc, NBPTLineCont& lc, double maxDist);
 
    EdgeVector getAllEdges() const;
 
    RouterEdgeVector getAllRouterEdges() const;
 
    bool checkConsistency(const NBNodeCont& nc);
 
    void updateAllChangeRestrictions(SVCPermissions ignoring);
 
    void addPrefix(const std::string& prefix);
 
    void fixSplitCustomLength();
 
    void computeAngles();
 
    std::set<std::string> getUsedTypes() const;
 
    int removeEdgesBySpeed(NBDistrictCont& dc);
    int removeEdgesByPermissions(NBDistrictCont& dc);
    int removeLanesByWidth(NBDistrictCont& dc, const double minWidth);
 
    int attachRemoved(NBNodeCont& nc, NBDistrictCont& dc, const double maxDist);
 
private:
    static double formFactor(const EdgeVector& loopEdges);
 
    void removeRoundaboutEdges(const EdgeSet& toRemove, std::set<EdgeSet>& roundabouts);
 
    NBTypeCont& myTypeCont;
 
    struct PostProcessConnection {
 
    public:
        PostProcessConnection(const std::string& from_, int fromLane_, const std::string& to_, int toLane_,
                              bool mayDefinitelyPass_, KeepClear keepClear_, double contPos_, double visibility_, double speed_,
                              double friction_, double length_,
                              const PositionVector& customShape_,
                              bool uncontrolled_,
                              bool warnOnly_,
                              SVCPermissions permissions_,
                              bool indirectLeft_,
                              const std::string& edgeType_,
                              SVCPermissions changeLeft_,
                              SVCPermissions changeRight_) :
            from(from_), fromLane(fromLane_), to(to_), toLane(toLane_), mayDefinitelyPass(mayDefinitelyPass_), keepClear(keepClear_), contPos(contPos_),
            visibility(visibility_),
            speed(speed_),
            friction(friction_),
            customLength(length_),
            customShape(customShape_),
            uncontrolled(uncontrolled_),
            permissions(permissions_),
            indirectLeft(indirectLeft_),
            edgeType(edgeType_),
            changeLeft(changeLeft_),
            changeRight(changeRight_),
            warnOnly(warnOnly_)
        {}
 
        std::string from;
 
        int fromLane;
 
        std::string to;
 
        int toLane;
 
        bool mayDefinitelyPass;
 
        KeepClear keepClear;
 
        double contPos;
 
        double visibility;
 
        double speed;
 
        double friction;
 
        double customLength;
 
        PositionVector customShape;
 
        bool uncontrolled;
 
        SVCPermissions permissions;
 
        bool indirectLeft;
 
        std::string edgeType;
 
        SVCPermissions changeLeft;
 
        SVCPermissions changeRight;
 
        bool warnOnly;
    };
 
    struct MinLaneComparatorIdLess {
        bool operator()(const std::pair<NBEdge*, int>& a, const std::pair<NBEdge*, int>& b) const;
    };
 
    std::map<std::string, std::vector<PostProcessConnection> > myConnections;
 
    typedef std::map<std::string, NBEdge*> EdgeCont;
 
    EdgeCont myEdges;
 
    EdgeCont myExtractedEdges;
 
    std::set<NBEdge*> myEdgeCemetery;
 
    std::set<std::string> myIgnoredEdges;
 
    std::map<const NBEdge*, std::pair<NBEdge*, NBEdge*> > myEdgesSplit;
    std::set<const NBEdge*> myWasSplit;
 
 
    double myEdgesMinSpeed;
 
    bool myRemoveEdgesAfterLoading;
 
    std::set<std::string> myEdges2Keep;
 
    std::set<std::string> myEdges2Remove;
 
    SVCPermissions myVehicleClasses2Keep;
 
    SVCPermissions myVehicleClasses2Remove;
 
    std::set<std::string> myTypes2Keep;
 
    std::set<std::string> myTypes2Remove;
 
    PositionVector myPruningBoundary;
 
    bool myNeedGeoTransformedPruningBoundary;
 
    std::set<EdgeSet> myRoundabouts;
 
    std::set<EdgeSet> myGuessedRoundabouts;
 
    class split_sorter {
    public:
        explicit split_sorter() { }
 
        int operator()(const Split& e1, const Split& e2) const {
            return e1.pos < e2.pos;
        }
    };
 
    NBEdgeCont(const NBEdgeCont& s) = delete;
 
    NBEdgeCont& operator=(const NBEdgeCont& s) = delete;
};