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 /****************************************************************************/
19 // A basic edge for routing applications
20 /****************************************************************************/
21 #ifndef ROEdge_h
22 #define ROEdge_h
23 
24 
25 // ===========================================================================
26 // included modules
27 // ===========================================================================
28 #include <config.h>
29 
30 #include <string>
31 #include <map>
32 #include <vector>
33 #include <algorithm>
34 #include <utils/common/Named.h>
35 #include <utils/common/StdDefs.h>
40 #include <utils/geom/Boundary.h>
41 #ifdef HAVE_FOX
42 #include <fx.h>
43 #endif
45 #include "RONode.h"
46 #include "ROVehicle.h"
47 
48 
49 // ===========================================================================
50 // class declarations
51 // ===========================================================================
52 class ROLane;
53 class ROEdge;
54 
55 typedef std::vector<ROEdge*> ROEdgeVector;
56 typedef std::vector<const ROEdge*> ConstROEdgeVector;
57 typedef std::vector<std::pair<const ROEdge*, const ROEdge*> > ROConstEdgePairVector;
58 
59 
60 // ===========================================================================
61 // class definitions
62 // ===========================================================================
72 class ROEdge : public Named, public Parameterised {
73 public:
81  ROEdge(const std::string& id, RONode* from, RONode* to, int index, const int priority);
82 
83 
85  virtual ~ROEdge();
86 
87 
89 
90 
99  virtual void addLane(ROLane* lane);
100 
101 
108  virtual void addSuccessor(ROEdge* s, ROEdge* via = nullptr, std::string dir = "");
109 
110 
114  inline void setFunction(SumoXMLEdgeFunc func) {
115  myFunction = func;
116  }
117 
118 
122  inline void setSource(const bool isSource = true) {
123  myAmSource = isSource;
124  }
125 
126 
130  inline void setSink(const bool isSink = true) {
131  myAmSink = isSink;
132  }
133 
134 
138  inline void setRestrictions(const std::map<SUMOVehicleClass, double>* restrictions) {
139  myRestrictions = restrictions;
140  }
141 
142  inline void setTimePenalty(double value) {
143  myTimePenalty = value;
144  }
145 
147  inline bool isInternal() const {
148  return myFunction == EDGEFUNC_INTERNAL;
149  }
150 
152  inline bool isCrossing() const {
153  return myFunction == EDGEFUNC_CROSSING;
154  }
155 
157  inline bool isWalkingArea() const {
159  }
160 
161  inline bool isTazConnector() const {
162  return myFunction == EDGEFUNC_CONNECTOR;
163  }
164 
174  void buildTimeLines(const std::string& measure, const bool boundariesOverride);
175 
176  void cacheParamRestrictions(const std::vector<std::string>& restrictionKeys);
178 
179 
180 
182 
183 
188  inline SumoXMLEdgeFunc getFunction() const {
189  return myFunction;
190  }
191 
192 
196  inline bool isSink() const {
197  return myAmSink;
198  }
199 
200 
204  double getLength() const {
205  return myLength;
206  }
207 
211  int getNumericalID() const {
212  return myIndex;
213  }
214 
215 
219  double getSpeedLimit() const {
220  return mySpeed;
221  }
222 
224  // sufficient for the astar air-distance heuristic
225  double getLengthGeometryFactor() const;
226 
231  inline double getVClassMaxSpeed(SUMOVehicleClass vclass) const {
232  if (myRestrictions != 0) {
233  std::map<SUMOVehicleClass, double>::const_iterator r = myRestrictions->find(vclass);
234  if (r != myRestrictions->end()) {
235  return r->second;
236  }
237  }
238  return mySpeed;
239  }
240 
241 
245  int getNumLanes() const {
246  return (int) myLanes.size();
247  }
248 
249 
256  bool isConnectedTo(const ROEdge* const e, const ROVehicle* const vehicle) const;
257 
258 
263  inline bool prohibits(const ROVehicle* const vehicle) const {
264  const SUMOVehicleClass vclass = vehicle->getVClass();
265  return (myCombinedPermissions & vclass) != vclass;
266  }
267 
269  return myCombinedPermissions;
270  }
271 
276  inline bool restricts(const ROVehicle* const vehicle) const {
277  const std::vector<double>& vTypeRestrictions = vehicle->getType()->paramRestrictions;
278  assert(vTypeRestrictions.size() == myParamRestrictions.size());
279  for (int i = 0; i < (int)vTypeRestrictions.size(); i++) {
280  if (vTypeRestrictions[i] > myParamRestrictions[i]) {
281  return true;
282  }
283  }
284  return false;
285  }
286 
287 
292  bool allFollowersProhibit(const ROVehicle* const vehicle) const;
294 
295 
296 
298 
299 
306  void addEffort(double value, double timeBegin, double timeEnd);
307 
308 
315  void addTravelTime(double value, double timeBegin, double timeEnd);
316 
317 
325  int getNumSuccessors() const;
326 
327 
333 
339 
340 
348  int getNumPredecessors() const;
349 
350 
355  const ROEdgeVector& getPredecessors() const {
356  return myApproachingEdges;
357  }
358 
360  const ROEdge* getNormalBefore() const;
361 
363  const ROEdge* getNormalAfter() const;
364 
372  double getEffort(const ROVehicle* const veh, double time) const;
373 
374 
380  bool hasLoadedTravelTime(double time) const;
381 
382 
389  double getTravelTime(const ROVehicle* const veh, double time) const;
390 
391 
400  static inline double getEffortStatic(const ROEdge* const edge, const ROVehicle* const veh, double time) {
401  return edge->getEffort(veh, time);
402  }
403 
404 
412  static inline double getTravelTimeStatic(const ROEdge* const edge, const ROVehicle* const veh, double time) {
413  return edge->getTravelTime(veh, time);
414  }
415 
416  static inline double getTravelTimeStaticRandomized(const ROEdge* const edge, const ROVehicle* const veh, double time) {
417  return edge->getTravelTime(veh, time) * RandHelper::rand(1., gWeightsRandomFactor);
418  }
419 
420 
426  inline double getMinimumTravelTime(const ROVehicle* const veh) const {
427  if (isTazConnector()) {
428  return 0;
429  } else if (veh != 0) {
430  return myLength / MIN2(veh->getType()->maxSpeed, veh->getChosenSpeedFactor() * mySpeed);
431  } else {
432  return myLength / mySpeed;
433  }
434  }
435 
436 
437  template<PollutantsInterface::EmissionType ET>
438  static double getEmissionEffort(const ROEdge* const edge, const ROVehicle* const veh, double time) {
439  double ret = 0;
440  if (!edge->getStoredEffort(time, ret)) {
441  const SUMOVTypeParameter* const type = veh->getType();
442  const double vMax = MIN2(type->maxSpeed, edge->mySpeed);
444  ret = PollutantsInterface::computeDefault(type->emissionClass, ET, vMax, accel, 0, edge->getTravelTime(veh, time)); // @todo: give correct slope
445  }
446  return ret;
447  }
448 
449 
450  static double getNoiseEffort(const ROEdge* const edge, const ROVehicle* const veh, double time);
452 
453 
455  double getDistanceTo(const ROEdge* other, const bool doBoundaryEstimate = false) const;
456 
457 
459  static const ROEdgeVector& getAllEdges();
460 
462  static int dictSize() {
463  return (int)myEdges.size();
464  };
465 
466  static void setGlobalOptions(const bool interpolate) {
467  myInterpolate = interpolate;
468  }
469 
471  static const Position getStopPosition(const SUMOVehicleParameter::Stop& stop);
472 
474  int getPriority() const {
475  return myPriority;
476  }
477 
478  const RONode* getFromJunction() const {
479  return myFromJunction;
480  }
481 
482  const RONode* getToJunction() const {
483  return myToJunction;
484  }
485 
486 
491  const std::vector<ROLane*>& getLanes() const {
492  return myLanes;
493  }
494 protected:
501  bool getStoredEffort(double time, double& ret) const;
502 
503 
504 
505 protected:
509 
511  const int myIndex;
512 
514  const int myPriority;
515 
517  double mySpeed;
518 
520  double myLength;
521 
528 
533 
535  static bool myInterpolate;
536 
538  static bool myHaveEWarned;
540  static bool myHaveTTWarned;
541 
544 
546 
549 
552 
554  const std::map<SUMOVehicleClass, double>* myRestrictions;
555 
557  std::vector<ROLane*> myLanes;
558 
561 
564 
567 
569  std::vector<double> myParamRestrictions;
570 
572 
573 
575  mutable std::map<SUMOVehicleClass, ROEdgeVector> myClassesSuccessorMap;
576 
578  mutable std::map<SUMOVehicleClass, ROConstEdgePairVector> myClassesViaSuccessorMap;
579 
580 #ifdef HAVE_FOX
581  mutable FXMutex myLock;
583 #endif
584 
585 private:
587  ROEdge(const ROEdge& src);
588 
590  ROEdge& operator=(const ROEdge& src);
591 
592 };
593 
594 
595 #endif
596 
597 /****************************************************************************/
598 
ROEdge::getPriority
int getPriority() const
get edge priority (road class)
Definition: ROEdge.h:474
Boundary.h
EDGEFUNC_INTERNAL
Definition: SUMOXMLDefinitions.h:1085
ROEdge::getAllEdges
static const ROEdgeVector & getAllEdges()
Returns all ROEdges.
Definition: ROEdge.cpp:344
ROEdge::isInternal
bool isInternal() const
return whether this edge is an internal edge
Definition: ROEdge.h:147
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition: SUMOVehicleClass.h:133
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:333
ROEdge::getNumLanes
int getNumLanes() const
Returns the number of lanes this edge has.
Definition: ROEdge.h:245
ROEdge::myRestrictions
const std::map< SUMOVehicleClass, double > * myRestrictions
The vClass speed restrictions for this edge.
Definition: ROEdge.h:554
MIN2
T MIN2(T a, T b)
Definition: StdDefs.h:73
ROEdge::myFollowingEdges
ROEdgeVector myFollowingEdges
List of edges that may be approached from this edge.
Definition: ROEdge.h:543
ROEdge::isCrossing
bool isCrossing() const
return whether this edge is a pedestrian crossing
Definition: ROEdge.h:152
ROEdge::myLanes
std::vector< ROLane * > myLanes
This edge's lanes.
Definition: ROEdge.h:557
ROEdge::getTravelTime
double getTravelTime(const ROVehicle *const veh, double time) const
Returns the travel time for this edge.
Definition: ROEdge.cpp:183
Parameterised
An upper class for objects with additional parameters.
Definition: Parameterised.h:42
ROEdge::myToJunction
RONode * myToJunction
Definition: ROEdge.h:508
Named
Base class for objects which have an id.
Definition: Named.h:56
EDGEFUNC_CROSSING
Definition: SUMOXMLDefinitions.h:1083
ROEdge::setTimePenalty
void setTimePenalty(double value)
Definition: ROEdge.h:142
RONode.h
ROEdge::restricts
bool restricts(const ROVehicle *const vehicle) const
Returns whether this edge has restriction parameters forbidding the given vehicle to pass it.
Definition: ROEdge.h:276
ROEdge::myUsingTTTimeLine
bool myUsingTTTimeLine
Information whether the time line shall be used instead of the length value.
Definition: ROEdge.h:527
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:400
ROEdge::getSuccessors
const ROEdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
Definition: ROEdge.cpp:358
ValueTimeLine.h
ROEdge::myEfforts
ValueTimeLine< double > myEfforts
Container storing passing time varying over time for the edge.
Definition: ROEdge.h:530
ROEdge::myHaveEWarned
static bool myHaveEWarned
Information whether the edge has reported missing weights.
Definition: ROEdge.h:538
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:412
ROEdge::myClassesViaSuccessorMap
std::map< SUMOVehicleClass, ROConstEdgePairVector > myClassesViaSuccessorMap
The successors with vias available for a given vClass.
Definition: ROEdge.h:578
ROEdge::myFollowingViaEdges
ROConstEdgePairVector myFollowingViaEdges
Definition: ROEdge.h:545
ROEdge::myAmSource
bool myAmSource
Definition: ROEdge.h:523
SumoXMLEdgeFunc
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
Definition: SUMOXMLDefinitions.h:1079
ROLane
A single lane the router may use.
Definition: ROLane.h:50
ROEdge::ROEdge
ROEdge(const std::string &id, RONode *from, RONode *to, int index, const int priority)
Constructor.
Definition: ROEdge.cpp:54
ROEdge::dictSize
static int dictSize()
Returns the number of edges.
Definition: ROEdge.h:462
RORoutable::getType
const SUMOVTypeParameter * getType() const
Returns the type of the routable.
Definition: RORoutable.h:84
ROVehicle
A vehicle as used by router.
Definition: ROVehicle.h:52
ROEdge::getLanes
const std::vector< ROLane * > & getLanes() const
Returns this edge's lanes.
Definition: ROEdge.h:491
ROConstEdgePairVector
std::vector< std::pair< const ROEdge *, const ROEdge * > > ROConstEdgePairVector
Definition: ROEdge.h:57
ROEdge::myPriority
const int myPriority
The edge priority (road class)
Definition: ROEdge.h:514
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:686
ROVehicle::getChosenSpeedFactor
double getChosenSpeedFactor() const
Returns an upper bound for the speed factor of this vehicle.
Definition: ROVehicle.h:111
ROEdge::setSource
void setSource(const bool isSource=true)
Sets whether the edge is a source.
Definition: ROEdge.h:122
ROEdge::getNoiseEffort
static double getNoiseEffort(const ROEdge *const edge, const ROVehicle *const veh, double time)
Definition: ROEdge.cpp:208
ROEdge::myFunction
SumoXMLEdgeFunc myFunction
The function of the edge.
Definition: ROEdge.h:551
ROEdge::setGlobalOptions
static void setGlobalOptions(const bool interpolate)
Definition: ROEdge.h:466
RORoutable::getVClass
SUMOVehicleClass getVClass() const
Definition: RORoutable.h:107
gWeightsRandomFactor
double gWeightsRandomFactor
Definition: StdDefs.cpp:30
ROEdge::getViaSuccessors
const ROConstEdgePairVector & getViaSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges including vias, restricted by vClass.
Definition: ROEdge.cpp:394
ROEdge::getEffort
double getEffort(const ROVehicle *const veh, double time) const
Returns the effort for this edge.
Definition: ROEdge.cpp:147
ROEdge::getPredecessors
const ROEdgeVector & getPredecessors() const
Returns the edge at the given position from the list of incoming edges.
Definition: ROEdge.h:355
ROEdge::myEdges
static ROEdgeVector myEdges
Definition: ROEdge.h:571
ROEdge::myCombinedPermissions
SVCPermissions myCombinedPermissions
The list of allowed vehicle classes combined across lanes.
Definition: ROEdge.h:560
RandHelper::rand
static double rand(std::mt19937 *rng=0)
Returns a random real number in [0, 1)
Definition: RandHelper.h:53
ROEdge::mySpeed
double mySpeed
The maximum speed allowed on this edge.
Definition: ROEdge.h:517
SUMO_ATTR_ACCEL
Definition: SUMOXMLDefinitions.h:445
ROEdge::addTravelTime
void addTravelTime(double value, double timeBegin, double timeEnd)
Adds a travel time value.
Definition: ROEdge.cpp:140
ROEdge::addSuccessor
virtual void addSuccessor(ROEdge *s, ROEdge *via=nullptr, std::string dir="")
Adds information about a connected edge.
Definition: ROEdge.cpp:104
SVCPermissions
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
Definition: SUMOVehicleClass.h:218
ROEdge::myIndex
const int myIndex
The index (numeric id) of the edge.
Definition: ROEdge.h:511
PollutantsInterface.h
ROEdge::getTravelTimeStaticRandomized
static double getTravelTimeStaticRandomized(const ROEdge *const edge, const ROVehicle *const veh, double time)
Definition: ROEdge.h:416
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:133
EDGEFUNC_WALKINGAREA
Definition: SUMOXMLDefinitions.h:1084
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:574
ROEdge::myTravelTimes
ValueTimeLine< double > myTravelTimes
Container storing passing time varying over time for the edge.
Definition: ROEdge.h:525
ROEdge::setRestrictions
void setRestrictions(const std::map< SUMOVehicleClass, double > *restrictions)
Sets the vehicle class specific speed limits of the edge.
Definition: ROEdge.h:138
ROEdge::getStoredEffort
bool getStoredEffort(double time, double &ret) const
Retrieves the stored effort.
Definition: ROEdge.cpp:219
SUMOVehicleClass.h
Boundary
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:41
ROEdge::setSink
void setSink(const bool isSink=true)
Sets whether the edge is a sink.
Definition: ROEdge.h:130
SUMOVTypeParameter::paramRestrictions
std::vector< double > paramRestrictions
cached value of parameters which may restrict access to certain edges
Definition: SUMOVTypeParameter.h:316
ROEdge::getLengthGeometryFactor
double getLengthGeometryFactor() const
return a lower bound on shape.length() / myLength that is
Definition: ROEdge.cpp:327
ROEdgeVector
std::vector< ROEdge * > ROEdgeVector
Definition: ROEdge.h:53
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:38
EDGEFUNC_CONNECTOR
Definition: SUMOXMLDefinitions.h:1082
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:458
SUMOVTypeParameter::maxSpeed
double maxSpeed
The vehicle type's maximum speed [m/s].
Definition: SUMOVTypeParameter.h:221
ROEdgeVector
std::vector< ROEdge * > ROEdgeVector
Definition: RODFRouteDesc.h:35
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:262
ROEdge::isTazConnector
bool isTazConnector() const
Definition: ROEdge.h:161
ROEdge::getNumericalID
int getNumericalID() const
Returns the index (numeric id) of the edge.
Definition: ROEdge.h:211
ROEdge::getFunction
SumoXMLEdgeFunc getFunction() const
Returns the function of the edge.
Definition: ROEdge.h:188
ROEdge::buildTimeLines
void buildTimeLines(const std::string &measure, const bool boundariesOverride)
Builds the internal representation of the travel time/effort.
Definition: ROEdge.cpp:284
ROEdge::myInterpolate
static bool myInterpolate
Information whether to interpolate at interval boundaries.
Definition: ROEdge.h:535
ROEdge::isSink
bool isSink() const
Returns whether the edge acts as a sink.
Definition: ROEdge.h:196
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:163
ROEdge::getNumSuccessors
int getNumSuccessors() const
Returns the number of edges this edge is connected to.
Definition: ROEdge.cpp:244
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:563
ROEdge::myApproachingEdges
ROEdgeVector myApproachingEdges
List of edges that approached this edge.
Definition: ROEdge.h:548
ROEdge::getFromJunction
const RONode * getFromJunction() const
Definition: ROEdge.h:478
ROEdge::myParamRestrictions
std::vector< double > myParamRestrictions
cached value of parameters which may restrict access
Definition: ROEdge.h:569
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:263
ROEdge::myLength
double myLength
The length of the edge.
Definition: ROEdge.h:520
ROEdge::getVClassMaxSpeed
double getVClassMaxSpeed(SUMOVehicleClass vclass) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
Definition: ROEdge.h:231
ROEdge::getLength
double getLength() const
Returns the length of the edge.
Definition: ROEdge.h:204
ROEdge::getNumPredecessors
int getNumPredecessors() const
Returns the number of edges connected to this edge.
Definition: ROEdge.cpp:253
ROEdge::~ROEdge
virtual ~ROEdge()
Destructor.
Definition: ROEdge.cpp:83
ROEdge::getEmissionEffort
static double getEmissionEffort(const ROEdge *const edge, const ROVehicle *const veh, double time)
Definition: ROEdge.h:438
ROEdge::myClassesSuccessorMap
std::map< SUMOVehicleClass, ROEdgeVector > myClassesSuccessorMap
The successors available for a given vClass.
Definition: ROEdge.h:575
ROEdge::addLane
virtual void addLane(ROLane *lane)
Adds a lane to the edge while loading.
Definition: ROEdge.cpp:91
ROEdge::hasLoadedTravelTime
bool hasLoadedTravelTime(double time) const
Returns whether a travel time for this edge was loaded.
Definition: ROEdge.cpp:177
ROEdge::getPermissions
SVCPermissions getPermissions() const
Definition: ROEdge.h:268
ROEdge
A basic edge for routing applications.
Definition: ROEdge.h:72
ROEdge::isWalkingArea
bool isWalkingArea() const
return whether this edge is walking area
Definition: ROEdge.h:157
ROEdge::myHaveTTWarned
static bool myHaveTTWarned
Information whether the edge has reported missing weights.
Definition: ROEdge.h:540
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:273
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:426
ROEdge::getSpeedLimit
double getSpeedLimit() const
Returns the speed allowed on this edge.
Definition: ROEdge.h:219
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:430
SUMOVTypeParameter::emissionClass
SUMOEmissionClass emissionClass
The emission class of this vehicle.
Definition: SUMOVTypeParameter.h:234
ValueTimeLine< double >
SVC_IGNORING
vehicles ignoring classes
Definition: SUMOVehicleClass.h:135
RONode
Base class for nodes used by the router.
Definition: RONode.h:45
SUMOVTypeParameter.h
ROEdge::setFunction
void setFunction(SumoXMLEdgeFunc func)
Sets the function of the edge.
Definition: ROEdge.h:114
ROEdge::getStopPosition
static const Position getStopPosition(const SUMOVehicleParameter::Stop &stop)
return the coordinates of the center of the given stop
Definition: ROEdge.cpp:350
SUMOVTypeParameter::vehicleClass
SUMOVehicleClass vehicleClass
The vehicle's class.
Definition: SUMOVTypeParameter.h:240
ROEdge::getDistanceTo
double getDistanceTo(const ROEdge *other, const bool doBoundaryEstimate=false) const
optimistic distance heuristic for use in routing
Definition: ROEdge.cpp:157
ROEdge::myTimePenalty
double myTimePenalty
flat penalty when computing traveltime
Definition: ROEdge.h:566
ROEdge::myUsingETimeLine
bool myUsingETimeLine
Information whether the time line shall be used instead of the length value.
Definition: ROEdge.h:532
ROEdge::cacheParamRestrictions
void cacheParamRestrictions(const std::vector< std::string > &restrictionKeys)
Definition: ROEdge.cpp:318
ROEdge::myFromJunction
RONode * myFromJunction
the junctions for this edge
Definition: ROEdge.h:507
ConstROEdgeVector
std::vector< const ROEdge * > ConstROEdgeVector
Definition: ROEdge.h:56
SUMOVehicleParameter::Stop
Definition of vehicle stop (position and duration)
Definition: SUMOVehicleParameter.h:572
ROEdge::myAmSink
bool myAmSink
whether the edge is a source or a sink
Definition: ROEdge.h:523
ROEdge::getToJunction
const RONode * getToJunction() const
Definition: ROEdge.h:482