NBNodeCont.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
/****************************************************************************/
// Container for nodes during the netbuilding process
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <map>
#include <vector>
#include <set>
#include <utils/common/NamedRTree.h>
#include <utils/geom/Position.h>
#include "NBCont.h"
#include "NBEdgeCont.h"
#include "NBNode.h"
#include <utils/common/UtilExceptions.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class NBDistrict;
class OptionsCont;
class OutputDevice;
class NBParkingCont;
class NBPTLineCont;
class NBPTStopCont;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NBNodeCont {
 
public:
    typedef std::vector<NodeSet> NodeClusters;
    typedef std::pair<NBNode*, double> NodeAndDist;
 
    NBNodeCont() {}
 
    ~NBNodeCont();
 
 
    bool insert(const std::string& id, const Position& position, NBDistrict* district = 0);
 
    bool insert(NBNode* node);
 
    bool erase(NBNode* node);
 
    bool extract(NBNode* node, bool remember = false);
 
    NBNode* retrieve(const std::string& id) const;
 
    NBNode* retrieve(const Position& position, const double offset = 0.) const;
 
    std::map<std::string, NBNode*>::const_iterator begin() const {
        return myNodes.begin();
    }
 
    std::map<std::string, NBNode*>::const_iterator end() const {
        return myNodes.end();
    }
 
    /* @brief add ids of nodes wich shall not be joined
     * @param[in] ids A list of ids to exclude from joining
     * @note it does not check whether the nodes exist because all nodes may not have been loaded yet
     */
    void addJoinExclusion(const std::vector<std::string>& ids);
 
    std::string createClusterId(const NodeSet& cluster, const std::string& prefix = "cluster_") {
        std::set<std::string> clusterIds;
        for (NBNode* j : cluster) {
            clusterIds.insert(j->getID());
        }
        return createClusterId(clusterIds, prefix);
    }
 
    std::string createClusterId(const std::set<std::string>& cluster, const std::string& prefix = "cluster_");
 
    void addCluster2Join(const std::set<std::string>& cluster, NBNode* node);
 
    int joinLoadedClusters(NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc);
 
    int joinJunctions(double maxDist, NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc, NBPTStopCont& sc);
 
    int joinSameJunctions(NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc);
 
    static NodeSet getClusterNeighbors(const NBNode* n, double longThreshold, NodeSet& cluster);
 
    static bool isSlipLaneContinuation(const NBNode* cont);
 
    bool maybeSlipLaneStart(const NBNode* n, EdgeVector& outgoing, double& inAngle) const;
    bool maybeSlipLaneEnd(const NBNode* n, EdgeVector& incoming, double& outAngle) const;
 
    bool reduceToCircle(NodeSet& cluster, int circleSize, NodeSet startNodes, double maxDist, std::vector<NBNode*> cands = std::vector<NBNode*>()) const;
 
    NBEdge* shortestEdge(const NodeSet& cluster, const NodeSet& startNodes, const std::vector<NBNode*>& exclude) const;
 
 
    int removeSelfLoops(NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tc);
 
    void joinSimilarEdges(NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc, bool removeDuplicates);
 
    void avoidOverlap();
 
    int removeIsolatedRoads(NBDistrictCont& dc, NBEdgeCont& ec);
 
    int removeComponents(NBDistrictCont& dc, NBEdgeCont& ec, const int numKeep, bool hasPTStops);
 
    /* @brief remove rail components after ptstops are built
     * @return The number of removed edges
     */
    int removeRailComponents(NBDistrictCont& dc, NBEdgeCont& ec, NBPTStopCont& sc);
 
    int removeUnwishedNodes(NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc,
                            NBPTStopCont& sc, NBPTLineCont& lc, NBParkingCont& pc,
                            bool removeGeometryNodes);
 
 
    void guessTLs(OptionsCont& oc, NBTrafficLightLogicCont& tlc);
 
    void recheckGuessedTLS(NBTrafficLightLogicCont& tlc);
 
    bool recheckTLSThreshold(NBNode* node);
 
    void computeKeepClear();
 
    void joinTLS(NBTrafficLightLogicCont& tlc, double maxdist);
 
    void setAsTLControlled(NBNode* node, NBTrafficLightLogicCont& tlc, TrafficLightType type, std::string id = "");
 
