Eclipse SUMO - Simulation of Urban MObility
NBContHelper.h
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 /****************************************************************************/
17 // Some methods for traversing lists of edges
18 /****************************************************************************/
19 #ifndef NBContHelper_h
20 #define NBContHelper_h
21 
22 
23 // ===========================================================================
24 // included modules
25 // ===========================================================================
26 #include <config.h>
27 
28 #include <vector>
29 #include <iostream>
30 #include <cmath>
31 #include <algorithm>
32 #include <cassert>
33 #include "NBHelpers.h"
34 #include "NBCont.h"
35 #include "NBEdge.h"
36 #include "NBNode.h"
37 #include <utils/common/StdDefs.h>
38 #include <utils/geom/GeomHelper.h>
39 
40 
41 // ===========================================================================
42 // class definitions
43 // ===========================================================================
49 class NBContHelper {
50 public:
53  static void nextCW(const EdgeVector& edges,
54  EdgeVector::const_iterator& from);
55 
58  static void nextCCW(const EdgeVector& edges,
59  EdgeVector::const_iterator& from);
60 
61  static double getMaxSpeed(const EdgeVector& edges);
62 
63  static double getMinSpeed(const EdgeVector& edges);
64 
66  static std::ostream& out(std::ostream& os, const std::vector<bool>& v);
67 
68 
78  public:
81 
82  public:
84  int operator()(NBEdge* e1, NBEdge* e2) const;
85 
86  private:
89  };
90 
91 
100  public:
103 
104  public:
106  int operator()(NBEdge* e1, NBEdge* e2) const;
107 
108  private:
111  };
112 
113 
119  public:
121  int operator()(NBEdge* e1, NBEdge* e2) const {
122  if (e1->getPriority() != e2->getPriority()) {
123  return e1->getPriority() > e2->getPriority();
124  }
125  if (e1->getSpeed() != e2->getSpeed()) {
126  return e1->getSpeed() > e2->getSpeed();
127  }
128  return e1->getNumLanes() > e2->getNumLanes();
129  }
130  };
131 
132  // ---------------------------
133 
142  public:
147  explicit edge_opposite_direction_sorter(const NBEdge* const e, const NBNode* const n, bool regardPriority) :
148  myNode(n),
149  myEdge(e),
150  myRegardPriority(regardPriority) {
151  myAngle = getEdgeAngleAt(e, n);
152  }
153 
159  int operator()(NBEdge* e1, NBEdge* e2) const {
160  if (!myRegardPriority || e1->getPriority() == e2->getPriority() || e1 == myEdge || e2 == myEdge) {
161  return getDiff(e1) > getDiff(e2);
162  } else {
163  return e1->getPriority() > e2->getPriority();
164  }
165  }
166 
167  protected:
172  double getDiff(const NBEdge* const e) const {
174  }
175 
182  double getEdgeAngleAt(const NBEdge* const e, const NBNode* const n) const {
183  if (e->getFromNode() == n) {
184  return e->getGeometry().angleAt2D(0);
185  } else {
186  return e->getGeometry()[-1].angleTo2D(e->getGeometry()[-2]);
187  }
188  }
189 
190  private:
191 
193  const NBNode* const myNode;
194 
196  const NBEdge* const myEdge;
197 
199  double myAngle;
200 
203 
204  private:
207 
208  };
209 
210  // ---------------------------
211 
219  public:
221  explicit edge_similar_direction_sorter(const NBEdge* const e)
222  : myAngle(e->getShapeEndAngle()) {}
223 
225  int operator()(const NBEdge* e1, const NBEdge* e2) const {
226  const double d1 = angleDiff(e1->getShapeStartAngle(), myAngle);
227  const double d2 = angleDiff(e2->getShapeStartAngle(), myAngle);
228  if (fabs(fabs(d1) - fabs(d2)) < NUMERICAL_EPS) {
229  if (fabs(d1 - d2) > NUMERICAL_EPS) {
230  return d1 < d2;
231  } else {
232  return e1->getNumericalID() < e2->getNumericalID();
233  }
234  }
235  return fabs(d1) < fabs(d2);
236  }
237 
238  private:
239  double angleDiff(const double angle1, const double angle2) const {
240  double d = angle2 - angle1;
241  while (d >= 180.) {
242  d -= 360.;
243  }
244  while (d < -180.) {
245  d += 360.;
246  }
247  return d;
248  }
249 
250 
251  private:
253  double myAngle;
254  };
255 
256 
261  public:
263  node_with_incoming_finder(const NBEdge* const e);
264 
265  bool operator()(const NBNode* const n) const;
266 
267  private:
268  const NBEdge* const myEdge;
269 
270  private:
273 
274  };
275 
276 
281  public:
283  node_with_outgoing_finder(const NBEdge* const e);
284 
285  bool operator()(const NBNode* const n) const;
286 
287  private:
288  const NBEdge* const myEdge;
289 
290  private:
293 
294  };
295 
296 
297 
298 
300  public:
303 
304  bool operator()(NBEdge* e) const;
305 
306  private:
308 
309  private:
312 
313  };
314 
315 
318  static NBEdge* findConnectingEdge(const EdgeVector& edges,
319  NBNode* from, NBNode* to);
320 
321 
323  static double maxSpeed(const EdgeVector& ev);
324 
332  public:
335 
337  int operator()(NBEdge* e1, NBEdge* e2) const {
338  std::pair<double, double> mm1 = getMinMaxRelAngles(e1);
339  std::pair<double, double> mm2 = getMinMaxRelAngles(e2);
340  if (mm1.first == mm2.first && mm1.second == mm2.second) {
341  // ok, let's simply sort them arbitrarily
342  return e1->getID() < e2->getID();
343  }
344 
345  assert(
346  (mm1.first <= mm2.first && mm1.second <= mm2.second)
347  ||
348  (mm1.first >= mm2.first && mm1.second >= mm2.second));
349  return (mm1.first >= mm2.first && mm1.second >= mm2.second);
350  }
351 
355  std::pair<double, double> getMinMaxRelAngles(NBEdge* e) const {
356  double min = 360;
357  double max = 360;
358  const EdgeVector& ev = e->getConnectedEdges();
359  for (EdgeVector::const_iterator i = ev.begin(); i != ev.end(); ++i) {
360  double angle = NBHelpers::normRelAngle(
361  e->getTotalAngle(), (*i)->getTotalAngle());
362  if (min == 360 || min > angle) {
363  min = angle;
364  }
365  if (max == 360 || max < angle) {
366  max = angle;
367  }
368  }
369  return std::pair<double, double>(min, max);
370  }
371  };
372 
373 
374  friend std::ostream& operator<<(std::ostream& os, const EdgeVector& ev);
375 
377  public:
380  : myReferenceEdge(edge) { }
381 
382  bool operator()(NBEdge* e) const {
385  }
386 
387  private:
389 
390  };
391 
397  public:
400 
401  public:
403  int operator()(const NBEdge* e1, const NBEdge* e2) const;
404 
405  private:
407  const NBNode* myNode;
408  };
409 
410 };
411 
412 
413 #endif
414 
415 /****************************************************************************/
416 
NBContHelper::edge_opposite_direction_sorter::operator()
int operator()(NBEdge *e1, NBEdge *e2) const
Comparing operation.
Definition: NBContHelper.h:159
NBContHelper::node_with_incoming_finder::operator=
node_with_incoming_finder & operator=(const node_with_incoming_finder &s)
invalidated assignment operator
NBContHelper::edge_opposite_direction_sorter::edge_opposite_direction_sorter
edge_opposite_direction_sorter(const NBEdge *const e, const NBNode *const n, bool regardPriority)
Constructor.
Definition: NBContHelper.h:147
NBContHelper::edge_by_angle_to_nodeShapeCentroid_sorter::edge_by_angle_to_nodeShapeCentroid_sorter
edge_by_angle_to_nodeShapeCentroid_sorter(const NBNode *n)
constructor
Definition: NBContHelper.h:399
NBContHelper::opposite_finder
Definition: NBContHelper.h:376
GeomHelper::angleDiff
static double angleDiff(const double angle1, const double angle2)
Returns the difference of the second angle to the first angle in radiants.
Definition: GeomHelper.cpp:181
NBContHelper::edge_similar_direction_sorter
Definition: NBContHelper.h:218
NUMERICAL_EPS
#define NUMERICAL_EPS
Definition: config.h:145
NBEdge::getNumericalID
int getNumericalID() const
Returns the index (numeric id) of the edge.
Definition: NBEdge.h:1350
NBContHelper::node_with_incoming_finder::operator()
bool operator()(const NBNode *const n) const
Definition: NBContHelper.cpp:102
NBContHelper::relative_incoming_edge_sorter::relative_incoming_edge_sorter
relative_incoming_edge_sorter(NBEdge *e)
constructor
Definition: NBContHelper.h:102
NBContHelper::node_with_outgoing_finder
Definition: NBContHelper.h:280
EdgeVector
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition: NBCont.h:35
NBEdge::isTurningDirectionAt
bool isTurningDirectionAt(const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
Definition: NBEdge.cpp:2783
NBHelpers::normRelAngle
static double normRelAngle(double angle1, double angle2)
ensure that reverse relAngles (>=179.999) always count as turnarounds (-180)
Definition: NBHelpers.cpp:60
NBContHelper::same_connection_edge_sorter::same_connection_edge_sorter
same_connection_edge_sorter()
constructor
Definition: NBContHelper.h:334
NBEdge::getPriority
int getPriority() const
Returns the priority of the edge.
Definition: NBEdge.h:472
NBContHelper::opposite_finder::operator()
bool operator()(NBEdge *e) const
Definition: NBContHelper.h:382
NBContHelper::relative_incoming_edge_sorter::myEdge
NBEdge * myEdge
the edge to compute the relative angle of
Definition: NBContHelper.h:110
NBEdge::getShapeStartAngle
double getShapeStartAngle() const
Returns the angle at the start of the edge.
Definition: NBEdge.cpp:2013
NBContHelper::relative_incoming_edge_sorter
Definition: NBContHelper.h:99
NBContHelper::edge_opposite_direction_sorter::myNode
const NBNode *const myNode
The related node.
Definition: NBContHelper.h:193
NBContHelper::node_with_outgoing_finder::operator()
bool operator()(const NBNode *const n) const
Definition: NBContHelper.cpp:117
NBContHelper::relative_outgoing_edge_sorter::operator()
int operator()(NBEdge *e1, NBEdge *e2) const
comparing operation
Definition: NBContHelper.cpp:140
PositionVector::angleAt2D
double angleAt2D(int pos) const
get angle in certain position of position vector
Definition: PositionVector.cpp:1204
NBContHelper::edge_by_priority_sorter
Definition: NBContHelper.h:118
NBEdge
The representation of a single edge during network building.
Definition: NBEdge.h:86
NBContHelper::findConnectingEdge
static NBEdge * findConnectingEdge(const EdgeVector &edges, NBNode *from, NBNode *to)
Definition: NBContHelper.cpp:68
NBContHelper::edge_opposite_direction_sorter::getDiff
double getDiff(const NBEdge *const e) const
Computes the angle difference between the related and the given edge.
Definition: NBContHelper.h:172
NBContHelper::relative_outgoing_edge_sorter::myEdge
NBEdge * myEdge
the edge to compute the relative angle of
Definition: NBContHelper.h:88
NBContHelper::same_connection_edge_sorter
Definition: NBContHelper.h:331
NBContHelper::getMaxSpeed
static double getMaxSpeed(const EdgeVector &edges)
Definition: NBContHelper.cpp:211
NBEdge::getGeometry
const PositionVector & getGeometry() const
Returns the geometry of the edge.
Definition: NBEdge.h:680
NBContHelper
Definition: NBContHelper.h:49
NBContHelper::getMinSpeed
static double getMinSpeed(const EdgeVector &edges)
Definition: NBContHelper.cpp:226
NBContHelper::node_with_outgoing_finder::operator=
node_with_outgoing_finder & operator=(const node_with_outgoing_finder &s)
invalidated assignment operator
NBContHelper::edge_with_destination_finder::operator()
bool operator()(NBEdge *e) const
Definition: NBContHelper.cpp:131
NBContHelper::edge_opposite_direction_sorter::operator=
edge_opposite_direction_sorter & operator=(const edge_opposite_direction_sorter &s)
Invalidated assignment operator.
NBContHelper::edge_by_angle_to_nodeShapeCentroid_sorter::myNode
const NBNode * myNode
the edge to compute the relative angle of
Definition: NBContHelper.h:407
NBEdge::getNumLanes
int getNumLanes() const
Returns the number of lanes.
Definition: NBEdge.h:465
NBContHelper::nextCCW
static void nextCCW(const EdgeVector &edges, EdgeVector::const_iterator &from)
Definition: NBContHelper.cpp:49
NBContHelper::edge_similar_direction_sorter::myAngle
double myAngle
the angle to find the edge with the opposite direction
Definition: NBContHelper.h:253
NBContHelper::node_with_incoming_finder::myEdge
const NBEdge *const myEdge
Definition: NBContHelper.h:268
NBContHelper::maxSpeed
static double maxSpeed(const EdgeVector &ev)
Definition: NBContHelper.cpp:81
NBContHelper::relative_incoming_edge_sorter::operator()
int operator()(NBEdge *e1, NBEdge *e2) const
comparing operation
Definition: NBContHelper.cpp:171
NBHelpers.h
NBContHelper::opposite_finder::opposite_finder
opposite_finder(NBEdge *edge)
constructor
Definition: NBContHelper.h:379
NBContHelper::edge_by_angle_to_nodeShapeCentroid_sorter::operator()
int operator()(const NBEdge *e1, const NBEdge *e2) const
comparing operation
Definition: NBContHelper.cpp:241
NBContHelper::opposite_finder::myReferenceEdge
NBEdge * myReferenceEdge
Definition: NBContHelper.h:388
NBContHelper::edge_by_angle_to_nodeShapeCentroid_sorter
Definition: NBContHelper.h:396
NBContHelper::same_connection_edge_sorter::getMinMaxRelAngles
std::pair< double, double > getMinMaxRelAngles(NBEdge *e) const
Definition: NBContHelper.h:355
NBContHelper::node_with_outgoing_finder::node_with_outgoing_finder
node_with_outgoing_finder(const NBEdge *const e)
constructor
Definition: NBContHelper.cpp:112
NBContHelper::relative_outgoing_edge_sorter
Definition: NBContHelper.h:77
NBContHelper::node_with_incoming_finder::node_with_incoming_finder
node_with_incoming_finder(const NBEdge *const e)
constructor
Definition: NBContHelper.cpp:97
NBContHelper::edge_opposite_direction_sorter::myEdge
const NBEdge *const myEdge
the reference edge
Definition: NBContHelper.h:196
NBEdge::getSpeed
double getSpeed() const
Returns the speed allowed on this edge.
Definition: NBEdge.h:559
NBContHelper::edge_with_destination_finder::edge_with_destination_finder
edge_with_destination_finder(NBNode *dest)
constructor
Definition: NBContHelper.cpp:126
NBContHelper::edge_similar_direction_sorter::edge_similar_direction_sorter
edge_similar_direction_sorter(const NBEdge *const e)
constructor
Definition: NBContHelper.h:221
NBContHelper::edge_similar_direction_sorter::operator()
int operator()(const NBEdge *e1, const NBEdge *e2) const
comparing operation
Definition: NBContHelper.h:225
NBContHelper::operator<<
friend std::ostream & operator<<(std::ostream &os, const EdgeVector &ev)
Definition: NBContHelper.cpp:199
NBContHelper::edge_opposite_direction_sorter::myRegardPriority
bool myRegardPriority
Whether edge priority may override closer angles.
Definition: NBContHelper.h:202
NBContHelper::edge_opposite_direction_sorter
Class to sort edges by their angle in relation to the given edge.
Definition: NBContHelper.h:141
NBContHelper::nextCW
static void nextCW(const EdgeVector &edges, EdgeVector::const_iterator &from)
Definition: NBContHelper.cpp:40
config.h
NBEdge::getConnectedEdges
EdgeVector getConnectedEdges() const
Returns the list of outgoing edges unsorted.
Definition: NBEdge.cpp:1226
GeomHelper.h
NBContHelper::edge_with_destination_finder::myDestinationNode
NBNode * myDestinationNode
Definition: NBContHelper.h:307
StdDefs.h
NBContHelper::node_with_outgoing_finder::myEdge
const NBEdge *const myEdge
Definition: NBContHelper.h:288
NBNode
Represents a single node (junction) during network building.
Definition: NBNode.h:68
NBContHelper::out
static std::ostream & out(std::ostream &os, const std::vector< bool > &v)
Definition: NBContHelper.cpp:59
NBNode.h
NBContHelper::node_with_incoming_finder
Definition: NBContHelper.h:260
NBEdge::getFromNode
NBNode * getFromNode() const
Returns the origin node of the edge.
Definition: NBEdge.h:479
NBEdge::getTotalAngle
double getTotalAngle() const
Returns the angle at the start of the edge.
Definition: NBEdge.h:526
NBContHelper::edge_by_priority_sorter::operator()
int operator()(NBEdge *e1, NBEdge *e2) const
comparing operator
Definition: NBContHelper.h:121
NBContHelper::edge_with_destination_finder
Definition: NBContHelper.h:299
NBContHelper::relative_outgoing_edge_sorter::relative_outgoing_edge_sorter
relative_outgoing_edge_sorter(NBEdge *e)
constructor
Definition: NBContHelper.h:80
NBContHelper::edge_opposite_direction_sorter::getEdgeAngleAt
double getEdgeAngleAt(const NBEdge *const e, const NBNode *const n) const
Returns the given edge's angle at the given node.
Definition: NBContHelper.h:182
NBContHelper::edge_opposite_direction_sorter::myAngle
double myAngle
The angle of the related edge at the given node.
Definition: NBContHelper.h:199
NBCont.h
NBEdge.h
NBContHelper::edge_with_destination_finder::operator=
edge_with_destination_finder & operator=(const edge_with_destination_finder &s)
invalidated assignment operator
NBContHelper::same_connection_edge_sorter::operator()
int operator()(NBEdge *e1, NBEdge *e2) const
comparing operation
Definition: NBContHelper.h:337
NBContHelper::edge_similar_direction_sorter::angleDiff
double angleDiff(const double angle1, const double angle2) const
Definition: NBContHelper.h:239
NBEdge::getID
const std::string & getID() const
Definition: NBEdge.h:1364