NBNodeCont.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2001-2018 German Aerospace Center (DLR) and others.
// This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v20.html
// SPDX-License-Identifier: EPL-2.0
/****************************************************************************/
// Container for nodes during the netbuilding process
/****************************************************************************/
#ifndef NBNodeCont_h
#define NBNodeCont_h


// ===========================================================================
// included modules
// ===========================================================================
#include <config.h>

#include <string>
#include <map>
#include <vector>
#include <set>
#include <utils/common/NamedRTree.h>
#include <utils/geom/Position.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::set<NBNode*, ComparatorIdLess> NodeSet;
    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
     * @param[in] check Whether to check if these nodes are known
     * @note checking is off by default because all nodes may not have been loaded yet
     */
    void addJoinExclusion(const std::vector<std::string>& ids, bool check = false);

    void addCluster2Join(std::set<std::string> cluster);

    int joinLoadedClusters(NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc);

    int joinJunctions(double maxDist, NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc, NBPTStopCont& sc);

    void pruneClusterFringe(NodeSet& cluster) const;

    bool feasibleCluster(const NodeSet& cluster, const NBEdgeCont& ec, const NBPTStopCont& sc, std::string& reason) const;

    bool reduceToCircle(NodeSet& cluster, int circleSize, NodeSet startNodes, std::vector<NBNode*> cands = std::vector<NBNode*>()) const;

    NBEdge* shortestEdge(const NodeSet& cluster, const NodeSet& startNodes, const std::vector<NBNode*>& exclude) const;


    void removeSelfLoops(NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tc);

    void joinSimilarEdges(NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc);

    void avoidOverlap();

    void removeIsolatedRoads(NBDistrictCont& dc, NBEdgeCont& ec);

    void removeComponents(NBDistrictCont& dc, NBEdgeCont& ec, const int numKeep);

    int removeUnwishedNodes(NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc,
                            NBPTStopCont& sc, NBPTLineCont& lc,
                            NBParkingCont& pc,
                            bool removeGeometryNodes);


    void guessTLs(OptionsCont& oc, NBTrafficLightLogicCont& tlc);

    void joinTLS(NBTrafficLightLogicCont& tlc, double maxdist);

    void setAsTLControlled(NBNode* node, NBTrafficLightLogicCont& tlc, TrafficLightType type, std::string id = "");

    void rename(NBNode* node, const std::string& newID);

    void computeLanes2Lanes();

    void computeLogics(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);

    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);

    /* @brief discards rail signals
     */
    void discardRailSignals();

    void markAsSplit(const NBNode* node) {
        mySplit.insert(node);
    }

    int remapIDs(bool numericaIDs, bool reservedIDs, const std::string& prefix);

private:


    void generateNodeClusters(double maxDist, NodeClusters& into) const;

    void joinNodeClusters(NodeClusters clusters, NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc);



    bool shouldBeTLSControlled(const NodeSet& c) const;


private:
    int myInternalID;

    typedef std::map<std::string, NBNode*> NodeCont;

    NodeCont myNodes;

    std::set<NBNode*> myExtractedNodes;

    std::set<std::string> myJoinExclusions;

    std::vector<std::set<std::string> > myClusters2Join;

    std::vector<std::set<std::string> > myJoinedClusters;

    std::set<std::string> myJoined;

    std::set<const NBNode*> mySplit;

    NamedRTree myRTree;

private:
    NBNodeCont(const NBNodeCont& s);

    NBNodeCont& operator=(const NBNodeCont& s);

};


#endif

/****************************************************************************/