Eclipse SUMO - Simulation of Urban MObility
MSStoppingPlace.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2005-2022 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials are made available under the
5 // terms of the Eclipse Public License 2.0 which is available at
6 // https://www.eclipse.org/legal/epl-2.0/
7 // This Source Code may also be made available under the following Secondary
8 // Licenses when the conditions for such availability set forth in the Eclipse
9 // Public License 2.0 are satisfied: GNU General Public License, version 2
10 // or later which is available at
11 // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 /****************************************************************************/
20 // A lane area vehicles can halt at
21 /****************************************************************************/
22 #pragma once
23 #include <config.h>
24 
25 #include <vector>
26 #include <algorithm>
27 #include <map>
28 #include <string>
29 #include <utils/common/Named.h>
31 #include <utils/common/RGBColor.h>
32 
33 
34 // ===========================================================================
35 // class declarations
36 // ===========================================================================
37 class MSLane;
38 class MSEdge;
39 class SUMOVehicle;
40 class MSTransportable;
41 class Position;
42 
43 
44 // ===========================================================================
45 // class definitions
46 // ===========================================================================
59 class MSStoppingPlace : public Named, public Parameterised {
60 public:
70  MSStoppingPlace(const std::string& id,
71  SumoXMLTag element,
72  const std::vector<std::string>& lines, MSLane& lane,
73  double begPos, double endPos,
74  const std::string name = "",
75  int capacity = 0,
76  double parkingLength = 0,
77  const RGBColor& color = RGBColor::INVISIBLE);
78 
79 
80 
82  virtual ~MSStoppingPlace();
83 
84 
89  const MSLane& getLane() const;
90 
91 
96  double getBeginLanePosition() const;
97 
98 
103  double getEndLanePosition() const;
104 
106  Position getCenterPos() const;
107 
119  void enter(SUMOVehicle* veh, bool parking);
120 
121 
131  void leaveFrom(SUMOVehicle* what);
132 
133 
140  double getLastFreePos(const SUMOVehicle& forVehicle, double brakePos = 0) const;
141 
143  bool fits(double pos, const SUMOVehicle& veh) const;
144 
150 
155  double getWaitingPositionOnLane(MSTransportable* t) const;
156 
157 
162  double getStoppingPosition(const SUMOVehicle* veh) const;
163 
167  return (int)myWaitingTransportables.size();
168  }
169 
172  std::vector<const MSTransportable*> getTransportables() const;
173 
177  return (int)myEndPositions.size();
178  }
179 
180  double getLastFreePos() const {
181  return myLastFreePos;
182  }
183 
185  bool hasSpaceForTransportable() const;
186 
188  bool addTransportable(const MSTransportable* p);
189 
191  void removeTransportable(const MSTransportable* p);
192 
194  virtual bool addAccess(MSLane* lane, const double pos, double length);
195 
197  const std::vector<std::tuple<MSLane*, double, double> >& getAllAccessPos() const {
198  return myAccessPos;
199  }
200 
202  double getAccessPos(const MSEdge* edge) const;
203 
205  double getAccessDistance(const MSEdge* edge) const;
206 
207  const std::string& getMyName() const;
208 
211  return myElement;
212  }
213 
214  const RGBColor& getColor() const;
215 
216  static int getTransportablesAbreast(double length, SumoXMLTag element);
217 
219  std::vector<const SUMOVehicle*> getStoppedVehicles() const;
220 
222  inline int getNumWaitingPersons() const {
223  return (int)myWaitingTransportables.size();
224  }
225 
227  inline int getWaitingCapacity() const {
229  }
230 
232  void getWaitingPersonIDs(std::vector<std::string>& into) const;
233 
235  void clearState();
236 
237 protected:
244  void computeLastFreePos();
245 
246  int getTransportablesAbreast() const;
247 
248 protected:
251 
253  std::vector<std::string> myLines;
254 
256  std::map<const SUMOVehicle*, std::pair<double, double>, ComparatorNumericalIdLess> myEndPositions;
257 
259  const MSLane& myLane;
260 
262  const double myBegPos;
263 
265  const double myEndPos;
266 
269 
271  const std::string myName;
272 
275 
277  const double myParkingFactor;
278 
281 
283  const double myTransportableDepth;
284 
285 protected:
286 
288  std::map<const MSTransportable*, int> myWaitingTransportables;
289  std::set<int> myWaitingSpots;
290 
292  std::vector<std::tuple<MSLane*, double, double> > myAccessPos;
293 
294 private:
297 
300 
301 
302 };
SumoXMLTag
Numbers representing SUMO-XML - element names.
A road/street connecting two junctions.
Definition: MSEdge.h:77
Representation of a lane in the micro simulation.
Definition: MSLane.h:82
A lane area vehicles can halt at.
std::vector< const SUMOVehicle * > getStoppedVehicles() const
get list of vehicles waiting at this stop
int getStoppedVehicleNumber() const
Returns the number of stopped vehicles waiting on this stop.
const SumoXMLTag myElement
the type of stopping place
double getWaitingPositionOnLane(MSTransportable *t) const
Returns the lane position corresponding to getWaitPosition()
std::map< const MSTransportable *, int > myWaitingTransportables
Persons waiting at this stop (mapped to waiting position)
const double myBegPos
The begin position this bus stop is located at.
double getBeginLanePosition() const
Returns the begin position of this stop.
int getNumWaitingPersons() const
get number of persons waiting at this stop
const MSLane & myLane
The lane this bus stop is located at.
bool hasSpaceForTransportable() const
whether there is still capacity for more transportables
std::map< const SUMOVehicle *, std::pair< double, double >, ComparatorNumericalIdLess > myEndPositions
A map from objects (vehicles) to the areas they acquire after entering the stop.
int getTransportablesAbreast() const
std::vector< const MSTransportable * > getTransportables() const
Returns the tranportables waiting on this stop.
void clearState()
Remove all vehicles before quick-loading state.
int getTransportableNumber() const
Returns the number of transportables waiting on this stop.
const std::vector< std::tuple< MSLane *, double, double > > & getAllAccessPos() const
lanes and positions connected to this stop
std::set< int > myWaitingSpots
const double myParkingFactor
the scaled space capacity for parking vehicles
Position getCenterPos() const
the position in the middle of the stop shape
bool fits(double pos, const SUMOVehicle &veh) const
return whether the given vehicle fits at the given position
MSStoppingPlace(const MSStoppingPlace &)
Invalidated copy constructor.
const std::string myName
The name of the stopping place.
int getWaitingCapacity() const
get number of persons that can wait at this stop
double getAccessDistance(const MSEdge *edge) const
the distance from the access on the given edge to the stop, -1 on failure
MSStoppingPlace(const std::string &id, SumoXMLTag element, const std::vector< std::string > &lines, MSLane &lane, double begPos, double endPos, const std::string name="", int capacity=0, double parkingLength=0, const RGBColor &color=RGBColor::INVISIBLE)
Constructor.
SumoXMLTag getElement() const
return the type of this stopping place
const double myEndPos
The end position this bus stop is located at.
double getEndLanePosition() const
Returns the end position of this stop.
const RGBColor myColor
The color of the stopping place.
std::vector< std::tuple< MSLane *, double, double > > myAccessPos
lanes and positions connected to this stop
std::vector< std::string > myLines
The list of lines that are assigned to this stop.
void enter(SUMOVehicle *veh, bool parking)
Called if a vehicle enters this stop.
double getStoppingPosition(const SUMOVehicle *veh) const
For vehicles at the stop this gives the the actual stopping position of the vehicle....
void removeTransportable(const MSTransportable *p)
Removes a transportable from this stop.
virtual ~MSStoppingPlace()
Destructor.
void computeLastFreePos()
Computes the last free position on this stop.
virtual bool addAccess(MSLane *lane, const double pos, double length)
adds an access point to this stop
const RGBColor & getColor() const
void getWaitingPersonIDs(std::vector< std::string > &into) const
get IDs of persons waiting at this stop
const MSLane & getLane() const
Returns the lane this stop is located at.
const int myTransportableCapacity
The number of transportables that can wait here.
const std::string & getMyName() const
Position getWaitPosition(MSTransportable *person) const
Returns the next free waiting place for pedestrians / containers.
MSStoppingPlace & operator=(const MSStoppingPlace &)
Invalidated assignment operator.
bool addTransportable(const MSTransportable *p)
adds a transportable to this stop
double myLastFreePos
The last free position at this stop (variable)
double getLastFreePos() const
double getAccessPos(const MSEdge *edge) const
the position on the given edge which is connected to this stop, -1 on failure
const double myTransportableDepth
row depth of waiting transportables
void leaveFrom(SUMOVehicle *what)
Called if a vehicle leaves this stop.
Base class for objects which have an id.
Definition: Named.h:54
An upper class for objects with additional parameters.
Definition: Parameterised.h:41
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
static const RGBColor INVISIBLE
Definition: RGBColor.h:195
Representation of a vehicle.
Definition: SUMOVehicle.h:60
Function-object for stable sorting of objects with numerical ids.
Definition: Named.h:39