Eclipse SUMO - Simulation of Urban MObility
ROPerson.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 /****************************************************************************/
15 // A person as used by router
16 /****************************************************************************/
17 #ifndef ROPerson_h
18 #define ROPerson_h
19 
20 // ===========================================================================
21 // included modules
22 // ===========================================================================
23 #include <config.h>
24 
25 #include <string>
26 #include <iostream>
27 #include <utils/common/StdDefs.h>
28 #include <utils/common/SUMOTime.h>
31 #include "RORoutable.h"
32 #include "RORouteDef.h"
33 #include "ROVehicle.h"
34 
35 
36 // ===========================================================================
37 // class declarations
38 // ===========================================================================
39 class OutputDevice;
40 class ROEdge;
41 
42 
43 // ===========================================================================
44 // class definitions
45 // ===========================================================================
50 class ROPerson : public RORoutable {
51 
52 public:
58  ROPerson(const SUMOVehicleParameter& pars, const SUMOVTypeParameter* type);
59 
61  virtual ~ROPerson();
62 
63  void addTrip(const ROEdge* const from, const ROEdge* const to, const SVCPermissions modeSet,
64  const std::string& vTypes, const double departPos, const double arrivalPos, const std::string& busStop,
65  double walkFactor);
66 
67  void addRide(const ROEdge* const from, const ROEdge* const to, const std::string& lines, double arrivalPos, const std::string& destStop);
68 
69  void addWalk(const ConstROEdgeVector& edges, const double duration, const double speed,
70  const double departPos, const double arrivalPos, const std::string& busStop);
71 
72  void addStop(const SUMOVehicleParameter::Stop& stopPar, const ROEdge* const stopEdge);
73 
74  class TripItem;
79  class PlanItem {
80  public:
82  virtual ~PlanItem() {}
83 
84  virtual PlanItem* clone() const = 0;
85 
86  virtual void addTripItem(TripItem* /* tripIt */) {
87  throw ProcessError();
88  }
89  virtual const ROEdge* getOrigin() const = 0;
90  virtual const ROEdge* getDestination() const = 0;
91  virtual double getDestinationPos() const = 0;
92  virtual void saveVehicles(OutputDevice& /* os */, OutputDevice* const /* typeos */, bool /* asAlternatives */, OptionsCont& /* options */) const {}
93  virtual void saveAsXML(OutputDevice& os, const bool extended, const bool asTrip, const bool writeGeoTrip) const = 0;
94  virtual bool isStop() const {
95  return false;
96  }
97  virtual bool needsRouting() const {
98  return false;
99  }
100 
101  virtual SUMOTime getDuration() const = 0;
102  };
103 
108  class Stop : public PlanItem {
109  public:
110  Stop(const SUMOVehicleParameter::Stop& stop, const ROEdge* const stopEdge)
111  : stopDesc(stop), edge(stopEdge) {}
112 
113  PlanItem* clone() const {
114  return new Stop(stopDesc, edge);
115  }
116 
117  const ROEdge* getOrigin() const {
118  return edge;
119  }
120  const ROEdge* getDestination() const {
121  return edge;
122  }
123  double getDestinationPos() const {
124  return (stopDesc.startPos + stopDesc.endPos) / 2;
125  }
126  void saveAsXML(OutputDevice& os, const bool /* extended */, const bool /*asTrip*/, const bool /*writeGeoTrip*/) const {
127  stopDesc.write(os);
128  }
129  bool isStop() const {
130  return true;
131  }
133  return stopDesc.duration;
134  }
135 
136  private:
138  const ROEdge* const edge;
139 
140  private:
142  Stop& operator=(const Stop& src);
143 
144  };
145 
150  class TripItem {
151  public:
152  TripItem(const double _cost)
153  : cost(_cost) {}
154 
156  virtual ~TripItem() {}
157 
158  virtual TripItem* clone() const = 0;
159 
160  virtual const ROEdge* getOrigin() const = 0;
161  virtual const ROEdge* getDestination() const = 0;
162  virtual double getDestinationPos() const = 0;
163  virtual void saveAsXML(OutputDevice& os, const bool extended) const = 0;
165  return TIME2STEPS(cost);
166  }
167  protected:
168  double cost;
169  };
170 
175  class Ride : public TripItem {
176  public:
177  Ride(const ROEdge* const _from, const ROEdge* const _to,
178  const std::string& _lines, const double _cost, const double arrivalPos,
179  const std::string& _destStop = "", const std::string& _intended = "", const SUMOTime _depart = -1) :
180  TripItem(_cost),
181  from(_from), to(_to),
182  lines(_lines),
183  destStop(_destStop),
184  intended(_intended),
185  depart(_depart),
186  arr(arrivalPos) {
187  }
188 
189  TripItem* clone() const {
190  return new Ride(from, to, lines, cost, arr, destStop, intended, depart);
191  }
192 
193  const ROEdge* getOrigin() const {
194  return from;
195  }
196  const ROEdge* getDestination() const {
197  return to;
198  }
199  double getDestinationPos() const {
200  return arr;
201  }
202  void saveAsXML(OutputDevice& os, const bool extended) const;
203 
204  private:
205  const ROEdge* const from;
206  const ROEdge* const to;
207  const std::string lines;
208  const std::string destStop;
209  const std::string intended;
211  const double arr;
212 
213  private:
215  Ride& operator=(const Ride& src);
216 
217  };
218 
223  class Walk : public TripItem {
224  public:
225  Walk(const ConstROEdgeVector& _edges, const double _cost,
226  double departPos = std::numeric_limits<double>::infinity(),
227  double arrivalPos = std::numeric_limits<double>::infinity(),
228  const std::string& _destStop = "")
229  : TripItem(_cost), edges(_edges), dur(-1), v(-1), dep(departPos), arr(arrivalPos), destStop(_destStop) {}
230  Walk(const ConstROEdgeVector& edges, const double _cost, const double duration, const double speed,
231  const double departPos, const double arrivalPos, const std::string& _destStop)
232  : TripItem(_cost), edges(edges), dur(duration), v(speed), dep(departPos), arr(arrivalPos), destStop(_destStop) {}
233 
234  TripItem* clone() const {
235  return new Walk(edges, cost, dep, arr, destStop);
236  }
237 
238  const ROEdge* getOrigin() const {
239  return edges.front();
240  }
241  const ROEdge* getDestination() const {
242  return edges.back();
243  }
244  double getDestinationPos() const {
245  return arr;
246  }
247  void saveAsXML(OutputDevice& os, const bool extended) const;
248 
249  private:
251  const double dur, v, dep, arr;
252  const std::string destStop;
253 
254  private:
256  Walk& operator=(const Walk& src);
257 
258  };
259 
264  class PersonTrip : public PlanItem {
265  public:
267  : from(0), to(0), modes(SVC_PEDESTRIAN), dep(0), arr(0), stopDest(""), walkFactor(1.0) {}
268  PersonTrip(const ROEdge* const from, const ROEdge* const to, const SVCPermissions modeSet,
269  const double departPos, const double arrivalPos, const std::string& _stopDest, double _walkFactor)
270  : from(from), to(to), modes(modeSet), dep(departPos), arr(arrivalPos), stopDest(_stopDest), walkFactor(_walkFactor) {}
272  virtual ~PersonTrip() {
273  for (std::vector<TripItem*>::const_iterator it = myTripItems.begin(); it != myTripItems.end(); ++it) {
274  delete *it;
275  }
276  for (std::vector<ROVehicle*>::const_iterator it = myVehicles.begin(); it != myVehicles.end(); ++it) {
277  delete (*it)->getRouteDefinition();
278  delete *it;
279  }
280  }
281 
282  PlanItem* clone() const;
283 
284  virtual void addTripItem(TripItem* tripIt) {
285  myTripItems.push_back(tripIt);
286  }
287  void addVehicle(ROVehicle* veh) {
288  myVehicles.push_back(veh);
289  }
290  std::vector<ROVehicle*>& getVehicles() {
291  return myVehicles;
292  }
293  const ROEdge* getOrigin() const {
294  return from != 0 ? from : myTripItems.front()->getOrigin();
295  }
296  const ROEdge* getDestination() const {
297  return to;
298  }
299  double getDestinationPos() const {
300  if (myTripItems.empty()) {
301  return getArrivalPos(true);
302  } else {
303  return myTripItems.back()->getDestinationPos();
304  }
305  }
306  double getDepartPos(bool replaceDefault = true) const {
307  return dep == std::numeric_limits<double>::infinity() && replaceDefault ? 0 : dep;
308  }
309  double getArrivalPos(bool replaceDefault = true) const {
310  return arr == std::numeric_limits<double>::infinity() && replaceDefault ? -POSITION_EPS : arr;
311  }
313  return modes;
314  }
315  const std::string& getStopDest() const {
316  return stopDest;
317  }
318  virtual bool needsRouting() const {
319  return myTripItems.empty();
320  }
321  void saveVehicles(OutputDevice& os, OutputDevice* const typeos, bool asAlternatives, OptionsCont& options) const;
322  void saveAsXML(OutputDevice& os, const bool extended, const bool asTrip, const bool writeGeoTrip) const;
323 
324  double getWalkFactor() const {
325  return walkFactor;
326  }
327 
329  SUMOTime getDuration() const;
330 
331  private:
332  const ROEdge* from;
333  const ROEdge* to;
335  const double dep, arr;
336  const std::string stopDest;
338  std::vector<TripItem*> myTripItems;
340  std::vector<ROVehicle*> myVehicles;
342  double walkFactor;
343 
344  private:
346  PersonTrip& operator=(const PersonTrip& src);
347 
348  };
349 
350 
355  const ROEdge* getDepartEdge() const {
356  return myPlan.front()->getOrigin();
357  }
358 
359 
360  void computeRoute(const RORouterProvider& provider,
361  const bool removeLoops, MsgHandler* errorHandler);
362 
363 
374  void saveAsXML(OutputDevice& os, OutputDevice* const typeos, bool asAlternatives, OptionsCont& options) const;
375 
376  std::vector<PlanItem*>& getPlan() {
377  return myPlan;
378  }
379 
380 private:
381  bool computeIntermodal(SUMOTime time, const RORouterProvider& provider,
382  PersonTrip* const trip, const ROVehicle* const veh, MsgHandler* const errorHandler);
383 
384 private:
388  std::vector<PlanItem*> myPlan;
389 
390 
391 private:
393  ROPerson(const ROPerson& src);
394 
396  ROPerson& operator=(const ROPerson& src);
397 
398 };
399 
400 #endif
401 
402 /****************************************************************************/
403 
ROPerson::PersonTrip::saveAsXML
void saveAsXML(OutputDevice &os, const bool extended, const bool asTrip, const bool writeGeoTrip) const
Definition: ROPerson.cpp:198
ROPerson::Ride::lines
const std::string lines
Definition: ROPerson.h:207
SVC_PEDESTRIAN
pedestrian
Definition: SUMOVehicleClass.h:156
ROPerson::Ride::intended
const std::string intended
Definition: ROPerson.h:209
ROPerson::PersonTrip::addVehicle
void addVehicle(ROVehicle *veh)
Definition: ROPerson.h:287
SUMOTime.h
ROPerson::Stop::stopDesc
SUMOVehicleParameter::Stop stopDesc
Definition: ROPerson.h:137
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:63
ROPerson::PersonTrip::saveVehicles
void saveVehicles(OutputDevice &os, OutputDevice *const typeos, bool asAlternatives, OptionsCont &options) const
Definition: ROPerson.cpp:191
ROPerson::Ride
A ride is part of a trip, e.g., go from here to here by car or bus.
Definition: ROPerson.h:175
ROPerson::PlanItem::~PlanItem
virtual ~PlanItem()
Destructor.
Definition: ROPerson.h:82
ROPerson::PlanItem::isStop
virtual bool isStop() const
Definition: ROPerson.h:94
ROPerson::Ride::arr
const double arr
Definition: ROPerson.h:211
SUMOTime
long long int SUMOTime
Definition: SUMOTime.h:34
ROPerson::saveAsXML
void saveAsXML(OutputDevice &os, OutputDevice *const typeos, bool asAlternatives, OptionsCont &options) const
Saves the complete person description.
Definition: ROPerson.cpp:330
ROPerson::TripItem::saveAsXML
virtual void saveAsXML(OutputDevice &os, const bool extended) const =0
ROPerson
A person as used by router.
Definition: ROPerson.h:50
ROPerson::PlanItem::clone
virtual PlanItem * clone() const =0
ROPerson::Walk::dur
const double dur
Definition: ROPerson.h:251
ROVehicle
A vehicle as used by router.
Definition: ROVehicle.h:52
ROPerson::TripItem::~TripItem
virtual ~TripItem()
Destructor.
Definition: ROPerson.h:156
RORoutable.h
SUMOVehicleParameter
Structure representing possible vehicle parameter.
Definition: SUMOVehicleParameter.h:297
ROVehicle.h
RORouteDef.h
ROPerson::TripItem::getDuration
SUMOTime getDuration() const
Definition: ROPerson.h:164
ROPerson::PersonTrip::myVehicles
std::vector< ROVehicle * > myVehicles
the vehicles which may be used for routing
Definition: ROPerson.h:340
ROPerson::Ride::clone
TripItem * clone() const
Definition: ROPerson.h:189
SUMOVehicleParameter.h
ROPerson::PersonTrip::modes
const SVCPermissions modes
Definition: ROPerson.h:334
ROPerson::PlanItem::getDestination
virtual const ROEdge * getDestination() const =0
ROPerson::Walk::Walk
Walk(const ConstROEdgeVector &edges, const double _cost, const double duration, const double speed, const double departPos, const double arrivalPos, const std::string &_destStop)
Definition: ROPerson.h:230
ROPerson::PersonTrip::stopDest
const std::string stopDest
Definition: ROPerson.h:336
ROPerson::Walk::getOrigin
const ROEdge * getOrigin() const
Definition: ROPerson.h:238
ROPerson::Walk::clone
TripItem * clone() const
Definition: ROPerson.h:234
ROPerson::Walk
A walk is part of a trip, e.g., go from here to here by foot.
Definition: ROPerson.h:223
ROPerson::Walk::getDestinationPos
double getDestinationPos() const
Definition: ROPerson.h:244
ROPerson::Ride::depart
const SUMOTime depart
Definition: ROPerson.h:210
ROPerson::Walk::v
const double v
Definition: ROPerson.h:251
ROPerson::Ride::from
const ROEdge *const from
Definition: ROPerson.h:205
MsgHandler
Definition: MsgHandler.h:38
ROPerson::Walk::saveAsXML
void saveAsXML(OutputDevice &os, const bool extended) const
Definition: ROPerson.cpp:155
SVCPermissions
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
Definition: SUMOVehicleClass.h:218
ROPerson::PlanItem
Every person has a plan comprising of multiple planItems.
Definition: ROPerson.h:79
TIME2STEPS
#define TIME2STEPS(x)
Definition: SUMOTime.h:58
ROPerson::Ride::to
const ROEdge *const to
Definition: ROPerson.h:206
ROPerson::Ride::getDestinationPos
double getDestinationPos() const
Definition: ROPerson.h:199
ROPerson::PersonTrip::PersonTrip
PersonTrip(const ROEdge *const from, const ROEdge *const to, const SVCPermissions modeSet, const double departPos, const double arrivalPos, const std::string &_stopDest, double _walkFactor)
Definition: ROPerson.h:268
SUMOVTypeParameter
Structure representing possible vehicle parameter.
Definition: SUMOVTypeParameter.h:86
ROPerson::Ride::Ride
Ride(const ROEdge *const _from, const ROEdge *const _to, const std::string &_lines, const double _cost, const double arrivalPos, const std::string &_destStop="", const std::string &_intended="", const SUMOTime _depart=-1)
Definition: ROPerson.h:177
ROPerson::addStop
void addStop(const SUMOVehicleParameter::Stop &stopPar, const ROEdge *const stopEdge)
Definition: ROPerson.cpp:118
ROPerson::Walk::arr
const double arr
Definition: ROPerson.h:251
ROPerson::PlanItem::needsRouting
virtual bool needsRouting() const
Definition: ROPerson.h:97
ROPerson::TripItem::getOrigin
virtual const ROEdge * getOrigin() const =0
ROPerson::PersonTrip
A planItem can be a Trip which contains multiple tripItems.
Definition: ROPerson.h:264
ROPerson::Stop::operator=
Stop & operator=(const Stop &src)
Invalidated assignment operator.
ROPerson::operator=
ROPerson & operator=(const ROPerson &src)
Invalidated assignment operator.
ROPerson::addTrip
void addTrip(const ROEdge *const from, const ROEdge *const to, const SVCPermissions modeSet, const std::string &vTypes, const double departPos, const double arrivalPos, const std::string &busStop, double walkFactor)
Definition: ROPerson.cpp:61
ROPerson::Ride::getOrigin
const ROEdge * getOrigin() const
Definition: ROPerson.h:193
ROPerson::PersonTrip::getDepartPos
double getDepartPos(bool replaceDefault=true) const
Definition: ROPerson.h:306
ProcessError
Definition: UtilExceptions.h:39
ROPerson::Walk::getDestination
const ROEdge * getDestination() const
Definition: ROPerson.h:241
ROPerson::Stop
A planItem can be a Stop.
Definition: ROPerson.h:108
ROPerson::PlanItem::getDestinationPos
virtual double getDestinationPos() const =0
ROPerson::Stop::getDuration
SUMOTime getDuration() const
Definition: ROPerson.h:132
ROPerson::PersonTrip::getDuration
SUMOTime getDuration() const
return duration sum of all trip items
Definition: ROPerson.cpp:263
ROPerson::PersonTrip::getVehicles
std::vector< ROVehicle * > & getVehicles()
Definition: ROPerson.h:290
ROPerson::getPlan
std::vector< PlanItem * > & getPlan()
Definition: ROPerson.h:376
ROPerson::TripItem::getDestinationPos
virtual double getDestinationPos() const =0
ROPerson::computeRoute
void computeRoute(const RORouterProvider &provider, const bool removeLoops, MsgHandler *errorHandler)
Definition: ROPerson.cpp:304
SUMOVehicleParameter::Stop::write
void write(OutputDevice &dev) const
Writes the stop as XML.
Definition: SUMOVehicleParameter.cpp:175
OptionsCont
A storage for options typed value containers)
Definition: OptionsCont.h:89
ROPerson::PersonTrip::walkFactor
double walkFactor
walking speed factor
Definition: ROPerson.h:342
SUMOVehicleParameter::Stop::endPos
double endPos
The stopping position end.
Definition: SUMOVehicleParameter.h:604
ROPerson::Stop::getOrigin
const ROEdge * getOrigin() const
Definition: ROPerson.h:117
ROPerson::PersonTrip::myTripItems
std::vector< TripItem * > myTripItems
the fully specified trips
Definition: ROPerson.h:338
ROPerson::Stop::getDestination
const ROEdge * getDestination() const
Definition: ROPerson.h:120
RouterProvider
Definition: RouterProvider.h:37
ROPerson::Walk::edges
const ConstROEdgeVector edges
Definition: ROPerson.h:250
ROPerson::TripItem::cost
double cost
Definition: ROPerson.h:168
ROPerson::addWalk
void addWalk(const ConstROEdgeVector &edges, const double duration, const double speed, const double departPos, const double arrivalPos, const std::string &busStop)
Definition: ROPerson.cpp:109
ROPerson::TripItem::clone
virtual TripItem * clone() const =0
ROPerson::myPlan
std::vector< PlanItem * > myPlan
The plan of the person.
Definition: ROPerson.h:388
ROPerson::Stop::clone
PlanItem * clone() const
Definition: ROPerson.h:113
SUMOVehicleParameter::Stop::startPos
double startPos
The stopping position start.
Definition: SUMOVehicleParameter.h:601
RORoutable
A routable thing such as a vehicle or person.
Definition: RORoutable.h:54
ROPerson::PersonTrip::from
const ROEdge * from
Definition: ROPerson.h:332
ROPerson::PersonTrip::~PersonTrip
virtual ~PersonTrip()
Destructor.
Definition: ROPerson.h:272
ROPerson::~ROPerson
virtual ~ROPerson()
Destructor.
Definition: ROPerson.cpp:53
ROPerson::Walk::operator=
Walk & operator=(const Walk &src)
Invalidated assignment operator.
ROPerson::Stop::edge
const ROEdge *const edge
Definition: ROPerson.h:138
ROPerson::ROPerson
ROPerson(const SUMOVehicleParameter &pars, const SUMOVTypeParameter *type)
Constructor.
Definition: ROPerson.cpp:48
ROPerson::Ride::getDestination
const ROEdge * getDestination() const
Definition: ROPerson.h:196
ROPerson::PersonTrip::getStopDest
const std::string & getStopDest() const
Definition: ROPerson.h:315
ROPerson::getDepartEdge
const ROEdge * getDepartEdge() const
Returns the first edge the person takes.
Definition: ROPerson.h:355
ROPerson::Stop::Stop
Stop(const SUMOVehicleParameter::Stop &stop, const ROEdge *const stopEdge)
Definition: ROPerson.h:110
ROPerson::Stop::saveAsXML
void saveAsXML(OutputDevice &os, const bool, const bool, const bool) const
Definition: ROPerson.h:126
ROPerson::addRide
void addRide(const ROEdge *const from, const ROEdge *const to, const std::string &lines, double arrivalPos, const std::string &destStop)
Definition: ROPerson.cpp:100
ROPerson::Ride::operator=
Ride & operator=(const Ride &src)
Invalidated assignment operator.
ROEdge
A basic edge for routing applications.
Definition: ROEdge.h:72
ROPerson::Walk::destStop
const std::string destStop
Definition: ROPerson.h:252
ROPerson::PlanItem::addTripItem
virtual void addTripItem(TripItem *)
Definition: ROPerson.h:86
ROPerson::PersonTrip::getDestinationPos
double getDestinationPos() const
Definition: ROPerson.h:299
ROPerson::PersonTrip::needsRouting
virtual bool needsRouting() const
Definition: ROPerson.h:318
config.h
ROPerson::Walk::Walk
Walk(const ConstROEdgeVector &_edges, const double _cost, double departPos=std::numeric_limits< double >::infinity(), double arrivalPos=std::numeric_limits< double >::infinity(), const std::string &_destStop="")
Definition: ROPerson.h:225
StdDefs.h
ROPerson::Ride::saveAsXML
void saveAsXML(OutputDevice &os, const bool extended) const
Definition: ROPerson.cpp:124
ROPerson::computeIntermodal
bool computeIntermodal(SUMOTime time, const RORouterProvider &provider, PersonTrip *const trip, const ROVehicle *const veh, MsgHandler *const errorHandler)
Definition: ROPerson.cpp:272
ROPerson::PersonTrip::getOrigin
const ROEdge * getOrigin() const
Definition: ROPerson.h:293
ROPerson::TripItem
A TripItem is part of a trip, e.g., go from here to here by car.
Definition: ROPerson.h:150
ROPerson::PersonTrip::clone
PlanItem * clone() const
Definition: ROPerson.cpp:182
ROPerson::PersonTrip::getDestination
const ROEdge * getDestination() const
Definition: ROPerson.h:296
ROPerson::TripItem::TripItem
TripItem(const double _cost)
Definition: ROPerson.h:152
SUMOVehicleParameter::Stop::duration
SUMOTime duration
The stopping duration.
Definition: SUMOVehicleParameter.h:607
ROPerson::PersonTrip::getWalkFactor
double getWalkFactor() const
Definition: ROPerson.h:324
ROPerson::PlanItem::saveAsXML
virtual void saveAsXML(OutputDevice &os, const bool extended, const bool asTrip, const bool writeGeoTrip) const =0
ROPerson::PersonTrip::getModes
SVCPermissions getModes() const
Definition: ROPerson.h:312
ROPerson::PersonTrip::to
const ROEdge * to
Definition: ROPerson.h:333
SUMOVTypeParameter.h
ROPerson::PersonTrip::addTripItem
virtual void addTripItem(TripItem *tripIt)
Definition: ROPerson.h:284
POSITION_EPS
#define POSITION_EPS
Definition: config.h:172
ROPerson::PersonTrip::operator=
PersonTrip & operator=(const PersonTrip &src)
Invalidated assignment operator.
ROPerson::Ride::destStop
const std::string destStop
Definition: ROPerson.h:208
ROPerson::PersonTrip::getArrivalPos
double getArrivalPos(bool replaceDefault=true) const
Definition: ROPerson.h:309
ROPerson::Stop::isStop
bool isStop() const
Definition: ROPerson.h:129
ROPerson::PersonTrip::PersonTrip
PersonTrip()
Definition: ROPerson.h:266
ROPerson::Walk::dep
const double dep
Definition: ROPerson.h:251
ROPerson::TripItem::getDestination
virtual const ROEdge * getDestination() const =0
ROPerson::PersonTrip::arr
const double arr
Definition: ROPerson.h:335
ConstROEdgeVector
std::vector< const ROEdge * > ConstROEdgeVector
Definition: ROEdge.h:56
SUMOVehicleParameter::Stop
Definition of vehicle stop (position and duration)
Definition: SUMOVehicleParameter.h:572
ROPerson::PlanItem::saveVehicles
virtual void saveVehicles(OutputDevice &, OutputDevice *const, bool, OptionsCont &) const
Definition: ROPerson.h:92
ROPerson::PlanItem::getDuration
virtual SUMOTime getDuration() const =0
ROPerson::PersonTrip::dep
const double dep
Definition: ROPerson.h:335
ROPerson::PlanItem::getOrigin
virtual const ROEdge * getOrigin() const =0
ROPerson::Stop::getDestinationPos
double getDestinationPos() const
Definition: ROPerson.h:123