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 /****************************************************************************/
16 // Some methods for traversing lists of edges
17 /****************************************************************************/
18 #ifndef NBContHelper_h
19 #define NBContHelper_h
20 
21 
22 // ===========================================================================
23 // included modules
24 // ===========================================================================
25 #include <config.h>
26 
27 #include <vector>
28 #include <iostream>
29 #include <cmath>
30 #include <algorithm>
31 #include <cassert>
32 #include "NBHelpers.h"
33 #include "NBCont.h"
34 #include "NBEdge.h"
35 #include "NBNode.h"
36 #include <utils/common/StdDefs.h>
37 #include <utils/geom/GeomHelper.h>
38 
39 
40 // ===========================================================================
41 // class definitions
42 // ===========================================================================
48 class NBContHelper {
49 public:
52  static void nextCW(const EdgeVector& edges,
53  EdgeVector::const_iterator& from);
54 
57  static void nextCCW(const EdgeVector& edges,
58  EdgeVector::const_iterator& from);
59 
60  static double getMaxSpeed(const EdgeVector& edges);
61 
62  static double getMinSpeed(const EdgeVector& edges);
63 
65  static std::ostream& out(std::ostream& os, const std::vector<bool>& v);
66 
67 
77  public:
80 
81  public:
83  int operator()(NBEdge* e1, NBEdge* e2) const;
84 
85  private:
88  };
89 
90 
99  public:
102 
103  public:
105  int operator()(NBEdge* e1, NBEdge* e2) const;
106 
107  private:
110  };
111 
112 
118  public:
120  int operator()(NBEdge* e1, NBEdge* e2) const {
121  if (e1->getPriority() != e2->getPriority()) {
122  return e1->getPriority() > e2->getPriority();
123  }
124  if (e1->getSpeed() != e2->getSpeed()) {
125  return e1->getSpeed() > e2->getSpeed();
126  }
127  return e1->getNumLanes() > e2->getNumLanes();
128  }
129  };
130 
131  // ---------------------------
132 
141  public:
146  explicit edge_opposite_direction_sorter(const NBEdge* const e, const NBNode* const n, bool regardPriority) :
147  myNode(n),
148  myEdge(e),
149  myRegardPriority(regardPriority) {
150  myAngle = getEdgeAngleAt(e, n);
151  }
152 
158  int operator()(NBEdge* e1, NBEdge* e2) const {
159  if (!myRegardPriority || e1->getPriority() == e2->getPriority() || e1 == myEdge || e2 == myEdge) {
160  return getDiff(e1) > getDiff(e2);
161  } else {
162  return e1->getPriority() > e2->getPriority();
163  }
164  }
165 
166  protected:
171  double getDiff(const NBEdge* const e) const {
173  }
174 
181  double getEdgeAngleAt(const NBEdge* const e, const NBNode* const n) const {
182  if (e->getFromNode() == n) {
183  return e->getGeometry().angleAt2D(0);
184  } else {
185  return e->getGeometry()[-1].angleTo2D(e->getGeometry()[-2]);
186  }
187  }
188 
189  private:
190 
192  const NBNode* const myNode;
193 
195  const NBEdge* const myEdge;
196 
198  double myAngle;
199 
202 
203  private:
206 
207  };
208 
209  // ---------------------------
210 
218  public:
220  explicit edge_similar_direction_sorter(const NBEdge* const e)
221  : myAngle(e->getShapeEndAngle()) {}
222 
224  int operator()(const NBEdge* e1, const NBEdge* e2) const {
225  const double d1 = angleDiff(e1->getShapeStartAngle(), myAngle);
226  const double d2 = angleDiff(e2->getShapeStartAngle(), myAngle);
227  if (fabs(fabs(d1) - fabs(d2)) < NUMERICAL_EPS) {
228  if (fabs(d1 - d2) > NUMERICAL_EPS) {
229  return d1 < d2;
230  } else {
231  return e1->getNumericalID() < e2->getNumericalID();
232  }
233  }
234  return fabs(d1) < fabs(d2);
235  }
236 
237  private:
238  double angleDiff(const double angle1, const double angle2) const {
239  double d = angle2 - angle1;
240  while (d >= 180.) {
241  d -= 360.;
242  }
243  while (d < -180.) {
244  d += 360.;
245  }
246  return d;
247  }
248 
249 
250  private:
252  double myAngle;
253  };
254 
255 
260  public:
262  node_with_incoming_finder(const NBEdge* const e);
263 
264  bool operator()(const NBNode* const n) const;
265 
266  private:
267  const NBEdge* const myEdge;
268 
269  private:
272 
273  };
274 
275 
280  public:
282  node_with_outgoing_finder(const NBEdge* const e);
283 
284  bool operator()(const NBNode* const n) const;
285 
286  private:
287  const NBEdge* const myEdge;
288 
289  private:
292 
293  };
294 
295 
296 
297 
299  public:
302 
303  bool operator()(NBEdge* e) const;
304 
305  private:
307 
308  private:
311 
312  };
313 
314 
317  static NBEdge* findConnectingEdge(const EdgeVector& edges,
318  NBNode* from, NBNode* to);
319 
320 
322  static double maxSpeed(const EdgeVector& ev);
323 
331  public:
334 
336  int operator()(NBEdge* e1, NBEdge* e2) const {
337  std::pair<double, double> mm1 = getMinMaxRelAngles(e1);
338  std::pair<double, double> mm2 = getMinMaxRelAngles(e2);
339  if (mm1.first == mm2.first && mm1.second == mm2.second) {
340  // ok, let's simply sort them arbitrarily
341  return e1->getID() < e2->getID();
342  }
343 
344  assert(
345  (mm1.first <= mm2.first && mm1.second <= mm2.second)
346  ||
347  (mm1.first >= mm2.first && mm1.second >= mm2.second));
348  return (mm1.first >= mm2.first && mm1.second >= mm2.second);
349  }
350 
354  std::pair<double, double> getMinMaxRelAngles(NBEdge* e) const {
355  double min = 360;
356  double max = 360;
357  const EdgeVector& ev = e->getConnectedEdges();
358  for (EdgeVector::const_iterator i = ev.begin(); i != ev.end(); ++i) {
359  double angle = NBHelpers::normRelAngle(
360  e->getTotalAngle(), (*i)->getTotalAngle());
361  if (min == 360 || min > angle) {
362  min = angle;
363  }
364  if (max == 360 || max < angle) {
365  max = angle;
366  }
367  }
368  return std::pair<double, double>(min, max);
369  }
370  };
371 
372 
373  friend std::ostream& operator<<(std::ostream& os, const EdgeVector& ev);
374 
376  public:
379  : myReferenceEdge(edge) { }
380 
381  bool operator()(NBEdge* e) const {
384  }
385 
386  private:
388 
389  };
390 
396  public:
399 
400  public:
402  int operator()(const NBEdge* e1, const NBEdge* e2) const;
403 
404  private:
406  const NBNode* myNode;
407  };
408 
409 };
410 
411 
412 #endif
413 
414 /****************************************************************************/
415 
NBContHelper::edge_opposite_direction_sorter::operator()
int operator()(NBEdge *e1, NBEdge *e2) const
Comparing operation.
Definition: NBContHelper.h:158
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:146
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:398
NBContHelper::opposite_finder
Definition: NBContHelper.h:375
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:180
NBContHelper::edge_similar_direction_sorter
Definition: NBContHelper.h:217
NUMERICAL_EPS
#define NUMERICAL_EPS
Definition: config.h:148
NBEdge::getNumericalID
int getNumericalID() const
Returns the index (numeric id) of the edge.
Definition: NBEdge.h:1366
NBContHelper::node_with_incoming_finder::operator()
bool operator()(const NBNode *const n) const
Definition: NBContHelper.cpp:101
NBContHelper::relative_incoming_edge_sorter::relative_incoming_edge_sorter
relative_incoming_edge_sorter(NBEdge *e)
constructor
Definition: NBContHelper.h:101
NBContHelper::node_with_outgoing_finder
Definition: NBContHelper.h:279
EdgeVector
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition: NBCont.h:34
NBEdge::isTurningDirectionAt
bool isTurningDirectionAt(const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
Definition: NBEdge.cpp:2756
NBHelpers::normRelAngle
static double normRelAngle(double angle1, double angle2)
ensure that reverse relAngles (>=179.999) always count as turnarounds (-180)
Definition: NBHelpers.cpp:59
NBContHelper::same_connection_edge_sorter::same_connection_edge_sorter
same_connection_edge_sorter()
constructor
Definition: NBContHelper.h:333
NBEdge::getPriority
int getPriority() const
Returns the priority of the edge.
Definition: NBEdge.h:484
NBContHelper::opposite_finder::operator()
bool operator()(NBEdge *e) const
Definition: NBContHelper.h:381
NBContHelper::relative_incoming_edge_sorter::myEdge
NBEdge * myEdge
the edge to compute the relative angle of
Definition: NBContHelper.h:109
NBEdge::getShapeStartAngle
double getShapeStartAngle() const
Returns the angle at the start of the edge.
Definition: NBEdge.cpp:1986
NBContHelper::relative_incoming_edge_sorter
Definition: NBContHelper.h:98
NBContHelper::edge_opposite_direction_sorter::myNode
const NBNode *const myNode
The related node.
Definition: NBContHelper.h:192
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
PositionVector::angleAt2D
double angleAt2D(int pos) const
get angle in certain position of position vector
Definition: PositionVector.cpp:1221
NBContHelper::edge_by_priority_sorter
Definition: NBContHelper.h:117
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
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:171
NBContHelper::relative_outgoing_edge_sorter::myEdge
NBEdge * myEdge
the edge to compute the relative angle of
Definition: NBContHelper.h:87
NBContHelper::same_connection_edge_sorter
Definition: NBContHelper.h:330
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
Definition: NBContHelper.h:48
NBContHelper::getMinSpeed
static double getMinSpeed(const EdgeVector &edges)
Definition: NBContHelper.cpp:225
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:130
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:406
NBEdge::getNumLanes
int getNumLanes() const
Returns the number of lanes.
Definition: NBEdge.h:477
NBContHelper::nextCCW
static void nextCCW(const EdgeVector &edges, EdgeVector::const_iterator &from)
Definition: NBContHelper.cpp:48
NBContHelper::edge_similar_direction_sorter::myAngle
double myAngle
the angle to find the edge with the opposite direction
Definition: NBContHelper.h:252
NBContHelper::node_with_incoming_finder::myEdge
const NBEdge *const myEdge
Definition: NBContHelper.h:267
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
NBHelpers.h
NBContHelper::opposite_finder::opposite_finder
opposite_finder(NBEdge *edge)
constructor
Definition: NBContHelper.h:378
NBContHelper::edge_by_angle_to_nodeShapeCentroid_sorter::operator()
int operator()(const NBEdge *e1, const NBEdge *e2) const
comparing operation
Definition: NBContHelper.cpp:240
NBContHelper::opposite_finder::myReferenceEdge
NBEdge * myReferenceEdge
Definition: NBContHelper.h:387
NBContHelper::edge_by_angle_to_nodeShapeCentroid_sorter
Definition: NBContHelper.h:395
NBContHelper::same_connection_edge_sorter::getMinMaxRelAngles
std::pair< double, double > getMinMaxRelAngles(NBEdge *e) const
Definition: NBContHelper.h:354
NBContHelper::node_with_outgoing_finder::node_with_outgoing_finder
node_with_outgoing_finder(const NBEdge *const e)
constructor
Definition: NBContHelper.cpp:111
NBContHelper::relative_outgoing_edge_sorter
Definition: NBContHelper.h:76
NBContHelper::node_with_incoming_finder::node_with_incoming_finder
node_with_incoming_finder(const NBEdge *const e)
constructor
Definition: NBContHelper.cpp:96
NBContHelper::edge_opposite_direction_sorter::myEdge
const NBEdge *const myEdge
the reference edge
Definition: NBContHelper.h:195
NBEdge::getSpeed
double getSpeed() const
Returns the speed allowed on this edge.
Definition: NBEdge.h:571
NBContHelper::edge_with_destination_finder::edge_with_destination_finder
edge_with_destination_finder(NBNode *dest)
constructor
Definition: NBContHelper.cpp:125
NBContHelper::edge_similar_direction_sorter::edge_similar_direction_sorter
edge_similar_direction_sorter(const NBEdge *const e)
constructor
Definition: NBContHelper.h:220
NBContHelper::edge_similar_direction_sorter::operator()
int operator()(const NBEdge *e1, const NBEdge *e2) const
comparing operation
Definition: NBContHelper.h:224
NBContHelper::operator<<
friend std::ostream & operator<<(std::ostream &os, const EdgeVector &ev)
Definition: NBContHelper.cpp:198
NBContHelper::edge_opposite_direction_sorter::myRegardPriority
bool myRegardPriority
Whether edge priority may override closer angles.
Definition: NBContHelper.h:201
NBContHelper::edge_opposite_direction_sorter
Class to sort edges by their angle in relation to the given edge.
Definition: NBContHelper.h:140
NBContHelper::nextCW
static void nextCW(const EdgeVector &edges, EdgeVector::const_iterator &from)
Definition: NBContHelper.cpp:39
config.h
NBEdge::getConnectedEdges
EdgeVector getConnectedEdges() const
Returns the list of outgoing edges unsorted.
Definition: NBEdge.cpp:1199
GeomHelper.h
NBContHelper::edge_with_destination_finder::myDestinationNode
NBNode * myDestinationNode
Definition: NBContHelper.h:306
StdDefs.h
NBContHelper::node_with_outgoing_finder::myEdge
const NBEdge *const myEdge
Definition: NBContHelper.h:287
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
NBNode.h
NBContHelper::node_with_incoming_finder
Definition: NBContHelper.h:259
NBEdge::getFromNode
NBNode * getFromNode() const
Returns the origin node of the edge.
Definition: NBEdge.h:491
NBEdge::getTotalAngle
double getTotalAngle() const
Returns the angle at the start of the edge.
Definition: NBEdge.h:538
NBContHelper::edge_by_priority_sorter::operator()
int operator()(NBEdge *e1, NBEdge *e2) const
comparing operator
Definition: NBContHelper.h:120
NBContHelper::edge_with_destination_finder
Definition: NBContHelper.h:298
NBContHelper::relative_outgoing_edge_sorter::relative_outgoing_edge_sorter
relative_outgoing_edge_sorter(NBEdge *e)
constructor
Definition: NBContHelper.h:79
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:181
NBContHelper::edge_opposite_direction_sorter::myAngle
double myAngle
The angle of the related edge at the given node.
Definition: NBContHelper.h:198
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:336
NBContHelper::edge_similar_direction_sorter::angleDiff
double angleDiff(const double angle1, const double angle2) const
Definition: NBContHelper.h:238
NBEdge::getID
const std::string & getID() const
Definition: NBEdge.h:1380