NBNodeCont.h

Go to the documentation of this file.

/****************************************************************************/
// Container for nodes during the netbuilding process
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright (C) 2001-2011 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program is free software; you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation; either version 2 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef NBNodeCont_h
#define NBNodeCont_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <string>
#include <map>
#include <vector>
#include <set>
#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 NBJoinedEdgesMap;


// ===========================================================================
// class definitions
// ===========================================================================
class NBNodeCont {
public:
    NBNodeCont() throw();


    ~NBNodeCont() throw();




    bool insert(const std::string& id, const Position& position,
                NBDistrict* district) throw();


    bool insert(const std::string& id, const Position& position) throw();


    Position insert(const std::string& id) throw();


    bool insert(NBNode* node) throw();


    bool erase(NBNode* node) throw();


    bool extract(NBNode* node, bool remember=false) throw();

    NBNode* retrieve(const std::string& id) const throw();


    NBNode* retrieve(const Position& position, SUMOReal offset=0.) const throw();


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


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


    unsigned int joinJunctions(SUMOReal maxdist, NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc);



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


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


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


    unsigned int removeUnwishedNodes(NBDistrictCont& dc, NBEdgeCont& ec, NBJoinedEdgesMap& je,
                                     NBTrafficLightLogicCont& tlc, bool removeGeometryNodes);




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


    void joinTLS(NBTrafficLightLogicCont& tlc);


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





    void computeLanes2Lanes();

    void computeLogics(const NBEdgeCont& ec, OptionsCont& oc);

    void sortNodesEdges(bool leftHand);

    void computeNodeTypes(const NBTypeCont& tc);

    void computePriorities();

    unsigned int size() const throw() {
        return (unsigned int) myNodes.size();
    }

    void clear();



    std::string getFreeID();

    void computeNodeShapes(bool leftHand);


    void guessRamps(OptionsCont& oc, NBEdgeCont& ec, NBDistrictCont& dc);


    void printBuiltNodesStatistics() const throw();


    std::vector<std::string> getAllNames() const throw();


    /* @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
     */
    void analyzeCluster(std::set<NBNode*> cluster, std::string& id, Position& pos, bool& hasTLS);


private:
    bool mayNeedOnRamp(OptionsCont& oc, NBNode* cur) const;
    bool mayNeedOffRamp(OptionsCont& oc, NBNode* cur) const;
    bool buildOnRamp(OptionsCont& oc, NBNode* cur,
                     NBEdgeCont& ec, NBDistrictCont& dc, EdgeVector& incremented);

    void buildOffRamp(OptionsCont& oc, NBNode* cur,
                      NBEdgeCont& ec, NBDistrictCont& dc, EdgeVector& incremented);

    void checkHighwayRampOrder(NBEdge *&pot_highway, NBEdge *&pot_ramp);




    typedef std::vector<std::set<NBNode*> > NodeClusters;


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

    // @brief merges two nodes using name and position of target
    void merge(NBNode* moved, NBNode* target, NBDistrictCont& dc, NBEdgeCont& ec);

    // @brief replaces oldEdge by an edge between from and to, keeping all attributes
    void remapEdge(NBEdge* oldEdge, NBNode* from, NBNode* to, NBDistrictCont& dc, NBEdgeCont& ec);

    // @brief joins the given node clusters
    void joinNodeClusters(NodeClusters clusters,
                          NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc);





    bool shouldBeTLSControlled(const std::set<NBNode*> &c) const;


private:
    int myInternalID;

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

    NodeCont myNodes;

    std::set<NBNode*> myExtractedNodes;

    // @brief set of node ids which should not be joined
    std::set<std::string> myJoinExclusions;

    // @brief loaded sets of node ids to join
    std::vector<std::set<std::string> > myClusters2Join;

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


private:
    NBNodeCont(const NBNodeCont& s);

    NBNodeCont& operator=(const NBNodeCont& s);

};


#endif

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