SUMO - Simulation of Urban MObility
NBEdgeCont.h
Go to the documentation of this file.
1 /****************************************************************************/
9 // Storage for edges, including some functionality operating on multiple edges
10 /****************************************************************************/
11 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
12 // Copyright (C) 2001-2015 DLR (http://www.dlr.de/) and contributors
13 /****************************************************************************/
14 //
15 // This file is part of SUMO.
16 // SUMO is free software: you can redistribute it and/or modify
17 // it under the terms of the GNU General Public License as published by
18 // the Free Software Foundation, either version 3 of the License, or
19 // (at your option) any later version.
20 //
21 /****************************************************************************/
22 #ifndef NBEdgeCont_h
23 #define NBEdgeCont_h
24 
25 
26 // ===========================================================================
27 // included modules
28 // ===========================================================================
29 #ifdef _MSC_VER
30 #include <windows_config.h>
31 #else
32 #include <config.h>
33 #endif
34 
35 #include <map>
36 #include <iostream>
37 #include <string>
38 #include <vector>
39 #include <set>
40 #include "NBCont.h"
44 
45 
46 // ===========================================================================
47 // class declarations
48 // ===========================================================================
49 class NBNodeCont;
50 class NBTypeCont;
51 class NBEdge;
52 class NBNode;
53 class OptionsCont;
54 class NBDistrictCont;
56 class OutputDevice;
57 
58 
59 // ===========================================================================
60 // class definitions
61 // ===========================================================================
66 class NBEdgeCont {
67 public:
72 
73 
75  ~NBEdgeCont();
76 
77 
86  void applyOptions(OptionsCont& oc);
87 
88 
90  void clear();
91 
92 
93 
94 
97 
111  bool insert(NBEdge* edge, bool ignorePrunning = false);
112 
113 
122  NBEdge* retrieve(const std::string& id, bool retrieveExtracted = false) const;
123 
124 
135  NBEdge* retrievePossiblySplit(const std::string& id, bool downstream) const;
136 
137 
150  NBEdge* retrievePossiblySplit(const std::string& id, const std::string& hint, bool incoming) const;
151 
152 
163  NBEdge* retrievePossiblySplit(const std::string& id, SUMOReal pos) const;
164 
165 
172  void erase(NBDistrictCont& dc, NBEdge* edge);
173 
174 
184  void extract(NBDistrictCont& dc, NBEdge* edge, bool remember = false);
185 
186 
190  std::map<std::string, NBEdge*>::const_iterator begin() const {
191  return myEdges.begin();
192  }
193 
194 
198  std::map<std::string, NBEdge*>::const_iterator end() const {
199  return myEdges.end();
200  }
202 
203 
204 
207 
221  bool splitAt(NBDistrictCont& dc, NBEdge* edge, NBNode* node);
222 
223 
247  bool splitAt(NBDistrictCont& dc, NBEdge* edge, NBNode* node,
248  const std::string& firstEdgeName, const std::string& secondEdgeName,
249  unsigned int noLanesFirstEdge, unsigned int noLanesSecondEdge,
250  const SUMOReal speed = -1., const int changedLeft = 0);
251 
252 
268  bool splitAt(NBDistrictCont& dc, NBEdge* edge, SUMOReal edgepos, NBNode* node,
269  const std::string& firstEdgeName, const std::string& secondEdgeName,
270  unsigned int noLanesFirstEdge, unsigned int noLanesSecondEdge,
271  const SUMOReal speed = -1., const int changedLeft = 0);
273 
274 
275 
278 
282  unsigned int size() const {
283  return (unsigned int) myEdges.size();
284  }
285 
286 
291  std::vector<std::string> getAllNames() const;
292 
293 
297  unsigned int getNoEdgeSplits() const {
298  return myEdgesSplit;
299  }
301 
302 
303 
306 
312 
313 
322  void splitGeometry(NBNodeCont& nc);
323 
324 
329  void reduceGeometries(const SUMOReal minDist);
330 
331 
338  void checkGeometries(const SUMOReal maxAngle, const SUMOReal minRadius, bool fix);
340 
341 
342 
345 
354 
355 
364  void computeEdge2Edges(bool noLeftMovers);
365 
366 
374  void computeLanes2Edges(const bool buildCrossingsAndWalkingAreas);
375 
376 
384  void recheckLanes(const bool buildCrossingsAndWalkingAreas);
385 
386 
395  void appendTurnarounds(bool noTLSControlled);
396 
397 
404  void appendTurnarounds(const std::set<std::string>& ids, bool noTLSControlled);
405 
406 
415  void computeEdgeShapes();
416 
417 
426  void computeLaneShapes();
427 
428 
431  void clearControllingTLInformation() const;
432 
433 
442  NBTrafficLightLogicCont& tlc, EdgeVector edges);
443 
444 
449  void recheckLaneSpread();
451 
452 
453 
457  void guessRoundabouts();
458 
459 
463  bool isLeftHanded() const {
464  return myAmLeftHanded;
465  }
466 
467 
471  bool wasIgnored(std::string id) const {
472  return myIgnoredEdges.count(id) != 0;
473  }
474 
475 
478  bool wasRemoved(std::string id) const {
479  return myExtractedEdges.count(id) != 0;
480  }
481 
484  void rename(NBEdge* edge, const std::string& newID);
485 
486 
487 
490 
498  void addPostProcessConnection(const std::string& from, int fromLane, const std::string& to, int toLane, bool mayDefinitelyPass);
499 
500 
505 
507  void generateStreetSigns();
508 
510  int guessSidewalks(SUMOReal width, SUMOReal minSpeed, SUMOReal maxSpeed, bool fromPermissions);
511 
512 
516  const std::set<EdgeSet> getRoundabouts() const;
517 
519  void addRoundabout(const EdgeSet& roundabout);
520 
522  void markRoundabouts();
523 
524 private:
531  EdgeVector getGeneratedFrom(const std::string& id) const;
532 
533 
535  bool ignoreFilterMatch(NBEdge* edge);
536 
537 private:
540 
545  public:
553  PostProcessConnection(const std::string& from_, int fromLane_, const std::string& to_, int toLane_, bool mayDefinitelyPass_)
554  : from(from_), fromLane(fromLane_), to(to_), toLane(toLane_), mayDefinitelyPass(mayDefinitelyPass_)
555  { }
557  std::string from;
559  int fromLane;
561  std::string to;
563  int toLane;
566  };
567 
569  std::vector<PostProcessConnection> myConnections;
570 
571 
573  typedef std::map<std::string, NBEdge*> EdgeCont;
574 
576  EdgeCont myEdges;
577 
580 
582  std::set<std::string> myIgnoredEdges;
583 
585  unsigned int myEdgesSplit;
586 
589 
590 
593 
596 
599 
601  std::set<std::string> myEdges2Keep;
602 
604  std::set<std::string> myEdges2Remove;
605 
608 
611 
613  std::set<std::string> myTypes2Keep;
614 
616  std::set<std::string> myTypes2Remove;
617 
620 
624 
626  std::set<EdgeSet> myRoundabouts;
628  std::set<EdgeSet> myGuessedRoundabouts;
629 
630 
631 private:
633  NBEdgeCont(const NBEdgeCont& s);
634 
636  NBEdgeCont& operator=(const NBEdgeCont& s);
637 
638 
639 };
640 
641 
642 #endif
643 
644 /****************************************************************************/
645 
~NBEdgeCont()
Destructor.
Definition: NBEdgeCont.cpp:78
int guessSidewalks(SUMOReal width, SUMOReal minSpeed, SUMOReal maxSpeed, bool fromPermissions)
add sidwalks to edges within the given limits or permissions and return the number of edges affected ...
Definition: NBEdgeCont.cpp:994
void sortOutgoingLanesConnections()
Sorts all lanes of all edges within the container by their direction.
Definition: NBEdgeCont.cpp:570
bool myAmLeftHanded
Whether the network is left-handed.
Definition: NBEdgeCont.h:588
void markRoundabouts()
mark edge priorities and prohibit turn-arounds for all roundabout edges
Definition: NBEdgeCont.cpp:930
NBEdge * retrievePossiblySplit(const std::string &id, bool downstream) const
Tries to retrieve an edge, even if it is splitted.
Definition: NBEdgeCont.cpp:275
std::vector< std::string > getAllNames() const
Returns all ids of known edges.
Definition: NBEdgeCont.cpp:504
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
Definition: NBEdgeCont.cpp:912
bool myNeedGeoTransformedPrunningBoundary
whether a geo transform has been applied to the pruning boundary
Definition: NBEdgeCont.h:622
A container for traffic light definitions and built programs.
bool myRemoveEdgesAfterJoining
Whether edges shall be joined first, then removed.
Definition: NBEdgeCont.h:598
std::map< std::string, NBEdge * > EdgeCont
The type of the dictionary where an edge may be found by its id.
Definition: NBEdgeCont.h:573
int SVCPermissions
The representation of a single edge during network building.
Definition: NBEdge.h:71
unsigned int getNoEdgeSplits() const
Returns the number of edge splits.
Definition: NBEdgeCont.h:297
A container for districts.
void clearControllingTLInformation() const
Clears information about controlling traffic lights for all connenections of all edges.
Definition: NBEdgeCont.cpp:562
void generateStreetSigns()
assigns street signs to edges based on toNode types
Definition: NBEdgeCont.cpp:956
void rename(NBEdge *edge, const std::string &newID)
Renames the edge. Throws exception if newID already exists.
Definition: NBEdgeCont.cpp:392
bool splitAt(NBDistrictCont &dc, NBEdge *edge, NBNode *node)
Splits the edge at the position nearest to the given node.
Definition: NBEdgeCont.cpp:404
void recheckPostProcessConnections()
Try to set any stored connections.
Definition: NBEdgeCont.cpp:748
unsigned int myEdgesSplit
the number of splits of edges during the building
Definition: NBEdgeCont.h:585
PostProcessConnection(const std::string &from_, int fromLane_, const std::string &to_, int toLane_, bool mayDefinitelyPass_)
Constructor.
Definition: NBEdgeCont.h:553
std::vector< PostProcessConnection > myConnections
The list of connections to recheck.
Definition: NBEdgeCont.h:569
void checkGeometries(const SUMOReal maxAngle, const SUMOReal minRadius, bool fix)
Definition: NBEdgeCont.cpp:551
NBEdgeCont(NBTypeCont &tc)
Constructor.
Definition: NBEdgeCont.cpp:69
SVCPermissions myVehicleClasses2Keep
Set of vehicle types which must be allowed on edges in order to keep them.
Definition: NBEdgeCont.h:607
void reduceGeometries(const SUMOReal minDist)
Definition: NBEdgeCont.cpp:543
void computeLanes2Edges(const bool buildCrossingsAndWalkingAreas)
Computes for each edge which lanes approach the next edges.
Definition: NBEdgeCont.cpp:586
std::set< NBEdge * > EdgeSet
Definition: NBCont.h:51
std::map< std::string, NBEdge * >::const_iterator end() const
Returns the pointer to the end of the stored edges.
Definition: NBEdgeCont.h:198
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
Definition: NBEdgeCont.cpp:170
void removeUnwishedEdges(NBDistrictCont &dc)
Removes unwished edges (not in keep-edges)
Definition: NBEdgeCont.cpp:515
void extract(NBDistrictCont &dc, NBEdge *edge, bool remember=false)
Removes the given edge from the container like erase but does not delete it.
Definition: NBEdgeCont.cpp:380
void guessRoundabouts()
Determines which edges belong to roundabouts and increases their priority.
Definition: NBEdgeCont.cpp:820
A list of positions.
void applyOptions(OptionsCont &oc)
Initialises the storage by applying given options.
Definition: NBEdgeCont.cpp:84
bool mayDefinitelyPass
Whether the connection may be passed without braking.
Definition: NBEdgeCont.h:565
std::set< std::string > myEdges2Keep
Set of ids of edges which shall explicitly be kept.
Definition: NBEdgeCont.h:601
void computeEdge2Edges(bool noLeftMovers)
Computes for each edge the approached edges.
Definition: NBEdgeCont.cpp:578
void computeLaneShapes()
Computes the shapes of all lanes of all edges stored in the container.
Definition: NBEdgeCont.cpp:626
Storage for edges, including some functionality operating on multiple edges.
Definition: NBEdgeCont.h:66
void splitGeometry(NBNodeCont &nc)
Splits edges into multiple if they have a complex geometry.
Definition: NBEdgeCont.cpp:532
EdgeCont myEdges
The instance of the dictionary (id->edge)
Definition: NBEdgeCont.h:576
void clear()
Deletes all edges.
Definition: NBEdgeCont.cpp:155
EdgeCont myExtractedEdges
The extracted nodes which are kept for reference.
Definition: NBEdgeCont.h:579
std::set< EdgeSet > myGuessedRoundabouts
Edges marked as belonging to a roundabout after guessing.
Definition: NBEdgeCont.h:628
std::set< EdgeSet > myRoundabouts
Edges marked as belonging to a roundabout by the user (each EdgeVector is a roundabout) ...
Definition: NBEdgeCont.h:626
void joinSameNodeConnectingEdges(NBDistrictCont &dc, NBTrafficLightLogicCont &tlc, EdgeVector edges)
Joins the given edges because they connect the same nodes.
Definition: NBEdgeCont.cpp:634
SVCPermissions myVehicleClasses2Remove
Set of vehicle types which need not be supported (edges which allow ONLY these are removed) ...
Definition: NBEdgeCont.h:610
std::string from
The id of the edge the connection starts at.
Definition: NBEdgeCont.h:557
std::map< std::string, NBEdge * >::const_iterator begin() const
Returns the pointer to the begin of the stored edges.
Definition: NBEdgeCont.h:190
PositionVector myPrunningBoundary
Boundary within which an edge must be located in order to be kept.
Definition: NBEdgeCont.h:619
std::set< std::string > myTypes2Keep
Set of edges types which shall be kept.
Definition: NBEdgeCont.h:613
SUMOReal myEdgesMinSpeed
The minimum speed an edge may have in order to be kept (default: -1)
Definition: NBEdgeCont.h:595
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
Definition: NBEdgeCont.cpp:258
bool wasRemoved(std::string id) const
Returns whether the edge with the id was deleted explicitly.
Definition: NBEdgeCont.h:478
void appendTurnarounds(bool noTLSControlled)
Appends turnarounds to all edges stored in the container.
Definition: NBEdgeCont.cpp:602
bool isLeftHanded() const
Returns whether the built edges are left-handed.
Definition: NBEdgeCont.h:463
std::vector< NBEdge * > EdgeVector
Definition: NBCont.h:41
int toLane
The number of the lane the connection ends at.
Definition: NBEdgeCont.h:563
A storage for options typed value containers)
Definition: OptionsCont.h:108
void recheckLanes(const bool buildCrossingsAndWalkingAreas)
Rechecks whether all lanes have a successor for each of the stored edges.
Definition: NBEdgeCont.cpp:594
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
Definition: NBEdgeCont.cpp:373
NBEdgeCont & operator=(const NBEdgeCont &s)
invalidated assignment operator
A structure representing a connection between two lanes.
Definition: NBEdgeCont.h:544
void computeEdgeShapes()
Computes the shapes of all edges stored in the container.
Definition: NBEdgeCont.cpp:618
Represents a single node (junction) during network building.
Definition: NBNode.h:75
NBTypeCont & myTypeCont
The network builder; used to obtain type information.
Definition: NBEdgeCont.h:539
std::string to
The id of the edge the connection ends at.
Definition: NBEdgeCont.h:561
void recheckLaneSpread()
Rechecks whether the lane spread is proper.
Definition: NBEdgeCont.cpp:721
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:71
#define SUMOReal
Definition: config.h:218
bool wasIgnored(std::string id) const
Returns whether the edge with the id was ignored during parsing.
Definition: NBEdgeCont.h:471
std::set< std::string > myTypes2Remove
Set of edges types which shall be removed.
Definition: NBEdgeCont.h:616
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:64
int fromLane
The number of the lane the connection starts at.
Definition: NBEdgeCont.h:559
std::set< std::string > myIgnoredEdges
The ids of ignored edges.
Definition: NBEdgeCont.h:582
EdgeVector getGeneratedFrom(const std::string &id) const
Returns the edges which have been built by splitting the edge of the given id.
Definition: NBEdgeCont.cpp:778
void addRoundabout(const EdgeSet &roundabout)
add user specified roundabout
Definition: NBEdgeCont.cpp:920
void addPostProcessConnection(const std::string &from, int fromLane, const std::string &to, int toLane, bool mayDefinitelyPass)
Adds a connection which could not be set during loading.
Definition: NBEdgeCont.cpp:742
bool ignoreFilterMatch(NBEdge *edge)
Returns true if this edge matches one of the removal criteria.
Definition: NBEdgeCont.cpp:194
unsigned int size() const
Returns the number of edges.
Definition: NBEdgeCont.h:282
A storage for available types of edges.
Definition: NBTypeCont.h:56
std::set< std::string > myEdges2Remove
Set of ids of edges which shall explicitly be removed.
Definition: NBEdgeCont.h:604