    bool wasRemoved(std::string id) const {
        return myExtractedNodes.count(id) != 0;
    }
 
    void addPrefix(const std::string& prefix);
 
    void rename(NBNode* node, const std::string& newID);
 
    void computeLanes2Lanes();
 
    void computeLogics(const NBEdgeCont& ec);
 
    void computeLogics2(const NBEdgeCont& ec, OptionsCont& oc);
 
    int size() const {
        return (int) myNodes.size();
    }
 
    void clear();
 
    std::string getFreeID();
 
    void computeNodeShapes(double mismatchThreshold = -1);
 
    void printBuiltNodesStatistics() const;
 
    std::vector<std::string> getAllNames() const;
 
    /* @brief analyzes a cluster of nodes which shall be joined
     * @param[in] cluster The nodes to be joined
     * @param[out] id The name for the new node
     * @param[out] pos The position of the new node
     * @param[out] hasTLS Whether the new node has a traffic light
     * @param[out] tlType The type of traffic light (if any)
     */
    void analyzeCluster(NodeSet cluster, std::string& id, Position& pos,
                        bool& hasTLS, TrafficLightType& type, SumoXMLNodeType& nodeType);
 
    void registerJoinedCluster(const NodeSet& cluster);
    void registerJoinedCluster(const std::set<std::string>& cluster);
 
    void unregisterJoinedCluster(const std::set<std::string>& cluster);
 
    const std::vector<std::set<std::string> >& getJoinedClusters() const {
        return myJoinedClusters;
    }
 
    /* @brief discards traffic lights
     * @param[in] geometryLike Whether only tls at geometry-like nodes shall be discarded
     */
    void discardTrafficLights(NBTrafficLightLogicCont& tlc, bool geometryLike, bool guessSignals);
 
    void discardRailSignals();
 
    void markAsSplit(const NBNode* node) {
        mySplit.insert(node);
    }
 
    void markAsNotTLS(const NBNode* node) {
        myUnsetTLS.insert(node);
    }
 
    int remapIDs(bool numericaIDs, bool reservedIDs, const std::string& prefix, NBTrafficLightLogicCont& tlc);
 
    int guessFringe();
 
    void applyConditionalDefaults();
 
    bool resetNodeShapes();
 
private:
 
 
    void generateNodeClusters(double maxDist, NodeClusters& into) const;
 
    void pruneClusterFringe(NodeSet& cluster, double maxDist) const;
 
    static int pruneLongEdges(NodeSet& cluster, double maxDist, const bool dryRun = false);
 
    static double getDiameter(const NodeSet& cluster);
 
    static bool geometryLikeForClass(const NBNode* n, SVCPermissions permissions);
 
    void pruneSlipLaneNodes(NodeSet& cluster, double maxDist) const;
 
    bool feasibleCluster(const NodeSet& cluster, const std::map<const NBNode*, std::vector<NBNode*> >& ptStopEnds,
                         double maxDist, std::string& reason) const;
 
    void joinNodeClusters(NodeClusters clusters, NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc, bool resetConnections = false);
    void joinNodeCluster(NodeSet clusters, NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc,
                         NBNode* predefined = nullptr, bool resetConnections = false);
 
 
 
    bool shouldBeTLSControlled(const NodeSet& c, double laneSpeedThreshold, bool recheck = false) const;
 
    bool onlyCrossings(const NodeSet& c) const;
 
    bool customTLID(const NodeSet& c) const;
 
    void paretoCheck(NBNode* node, NodeSet& frontier, int xSign, int ySign);
 
    typedef std::map<std::string, NBNode*> NodeCont;
 
    NodeCont myNodes;
 
    NodeCont myExtractedNodes;
 
    std::set<std::string> myJoinExclusions;
 
    std::vector<std::pair<std::set<std::string>, NBNode*> > myClusters2Join;
 
    std::vector<std::set<std::string> > myJoinedClusters;
 
    std::set<std::string> myJoined;
 
    std::set<const NBNode*> mySplit;
 
    std::set<NBNode*, ComparatorIdLess> myGuessedTLS;
 
    std::set<const NBNode*> myUnsetTLS;
 
    NamedRTree myRTree;
 
    std::vector<std::vector<std::string> > myRailComponents;
 
    NBNodeCont(const NBNodeCont& s) = delete;
 
    NBNodeCont& operator=(const NBNodeCont& s) = delete;
};