Eclipse SUMO - Simulation of Urban MObility
ROEdge.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2002-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 /****************************************************************************/
20 // A basic edge for routing applications
21 /****************************************************************************/
22 #ifndef ROEdge_h
23 #define ROEdge_h
24 
25 
26 // ===========================================================================
27 // included modules
28 // ===========================================================================
29 #include <config.h>
30 
31 #include <string>
32 #include <map>
33 #include <vector>
34 #include <algorithm>
35 #include <utils/common/Named.h>
36 #include <utils/common/StdDefs.h>
41 #include <utils/geom/Boundary.h>
42 #ifdef HAVE_FOX
43 #include <fx.h>
44 #endif
46 #include "RONode.h"
47 #include "ROVehicle.h"
48 
49 
50 // ===========================================================================
51 // class declarations
52 // ===========================================================================
53 class ROLane;
54 class ROEdge;
55 
56 typedef std::vector<ROEdge*> ROEdgeVector;
57 typedef std::vector<const ROEdge*> ConstROEdgeVector;
58 typedef std::vector<std::pair<const ROEdge*, const ROEdge*> > ROConstEdgePairVector;
59 
60 
61 // ===========================================================================
62 // class definitions
63 // ===========================================================================
73 class ROEdge : public Named {
74 public:
82  ROEdge(const std::string& id, RONode* from, RONode* to, int index, const int priority);
83 
84 
86  virtual ~ROEdge();
87 
88 
90 
91 
100  virtual void addLane(ROLane* lane);
101 
102 
109  virtual void addSuccessor(ROEdge* s, ROEdge* via = nullptr, std::string dir = "");
110 
111 
115  inline void setFunction(SumoXMLEdgeFunc func) {
116  myFunction = func;
117  }
118 
119 
123  inline void setSource(const bool isSource = true) {
124  myAmSource = isSource;
125  }
126 
127 
131  inline void setSink(const bool isSink = true) {
132  myAmSink = isSink;
133  }
134 
135 
139  inline void setRestrictions(const std::map<SUMOVehicleClass, double>* restrictions) {
140  myRestrictions = restrictions;
141  }
142 
143  inline void setTimePenalty(double value) {
144  myTimePenalty = value;
145  }
146 
148  inline bool isInternal() const {
149  return myFunction == EDGEFUNC_INTERNAL;
150  }
151 
153  inline bool isCrossing() const {
154  return myFunction == EDGEFUNC_CROSSING;
155  }
156 
158  inline bool isWalkingArea() const {
160  }
161 
162  inline bool isTazConnector() const {
163  return myFunction == EDGEFUNC_CONNECTOR;
164  }
165 
175  void buildTimeLines(const std::string& measure, const bool boundariesOverride);
177 
178 
179 
181 
182 
187  inline SumoXMLEdgeFunc getFunction() const {
188  return myFunction;
189  }
190 
191 
195  inline bool isSink() const {
196  return myAmSink;
197  }
198 
199 
203  double getLength() const {
204  return myLength;
205  }
206 
210  int getNumericalID() const {
211  return myIndex;
212  }
213 
214 
218  double getSpeedLimit() const {
219  return mySpeed;
220  }
221 
223  // sufficient for the astar air-distance heuristic
224  double getLengthGeometryFactor() const;
225 
230  inline double getVClassMaxSpeed(SUMOVehicleClass vclass) const {
231  if (myRestrictions != 0) {
232  std::map<SUMOVehicleClass, double>::const_iterator r = myRestrictions->find(vclass);
233  if (r != myRestrictions->end()) {
234  return r->second;
235  }
236  }
237  return mySpeed;
238  }
239 
240 
244  int getNumLanes() const {
245  return (int) myLanes.size();
246  }
247 
248 
255  bool isConnectedTo(const ROEdge* const e, const ROVehicle* const vehicle) const;
256 
257 
262  inline bool prohibits(const ROVehicle* const vehicle) const {
263  const SUMOVehicleClass vclass = vehicle->getVClass();
264  return (myCombinedPermissions & vclass) != vclass;
265  }
266 
268  return myCombinedPermissions;
269  }
270 
271 
276  bool allFollowersProhibit(const ROVehicle* const vehicle) const;
278 
279 
280 
282 
283 
290  void addEffort(double value, double timeBegin, double timeEnd);
291 
292 
299  void addTravelTime(double value, double timeBegin, double timeEnd);
300 
301 
309  int getNumSuccessors() const;
310 
311 
317 
323 
324 
332  int getNumPredecessors() const;
333 
334 
339  const ROEdgeVector& getPredecessors() const {
340  return myApproachingEdges;
341  }
342 
344  const ROEdge* getNormalBefore() const;
345 
347  const ROEdge* getNormalAfter() const;
348 
356  double getEffort(const ROVehicle* const veh, double time) const;
357 
358 
364  bool hasLoadedTravelTime(double time) const;
365 
366 
373  double getTravelTime(const ROVehicle* const veh, double time) const;
374 
375 
384  static inline double getEffortStatic(const ROEdge* const edge, const ROVehicle* const veh, double time) {
385  return edge->getEffort(veh, time);
386  }
387 
388 
396  static inline double getTravelTimeStatic(const ROEdge* const edge, const ROVehicle* const veh, double time) {
397  return edge->getTravelTime(veh, time);
398  }
399 
400  static inline double getTravelTimeStaticRandomized(const ROEdge* const edge, const ROVehicle* const veh, double time) {
401  return edge->getTravelTime(veh, time) * RandHelper::rand(1., gWeightsRandomFactor);
402  }
403 
404 
410  inline double getMinimumTravelTime(const ROVehicle* const veh) const {
411  if (isTazConnector()) {
412  return 0;
413  } else if (veh != 0) {
414  return myLength / MIN2(veh->getType()->maxSpeed, veh->getChosenSpeedFactor() * mySpeed);
415  } else {
416  return myLength / mySpeed;
417  }
418  }
419 
420 
421  template<PollutantsInterface::EmissionType ET>
422  static double getEmissionEffort(const ROEdge* const edge, const ROVehicle* const veh, double time) {
423  double ret = 0;
424  if (!edge->getStoredEffort(time, ret)) {
425  const SUMOVTypeParameter* const type = veh->getType();
426  const double vMax = MIN2(type->maxSpeed, edge->mySpeed);
428  ret = PollutantsInterface::computeDefault(type->emissionClass, ET, vMax, accel, 0, edge->getTravelTime(veh, time)); // @todo: give correct slope
429  }
430  return ret;
431  }
432 
433 
434  static double getNoiseEffort(const ROEdge* const edge, const ROVehicle* const veh, double time);
436 
437 
439  double getDistanceTo(const ROEdge* other, const bool doBoundaryEstimate = false) const;
440 
441 
443  static const ROEdgeVector& getAllEdges();
444 
446  static int dictSize() {
447  return (int)myEdges.size();
448  };
449 
450  static void setGlobalOptions(const bool interpolate) {
451  myInterpolate = interpolate;
452  }
453 
455  static const Position getStopPosition(const SUMOVehicleParameter::Stop& stop);
456 
458  int getPriority() const {
459  return myPriority;
460  }
461 
462  const RONode* getFromJunction() const {
463  return myFromJunction;
464  }
465 
466  const RONode* getToJunction() const {
467  return myToJunction;
468  }
469 
470 
475  const std::vector<ROLane*>& getLanes() const {
476  return myLanes;
477  }
478 protected:
485  bool getStoredEffort(double time, double& ret) const;
486 
487 
488 
489 protected:
493 
495  const int myIndex;
496 
498  const int myPriority;
499 
501  double mySpeed;
502 
504  double myLength;
505 
512 
517 
519  static bool myInterpolate;
520 
522  static bool myHaveEWarned;
524  static bool myHaveTTWarned;
525 
528 
530 
533 
536 
538  const std::map<SUMOVehicleClass, double>* myRestrictions;
539 
541  std::vector<ROLane*> myLanes;
542 
545 
548 
551 
553 
554 
556  mutable std::map<SUMOVehicleClass, ROEdgeVector> myClassesSuccessorMap;
557 
559  mutable std::map<SUMOVehicleClass, ROConstEdgePairVector> myClassesViaSuccessorMap;
560 
561 #ifdef HAVE_FOX
562  mutable FXMutex myLock;
564 #endif
565 
566 private:
568  ROEdge(const ROEdge& src);
569 
571  ROEdge& operator=(const ROEdge& src);
572 
573 };
574 
575 
576 #endif
577 
578 /****************************************************************************/
579 
ROEdge::getPriority
int getPriority() const
get edge priority (road class)
Definition: ROEdge.h:458
Boundary.h
EDGEFUNC_INTERNAL
Definition: SUMOXMLDefinitions.h:1080
ROEdge::getAllEdges
static const ROEdgeVector & getAllEdges()
Returns all ROEdges.
Definition: ROEdge.cpp:336
ROEdge::isInternal
bool isInternal() const
return whether this edge is an internal edge
Definition: ROEdge.h:148
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition: SUMOVehicleClass.h:134
ROEdge::allFollowersProhibit
bool allFollowersProhibit(const ROVehicle *const vehicle) const
Returns whether this edge succeeding edges prohibit the given vehicle to pass them.
Definition: ROEdge.cpp:325
ROEdge::getNumLanes
int getNumLanes() const
Returns the number of lanes this edge has.
Definition: ROEdge.h:244
ROEdge::myRestrictions
const std::map< SUMOVehicleClass, double > * myRestrictions
The vClass speed restrictions for this edge.
Definition: ROEdge.h:538
MIN2
T MIN2(T a, T b)
Definition: StdDefs.h:74
ROEdge::myFollowingEdges
ROEdgeVector myFollowingEdges
List of edges that may be approached from this edge.
Definition: ROEdge.h:527
ROEdge::isCrossing
bool isCrossing() const
return whether this edge is a pedestrian crossing
Definition: ROEdge.h:153
ROEdge::myLanes
std::vector< ROLane * > myLanes
This edge's lanes.
Definition: ROEdge.h:541
ROEdge::getTravelTime
double getTravelTime(const ROVehicle *const veh, double time) const
Returns the travel time for this edge.
Definition: ROEdge.cpp:184
ROEdge::myToJunction
RONode * myToJunction
Definition: ROEdge.h:492
Named
Base class for objects which have an id.
Definition: Named.h:57
EDGEFUNC_CROSSING
Definition: SUMOXMLDefinitions.h:1078
ROEdge::setTimePenalty
void setTimePenalty(double value)
Definition: ROEdge.h:143
RONode.h
ROEdge::myUsingTTTimeLine
bool myUsingTTTimeLine
Information whether the time line shall be used instead of the length value.
Definition: ROEdge.h:511
ROEdge::getEffortStatic
static double getEffortStatic(const ROEdge *const edge, const ROVehicle *const veh, double time)
Returns the effort for the given edge.
Definition: ROEdge.h:384
ROEdge::getSuccessors
const ROEdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
Definition: ROEdge.cpp:350
ValueTimeLine.h
ROEdge::myEfforts
ValueTimeLine< double > myEfforts
Container storing passing time varying over time for the edge.
Definition: ROEdge.h:514
ROEdge::myHaveEWarned
static bool myHaveEWarned
Information whether the edge has reported missing weights.
Definition: ROEdge.h:522
ROEdge::getTravelTimeStatic
static double getTravelTimeStatic(const ROEdge *const edge, const ROVehicle *const veh, double time)
Returns the travel time for the given edge.
Definition: ROEdge.h:396
ROEdge::myClassesViaSuccessorMap
std::map< SUMOVehicleClass, ROConstEdgePairVector > myClassesViaSuccessorMap
The successors with vias available for a given vClass.
Definition: ROEdge.h:559
ROEdge::myFollowingViaEdges
ROConstEdgePairVector myFollowingViaEdges
Definition: ROEdge.h:529
ROEdge::myAmSource
bool myAmSource
Definition: ROEdge.h:507
SumoXMLEdgeFunc
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
Definition: SUMOXMLDefinitions.h:1074
ROLane
A single lane the router may use.
Definition: ROLane.h:51
ROEdge::ROEdge
ROEdge(const std::string &id, RONode *from, RONode *to, int index, const int priority)
Constructor.
Definition: ROEdge.cpp:55
ROEdge::dictSize
static int dictSize()
Returns the number of edges.
Definition: ROEdge.h:446
RORoutable::getType
const SUMOVTypeParameter * getType() const
Returns the type of the routable.
Definition: RORoutable.h:85
ROVehicle
A vehicle as used by router.
Definition: ROVehicle.h:53
ROEdge::getLanes
const std::vector< ROLane * > & getLanes() const
Returns this edge's lanes.
Definition: ROEdge.h:475
ROConstEdgePairVector
std::vector< std::pair< const ROEdge *, const ROEdge * > > ROConstEdgePairVector
Definition: ROEdge.h:58
ROEdge::myPriority
const int myPriority
The edge priority (road class)
Definition: ROEdge.h:498
ROVehicle.h
SUMOVTypeParameter::getDefaultImperfection
static double getDefaultImperfection(const SUMOVehicleClass vc=SVC_IGNORING)
Returns the default driver's imperfection (sigma or epsilon in Krauss' model) for the given vehicle c...
Definition: SUMOVTypeParameter.cpp:584
ROVehicle::getChosenSpeedFactor
double getChosenSpeedFactor() const
Returns an upper bound for the speed factor of this vehicle.
Definition: ROVehicle.h:112
ROEdge::setSource
void setSource(const bool isSource=true)
Sets whether the edge is a source.
Definition: ROEdge.h:123
ROEdge::getNoiseEffort
static double getNoiseEffort(const ROEdge *const edge, const ROVehicle *const veh, double time)
Definition: ROEdge.cpp:209
ROEdge::myFunction
SumoXMLEdgeFunc myFunction
The function of the edge.
Definition: ROEdge.h:535
ROEdge::setGlobalOptions
static void setGlobalOptions(const bool interpolate)
Definition: ROEdge.h:450
RORoutable::getVClass
SUMOVehicleClass getVClass() const
Definition: RORoutable.h:108
gWeightsRandomFactor
double gWeightsRandomFactor
Definition: StdDefs.cpp:31
ROEdge::getViaSuccessors
const ROConstEdgePairVector & getViaSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges including vias, restricted by vClass.
Definition: ROEdge.cpp:386
ROEdge::getEffort
double getEffort(const ROVehicle *const veh, double time) const
Returns the effort for this edge.
Definition: ROEdge.cpp:148
ROEdge::getPredecessors
const ROEdgeVector & getPredecessors() const
Returns the edge at the given position from the list of incoming edges.
Definition: ROEdge.h:339
ROEdge::myEdges
static ROEdgeVector myEdges
Definition: ROEdge.h:552
ROEdge::myCombinedPermissions
SVCPermissions myCombinedPermissions
The list of allowed vehicle classes combined across lanes.
Definition: ROEdge.h:544
RandHelper::rand
static double rand(std::mt19937 *rng=0)
Returns a random real number in [0, 1)
Definition: RandHelper.h:60
ROEdge::mySpeed
double mySpeed
The maximum speed allowed on this edge.
Definition: ROEdge.h:501
SUMO_ATTR_ACCEL
Definition: SUMOXMLDefinitions.h:446
ROEdge::addTravelTime
void addTravelTime(double value, double timeBegin, double timeEnd)
Adds a travel time value.
Definition: ROEdge.cpp:141
ROEdge::addSuccessor
virtual void addSuccessor(ROEdge *s, ROEdge *via=nullptr, std::string dir="")
Adds information about a connected edge.
Definition: ROEdge.cpp:105
SVCPermissions
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
Definition: SUMOVehicleClass.h:219
ROEdge::myIndex
const int myIndex
The index (numeric id) of the edge.
Definition: ROEdge.h:495
PollutantsInterface.h
ROEdge::getTravelTimeStaticRandomized
static double getTravelTimeStaticRandomized(const ROEdge *const edge, const ROVehicle *const veh, double time)
Definition: ROEdge.h:400
ROEdge::operator=
ROEdge & operator=(const ROEdge &src)
Invalidated assignment operator.
ROEdge::addEffort
void addEffort(double value, double timeBegin, double timeEnd)
Adds a weight value.
Definition: ROEdge.cpp:134
EDGEFUNC_WALKINGAREA
Definition: SUMOXMLDefinitions.h:1079
SUMOVTypeParameter
Structure representing possible vehicle parameter.
Definition: SUMOVTypeParameter.h:86
Named.h
SUMOVTypeParameter::getDefaultAccel
static double getDefaultAccel(const SUMOVehicleClass vc=SVC_IGNORING)
Returns the default acceleration for the given vehicle class This needs to be a function because the ...
Definition: SUMOVTypeParameter.cpp:472
ROEdge::myTravelTimes
ValueTimeLine< double > myTravelTimes
Container storing passing time varying over time for the edge.
Definition: ROEdge.h:509
ROEdge::setRestrictions
void setRestrictions(const std::map< SUMOVehicleClass, double > *restrictions)
Sets the vehicle class specific speed limits of the edge.
Definition: ROEdge.h:139
ROEdge::getStoredEffort
bool getStoredEffort(double time, double &ret) const
Retrieves the stored effort.
Definition: ROEdge.cpp:220
SUMOVehicleClass.h
Boundary
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:42
ROEdge::setSink
void setSink(const bool isSink=true)
Sets whether the edge is a sink.
Definition: ROEdge.h:131
ROEdge::getLengthGeometryFactor
double getLengthGeometryFactor() const
return a lower bound on shape.length() / myLength that is
Definition: ROEdge.cpp:319
ROEdgeVector
std::vector< ROEdge * > ROEdgeVector
Definition: ROEdge.h:54
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:39
EDGEFUNC_CONNECTOR
Definition: SUMOXMLDefinitions.h:1077
SUMOVTypeParameter::getCFParam
double getCFParam(const SumoXMLAttr attr, const double defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:406
SUMOVTypeParameter::maxSpeed
double maxSpeed
The vehicle type's maximum speed [m/s].
Definition: SUMOVTypeParameter.h:219
ROEdgeVector
std::vector< ROEdge * > ROEdgeVector
Definition: RODFRouteDesc.h:36
ROEdge::getNormalBefore
const ROEdge * getNormalBefore() const
if this edge is an internal edge, return its first normal predecessor, otherwise the edge itself
Definition: ROEdge.cpp:263
ROEdge::isTazConnector
bool isTazConnector() const
Definition: ROEdge.h:162
ROEdge::getNumericalID
int getNumericalID() const
Returns the index (numeric id) of the edge.
Definition: ROEdge.h:210
ROEdge::getFunction
SumoXMLEdgeFunc getFunction() const
Returns the function of the edge.
Definition: ROEdge.h:187
ROEdge::buildTimeLines
void buildTimeLines(const std::string &measure, const bool boundariesOverride)
Builds the internal representation of the travel time/effort.
Definition: ROEdge.cpp:285
ROEdge::myInterpolate
static bool myInterpolate
Information whether to interpolate at interval boundaries.
Definition: ROEdge.h:519
ROEdge::isSink
bool isSink() const
Returns whether the edge acts as a sink.
Definition: ROEdge.h:195
PollutantsInterface::computeDefault
static double computeDefault(const SUMOEmissionClass c, const EmissionType e, const double v, const double a, const double slope, const double tt, const std::map< int, double > *param=0)
Returns the amount of emitted pollutant given the vehicle type and default values for the state (in m...
Definition: PollutantsInterface.cpp:164
ROEdge::getNumSuccessors
int getNumSuccessors() const
Returns the number of edges this edge is connected to.
Definition: ROEdge.cpp:245
ROEdge::myBoundary
Boundary myBoundary
The bounding rectangle of end nodes incoming or outgoing edges for taz connectors or of my own start ...
Definition: ROEdge.h:547
ROEdge::myApproachingEdges
ROEdgeVector myApproachingEdges
List of edges that approached this edge.
Definition: ROEdge.h:532
ROEdge::getFromJunction
const RONode * getFromJunction() const
Definition: ROEdge.h:462
SUMO_ATTR_SIGMA
Definition: SUMOXMLDefinitions.h:548
ROEdge::prohibits
bool prohibits(const ROVehicle *const vehicle) const
Returns whether this edge prohibits the given vehicle to pass it.
Definition: ROEdge.h:262
ROEdge::myLength
double myLength
The length of the edge.
Definition: ROEdge.h:504
ROEdge::getVClassMaxSpeed
double getVClassMaxSpeed(SUMOVehicleClass vclass) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
Definition: ROEdge.h:230
ROEdge::getLength
double getLength() const
Returns the length of the edge.
Definition: ROEdge.h:203
ROEdge::getNumPredecessors
int getNumPredecessors() const
Returns the number of edges connected to this edge.
Definition: ROEdge.cpp:254
ROEdge::~ROEdge
virtual ~ROEdge()
Destructor.
Definition: ROEdge.cpp:84
ROEdge::getEmissionEffort
static double getEmissionEffort(const ROEdge *const edge, const ROVehicle *const veh, double time)
Definition: ROEdge.h:422
ROEdge::myClassesSuccessorMap
std::map< SUMOVehicleClass, ROEdgeVector > myClassesSuccessorMap
The successors available for a given vClass.
Definition: ROEdge.h:556
ROEdge::addLane
virtual void addLane(ROLane *lane)
Adds a lane to the edge while loading.
Definition: ROEdge.cpp:92
ROEdge::hasLoadedTravelTime
bool hasLoadedTravelTime(double time) const
Returns whether a travel time for this edge was loaded.
Definition: ROEdge.cpp:178
ROEdge::getPermissions
SVCPermissions getPermissions() const
Definition: ROEdge.h:267
ROEdge
A basic edge for routing applications.
Definition: ROEdge.h:73
ROEdge::isWalkingArea
bool isWalkingArea() const
return whether this edge is walking area
Definition: ROEdge.h:158
ROEdge::myHaveTTWarned
static bool myHaveTTWarned
Information whether the edge has reported missing weights.
Definition: ROEdge.h:524
config.h
ROEdge::getNormalAfter
const ROEdge * getNormalAfter() const
if this edge is an internal edge, return its first normal successor, otherwise the edge itself
Definition: ROEdge.cpp:274
RandHelper.h
StdDefs.h
ROEdge::getMinimumTravelTime
double getMinimumTravelTime(const ROVehicle *const veh) const
Returns a lower bound for the travel time on this edge without using any stored timeLine.
Definition: ROEdge.h:410
ROEdge::getSpeedLimit
double getSpeedLimit() const
Returns the speed allowed on this edge.
Definition: ROEdge.h:218
ROEdge::isConnectedTo
bool isConnectedTo(const ROEdge *const e, const ROVehicle *const vehicle) const
returns the information whether this edge is directly connected to the given
Definition: ROEdge.cpp:422
SUMOVTypeParameter::emissionClass
SUMOEmissionClass emissionClass
The emission class of this vehicle.
Definition: SUMOVTypeParameter.h:232
ValueTimeLine< double >
SVC_IGNORING
vehicles ignoring classes
Definition: SUMOVehicleClass.h:136
RONode
Base class for nodes used by the router.
Definition: RONode.h:46
SUMOVTypeParameter.h
ROEdge::setFunction
void setFunction(SumoXMLEdgeFunc func)
Sets the function of the edge.
Definition: ROEdge.h:115
ROEdge::getStopPosition
static const Position getStopPosition(const SUMOVehicleParameter::Stop &stop)
return the coordinates of the center of the given stop
Definition: ROEdge.cpp:342
SUMOVTypeParameter::vehicleClass
SUMOVehicleClass vehicleClass
The vehicle's class.
Definition: SUMOVTypeParameter.h:238
ROEdge::getDistanceTo
double getDistanceTo(const ROEdge *other, const bool doBoundaryEstimate=false) const
optimistic distance heuristic for use in routing
Definition: ROEdge.cpp:158
ROEdge::myTimePenalty
double myTimePenalty
flat penalty when computing traveltime
Definition: ROEdge.h:550
ROEdge::myUsingETimeLine
bool myUsingETimeLine
Information whether the time line shall be used instead of the length value.
Definition: ROEdge.h:516
ROEdge::myFromJunction
RONode * myFromJunction
the junctions for this edge
Definition: ROEdge.h:491
ConstROEdgeVector
std::vector< const ROEdge * > ConstROEdgeVector
Definition: ROEdge.h:57
SUMOVehicleParameter::Stop
Definition of vehicle stop (position and duration)
Definition: SUMOVehicleParameter.h:566
ROEdge::myAmSink
bool myAmSink
whether the edge is a source or a sink
Definition: ROEdge.h:507
ROEdge::getToJunction
const RONode * getToJunction() const
Definition: ROEdge.h:466