Eclipse SUMO - Simulation of Urban MObility
NBContHelper.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
16 // Some methods for traversing lists of edges
17 /****************************************************************************/
18 
19 
20 // ===========================================================================
21 // included modules
22 // ===========================================================================
23 #include <config.h>
24 
25 #include <vector>
26 #include <map>
27 #include <cassert>
28 #include "NBContHelper.h"
29 #include <utils/geom/GeomHelper.h>
30 
31 
32 // ===========================================================================
33 // method definitions
34 // ===========================================================================
35 /* -------------------------------------------------------------------------
36  * utility methods
37  * ----------------------------------------------------------------------- */
38 void
39 NBContHelper::nextCW(const EdgeVector& edges, EdgeVector::const_iterator& from) {
40  from++;
41  if (from == edges.end()) {
42  from = edges.begin();
43  }
44 }
45 
46 
47 void
48 NBContHelper::nextCCW(const EdgeVector& edges, EdgeVector::const_iterator& from) {
49  if (from == edges.begin()) {
50  from = edges.end() - 1;
51  } else {
52  --from;
53  }
54 }
55 
56 
57 std::ostream&
58 NBContHelper::out(std::ostream& os, const std::vector<bool>& v) {
59  for (std::vector<bool>::const_iterator i = v.begin(); i != v.end(); i++) {
60  os << *i;
61  }
62  return os;
63 }
64 
65 
66 NBEdge*
68  NBNode* from, NBNode* to) {
69  for (EdgeVector::const_iterator i = edges.begin(); i != edges.end(); i++) {
70  if ((*i)->getToNode() == to && (*i)->getFromNode() == from) {
71  return *i;
72  }
73  }
74  return nullptr;
75 }
76 
77 
78 
79 double
81  assert(ev.size() > 0);
82  double max = (*(ev.begin()))->getSpeed();
83  for (EdgeVector::const_iterator i = ev.begin() + 1; i != ev.end(); i++) {
84  max =
85  max > (*i)->getSpeed()
86  ? max : (*i)->getSpeed();
87  }
88  return max;
89 }
90 
91 
92 
93 /* -------------------------------------------------------------------------
94  * methods from node_with_incoming_finder
95  * ----------------------------------------------------------------------- */
97  : myEdge(e) {}
98 
99 
100 bool
102  const EdgeVector& incoming = n->getIncomingEdges();
103  return std::find(incoming.begin(), incoming.end(), myEdge) != incoming.end();
104 }
105 
106 
107 
108 /* -------------------------------------------------------------------------
109  * methods from node_with_outgoing_finder
110  * ----------------------------------------------------------------------- */
112  : myEdge(e) {}
113 
114 
115 bool
117  const EdgeVector& outgoing = n->getOutgoingEdges();
118  return std::find(outgoing.begin(), outgoing.end(), myEdge) != outgoing.end();
119 }
120 
121 
122 /* -------------------------------------------------------------------------
123  * methods from edge_with_destination_finder
124  * ----------------------------------------------------------------------- */
126  : myDestinationNode(dest) {}
127 
128 
129 bool
131  return e->getToNode() == myDestinationNode;
132 }
133 
134 
135 /* -------------------------------------------------------------------------
136  * methods from relative_outgoing_edge_sorter
137  * ----------------------------------------------------------------------- */
138 int
140  if (e1 == nullptr || e2 == nullptr) {
141  return -1;
142  }
143  double relAngle1 = NBHelpers::normRelAngle(
144  myEdge->getEndAngle(), e1->getStartAngle());
145  double relAngle2 = NBHelpers::normRelAngle(
146  myEdge->getEndAngle(), e2->getStartAngle());
147 
148  double lookAhead = 2 * NBEdge::ANGLE_LOOKAHEAD;
149  while (fabs(relAngle1 - relAngle2) < 3.0) {
150  // look at further geometry segments to resolve ambiguity
151  const Position referencePos1 = e1->getGeometry().positionAtOffset2D(lookAhead);
152  const Position referencePos2 = e2->getGeometry().positionAtOffset2D(lookAhead);
153  relAngle1 = NBHelpers::normRelAngle(myEdge->getEndAngle(), GeomHelper::legacyDegree(
154  e1->getFromNode()->getPosition().angleTo2D(referencePos1), true));
155  relAngle2 = NBHelpers::normRelAngle(myEdge->getEndAngle(), GeomHelper::legacyDegree(
156  e2->getFromNode()->getPosition().angleTo2D(referencePos2), true));
157  if (lookAhead > MAX2(e1->getLength(), e2->getLength())) {
158  break;
159  }
160  lookAhead *= 2;
161  }
162  return relAngle1 > relAngle2;
163 }
164 
165 
166 /* -------------------------------------------------------------------------
167  * methods from relative_incoming_edge_sorter
168  * ----------------------------------------------------------------------- */
169 int
171  if (e1 == nullptr || e2 == nullptr) {
172  return -1;
173  }
174  double relAngle1 = NBHelpers::normRelAngle(
175  myEdge->getStartAngle(), e1->getEndAngle());
176  double relAngle2 = NBHelpers::normRelAngle(
177  myEdge->getStartAngle(), e2->getEndAngle());
178 
179  double lookAhead = 2 * NBEdge::ANGLE_LOOKAHEAD;
180  while (fabs(relAngle1 - relAngle2) < 3.0) {
181  // look at further geometry segments to resolve ambiguity
182  const Position referencePos1 = e1->getGeometry().positionAtOffset2D(e1->getGeometry().length() - lookAhead);
183  const Position referencePos2 = e2->getGeometry().positionAtOffset2D(e2->getGeometry().length() - lookAhead);
184  relAngle1 = NBHelpers::normRelAngle(myEdge->getStartAngle(), GeomHelper::legacyDegree(
185  referencePos1.angleTo2D(e1->getToNode()->getPosition()), true));
186  relAngle2 = NBHelpers::normRelAngle(myEdge->getStartAngle(), GeomHelper::legacyDegree(
187  referencePos2.angleTo2D(e2->getToNode()->getPosition()), true));
188  if (lookAhead > MAX2(e1->getLength(), e2->getLength())) {
189  break;
190  }
191  lookAhead *= 2;
192  }
193  return relAngle1 > relAngle2;
194 }
195 
196 
197 std::ostream&
198 operator<<(std::ostream& os, const EdgeVector& ev) {
199  for (EdgeVector::const_iterator i = ev.begin(); i != ev.end(); i++) {
200  if (i != ev.begin()) {
201  os << ", ";
202  }
203  os << (*i)->getID();
204  }
205  return os;
206 }
207 
208 
209 double
211  if (edges.size() == 0) {
212  return -1;
213  }
214  double ret = (*(edges.begin()))->getSpeed();
215  for (EdgeVector::const_iterator i = edges.begin() + 1; i != edges.end(); i++) {
216  if ((*i)->getSpeed() > ret) {
217  ret = (*i)->getSpeed();
218  }
219  }
220  return ret;
221 }
222 
223 
224 double
226  if (edges.size() == 0) {
227  return -1;
228  }
229  double ret = (*(edges.begin()))->getSpeed();
230  for (EdgeVector::const_iterator i = edges.begin() + 1; i != edges.end(); i++) {
231  if ((*i)->getSpeed() < ret) {
232  ret = (*i)->getSpeed();
233  }
234  }
235  return ret;
236 }
237 
238 
239 int
241  assert(e1->getFromNode() == myNode || e1->getToNode() == myNode);
242  assert(e2->getFromNode() == myNode || e2->getToNode() == myNode);
243  const double angle1 = e1->getAngleAtNodeToCenter(myNode);
244  const double angle2 = e2->getAngleAtNodeToCenter(myNode);
245  const double absDiff = fabs(angle1 - angle2);
246 
247  // cannot trust the angle difference hence a heuristic:
248  if (absDiff < 2 || absDiff > (360 - 2)) {
249  const bool sameDir = ((e1->getFromNode() == myNode && e2->getFromNode() == myNode)
250  || (e1->getToNode() == myNode && e2->getToNode() == myNode));
251  if (sameDir) {
252  // put edges that allow pedestrians on the 'outside', but be aware if both allow / disallow
253  const bool e1Peds = (e1->getPermissions() & SVC_PEDESTRIAN) != 0;
254  const bool e2Peds = (e2->getPermissions() & SVC_PEDESTRIAN) != 0;
255  if (e1->getToNode() == myNode) {
256  if (e1Peds && !e2Peds) {
257  return true;
258  } else if (!e1Peds && e2Peds) {
259  return false;
260  }
261  } else {
262  if (!e1Peds && e2Peds) {
263  return true;
264  } else if (e1Peds && !e2Peds) {
265  return false;
266  }
267  }
268  // break ties to ensure strictly weak ordering
269  return e1->getID() < e2->getID();
270  } else {
271  // sort incoming before outgoing, no need to break ties here
272  return e1->getToNode() == myNode;
273  }
274  }
275  return angle1 < angle2;
276 }
277 
278 /****************************************************************************/
279 
SVC_PEDESTRIAN
@ SVC_PEDESTRIAN
pedestrian
Definition: SUMOVehicleClass.h:156
NBContHelper::node_with_incoming_finder::operator()
bool operator()(const NBNode *const n) const
Definition: NBContHelper.cpp:101
EdgeVector
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition: NBCont.h:34
NBNode::getOutgoingEdges
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
Definition: NBNode.h:260
GeomHelper::legacyDegree
static double legacyDegree(const double angle, const bool positive=false)
Definition: GeomHelper.cpp:216
NBHelpers::normRelAngle
static double normRelAngle(double angle1, double angle2)
ensure that reverse relAngles (>=179.999) always count as turnarounds (-180)
Definition: NBHelpers.cpp:59
PositionVector::length
double length() const
Returns the length.
Definition: PositionVector.cpp:484
NBEdge::getPermissions
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
Definition: NBEdge.cpp:3404
NBContHelper::node_with_outgoing_finder::operator()
bool operator()(const NBNode *const n) const
Definition: NBContHelper.cpp:116
NBContHelper::relative_outgoing_edge_sorter::operator()
int operator()(NBEdge *e1, NBEdge *e2) const
comparing operation
Definition: NBContHelper.cpp:139
NBEdge
The representation of a single edge during network building.
Definition: NBEdge.h:91
NBContHelper::findConnectingEdge
static NBEdge * findConnectingEdge(const EdgeVector &edges, NBNode *from, NBNode *to)
Definition: NBContHelper.cpp:67
MAX2
T MAX2(T a, T b)
Definition: StdDefs.h:79
NBNode::getPosition
const Position & getPosition() const
Definition: NBNode.h:247
NBEdge::getToNode
NBNode * getToNode() const
Returns the destination node of the edge.
Definition: NBEdge.h:498
NBContHelper::getMaxSpeed
static double getMaxSpeed(const EdgeVector &edges)
Definition: NBContHelper.cpp:210
NBEdge::getGeometry
const PositionVector & getGeometry() const
Returns the geometry of the edge.
Definition: NBEdge.h:692
NBContHelper::getMinSpeed
static double getMinSpeed(const EdgeVector &edges)
Definition: NBContHelper.cpp:225
NBContHelper::edge_with_destination_finder::operator()
bool operator()(NBEdge *e) const
Definition: NBContHelper.cpp:130
NBContHelper::nextCCW
static void nextCCW(const EdgeVector &edges, EdgeVector::const_iterator &from)
Definition: NBContHelper.cpp:48
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:38
NBEdge::ANGLE_LOOKAHEAD
static const double ANGLE_LOOKAHEAD
the distance at which to take the default angle
Definition: NBEdge.h:336
NBContHelper::maxSpeed
static double maxSpeed(const EdgeVector &ev)
Definition: NBContHelper.cpp:80
NBContHelper::relative_incoming_edge_sorter::operator()
int operator()(NBEdge *e1, NBEdge *e2) const
comparing operation
Definition: NBContHelper.cpp:170
NBContHelper.h
NBEdge::getAngleAtNodeToCenter
double getAngleAtNodeToCenter(const NBNode *const node) const
Returns the angle of from the node shape center to where the edge meets the node shape.
Definition: NBEdge.cpp:1848
NBContHelper::edge_by_angle_to_nodeShapeCentroid_sorter::operator()
int operator()(const NBEdge *e1, const NBEdge *e2) const
comparing operation
Definition: NBContHelper.cpp:240
NBEdge::getEndAngle
double getEndAngle() const
Returns the angle at the end of the edge (relative to the node shape center) The angle is computed in...
Definition: NBEdge.h:516
NBContHelper::node_with_outgoing_finder::node_with_outgoing_finder
node_with_outgoing_finder(const NBEdge *const e)
constructor
Definition: NBContHelper.cpp:111
Position::angleTo2D
double angleTo2D(const Position &other) const
returns the angle in the plane of the vector pointing from here to the other position
Definition: Position.h:253
NBEdge::getLength
double getLength() const
Returns the computed length of the edge.
Definition: NBEdge.h:545
NBContHelper::node_with_incoming_finder::node_with_incoming_finder
node_with_incoming_finder(const NBEdge *const e)
constructor
Definition: NBContHelper.cpp:96
PositionVector::positionAtOffset2D
Position positionAtOffset2D(double pos, double lateralOffset=0) const
Returns the position at the given length.
Definition: PositionVector.cpp:273
NBContHelper::edge_with_destination_finder::edge_with_destination_finder
edge_with_destination_finder(NBNode *dest)
constructor
Definition: NBContHelper.cpp:125
NBEdge::getStartAngle
double getStartAngle() const
Returns the angle at the start of the edge (relative to the node shape center) The angle is computed ...
Definition: NBEdge.h:507
NBContHelper::operator<<
friend std::ostream & operator<<(std::ostream &os, const EdgeVector &ev)
Definition: NBContHelper.cpp:198
NBNode::getIncomingEdges
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
Definition: NBNode.h:255
NBContHelper::nextCW
static void nextCW(const EdgeVector &edges, EdgeVector::const_iterator &from)
Definition: NBContHelper.cpp:39
config.h
GeomHelper.h
NBNode
Represents a single node (junction) during network building.
Definition: NBNode.h:67
NBContHelper::out
static std::ostream & out(std::ostream &os, const std::vector< bool > &v)
Definition: NBContHelper.cpp:58
NBEdge::getFromNode
NBNode * getFromNode() const
Returns the origin node of the edge.
Definition: NBEdge.h:491
NBEdge::getID
const std::string & getID() const
Definition: NBEdge.h:1380