Eclipse SUMO - Simulation of Urban MObility
NBPTStop.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-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/****************************************************************************/
18// The representation of a single pt stop
19/****************************************************************************/
20#include <config.h>
21
24#include "NBPTStop.h"
25#include "NBEdge.h"
26#include "NBEdgeCont.h"
27
28
29// ===========================================================================
30// method definitions
31// ===========================================================================
32NBPTStop::NBPTStop(std::string ptStopId, Position position, std::string edgeId, std::string origEdgeId, double length,
33 std::string name, SVCPermissions svcPermissions, double parkingLength, const RGBColor color, double givenStartPos) :
34 myPTStopId(ptStopId),
35 myPosition(position),
36 myEdgeId(edgeId),
37 myOrigEdgeId(origEdgeId),
38 myPTStopLength(length),
39 myName(name),
40 myParkingLength(parkingLength),
41 myColor(color),
42 myPermissions(svcPermissions),
43 myStartPos(0),
44 myEndPos(0),
45 myBidiStop(nullptr),
46 myIsLoose(origEdgeId == ""),
47 myIsPlatform(false),
48 myIsMultipleStopPositions(false),
49 myAreaID(-1),
50 myGivenStartPos(givenStartPos) {
51}
52
53
54std::string
56 return myPTStopId;
57}
58
59
60const std::string
62 return myOrigEdgeId;
63}
64
65
66const std::string&
68 return myEdgeId;
69}
70
71
72const std::string
74 return myName;
75}
76
77
78const Position&
80 return myPosition;
81}
82
83
84void
86 myPosition.mul(1, -1);
87}
88
89
90void
91NBPTStop::addLine(const std::string& line) {
92 const std::string l = StringUtils::escapeXML(line);
93 if (std::find(myLines.begin(), myLines.end(), l) == myLines.end()) {
94 myLines.push_back(l);
95 }
96}
97
98
99void
103 if (!myName.empty()) {
105 }
109 device.writeAttr(SUMO_ATTR_FRIENDLY_POS, "true");
110 if (myLines.size() > 0) {
112 }
113 if (myParkingLength > 0) {
115 }
116 if (myColor.isValid()) {
118 }
119 if (!myAccesses.empty()) {
120 std::sort(myAccesses.begin(), myAccesses.end());
121 for (auto tuple : myAccesses) {
122 device.openTag(SUMO_TAG_ACCESS);
123 device.writeAttr(SUMO_ATTR_LANE, std::get<0>(tuple));
124 device.writeAttr(SUMO_ATTR_POSITION, std::get<1>(tuple));
125 device.writeAttr(SUMO_ATTR_LENGTH, std::get<2>(tuple));
126 device.writeAttr(SUMO_ATTR_FRIENDLY_POS, true);
127 device.closeTag();
128 }
129 }
130 writeParams(device);
131 device.closeTag();
132}
133
134
135void
136NBPTStop::reshiftPosition(const double offsetX, const double offsetY) {
137 myPosition.add(offsetX, offsetY, 0);
138 for (NBPTPlatform& platformCand : myPlatformCands) {
139 platformCand.reshiftPosition(offsetX, offsetY);
140 }
141}
142
143
146 return myPermissions;
147}
148
149
150void
152 myPlatformCands.push_back(platform);
153}
154
155
156const std::vector<NBPTPlatform>&
158 return myPlatformCands;
159}
160
161
162bool
165}
166
167
168void
169NBPTStop::setIsMultipleStopPositions(bool multipleStopPositions, long long int areaID) {
170 myIsMultipleStopPositions = multipleStopPositions;
171 myAreaID = areaID;
172}
173
174
175double
177 return myPTStopLength;
178}
179
180
181bool
182NBPTStop::setEdgeId(std::string edgeId, const NBEdgeCont& ec) {
183 myEdgeId = edgeId;
185}
186
187
188void
189NBPTStop::registerAdditionalEdge(std::string wayId, std::string edgeId) {
190 myAdditionalEdgeCandidates[wayId] = edgeId;
191}
192
193
194bool
196 NBEdge* edge = ec.getByID(myEdgeId);
198}
199
200
201bool
203 if (edge != nullptr) {
204 myEdgeId = edge->getID();
205 int laneNr = -1;
206 for (const auto& it : edge->getLanes()) {
207 if ((it.permissions & getPermissions()) == getPermissions()) {
208 ++laneNr;
209 break;
210 }
211 laneNr++;
212 }
213 if (laneNr != -1) {
214 myLaneId = edge->getLaneID(laneNr);
215 const PositionVector& shape = edge->getLaneShape(laneNr);
216 double offset = shape.nearest_offset_to_point2D(getPosition(), false);
217 const double edgeLength = edge->getFinalLength();
218 offset *= edgeLength / shape.length2D();
219 if (myGivenStartPos >= 0) {
222 } else {
223 myStartPos = MAX2(0.0, offset - myPTStopLength / 2.);
224 myEndPos = MIN2(myStartPos + myPTStopLength, edgeLength);
225 double missing = myPTStopLength - (myEndPos - myStartPos);
226 if (missing > 0) {
227 myStartPos = MAX2(0.0, myStartPos - missing);
228 }
229 }
230 return true;
231 }
232 }
233 return myEdgeId == ""; // loose stop. Try later when processing lines
234}
235
236
237void
239 myAccesses.clear();
240}
241
242
243void
244NBPTStop::addAccess(std::string laneID, double offset, double length) {
245 const std::string newEdgeID = SUMOXMLDefinitions::getEdgeIDFromLane(laneID);
246 // avoid duplicate access
247 for (auto it = myAccesses.begin(); it != myAccesses.end();) {
248 if (SUMOXMLDefinitions::getEdgeIDFromLane(std::get<0>(*it)) == newEdgeID) {
249 it = myAccesses.erase(it);
250 } else {
251 it++;
252 }
253 }
254 myAccesses.push_back(std::make_tuple(laneID, offset, length));
255}
256
257
258bool
259NBPTStop::replaceEdge(const std::string& edgeID, const EdgeVector& replacement) {
260 if (myEdgeId == edgeID) {
261 // find best edge among replacement edges
262 double bestDist = std::numeric_limits<double>::max();
263 NBEdge* bestEdge = nullptr;
264 for (NBEdge* cand : replacement) {
265 if (myPermissions == 0 || (cand->getPermissions() & myPermissions) != 0) {
266 const double dist = cand->getGeometry().distance2D(myPosition) + MAX2(0., myPTStopLength - cand->getLoadedLength());
267 if (dist < bestDist) {
268 bestDist = dist;
269 bestEdge = cand;
270 }
271 }
272 }
273 if (bestEdge != nullptr) {
274 if ((bestEdge->getPermissions() & SVC_PEDESTRIAN) != 0) {
275 // no need for access
276 clearAccess();
277 }
278 return findLaneAndComputeBusStopExtent(bestEdge);
279 }
280 return false;
281 }
282 return true;
283}
284
285
286/****************************************************************************/
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition: NBCont.h:42
@ SVC_PEDESTRIAN
pedestrian
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
@ SUMO_TAG_ACCESS
An access point for a train stop.
@ SUMO_TAG_BUS_STOP
A bus stop.
@ SUMO_ATTR_STARTPOS
@ SUMO_ATTR_LINES
@ SUMO_ATTR_LANE
@ SUMO_ATTR_PARKING_LENGTH
@ SUMO_ATTR_ENDPOS
@ SUMO_ATTR_NAME
@ SUMO_ATTR_FRIENDLY_POS
@ SUMO_ATTR_LENGTH
@ SUMO_ATTR_COLOR
A color information.
@ SUMO_ATTR_ID
@ SUMO_ATTR_POSITION
T MIN2(T a, T b)
Definition: StdDefs.h:71
T MAX2(T a, T b)
Definition: StdDefs.h:77
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
Storage for edges, including some functionality operating on multiple edges.
Definition: NBEdgeCont.h:59
NBEdge * getByID(const std::string &edgeID) const
Returns the edge with id if it exists.
The representation of a single edge during network building.
Definition: NBEdge.h:92
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
Definition: NBEdge.cpp:4137
const PositionVector & getGeometry() const
Returns the geometry of the edge.
Definition: NBEdge.h:787
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
Definition: NBEdge.h:736
const std::string & getID() const
Definition: NBEdge.h:1526
std::string getLaneID(int lane) const
get lane ID
Definition: NBEdge.cpp:3776
const PositionVector & getLaneShape(int i) const
Returns the shape of the nth lane.
Definition: NBEdge.cpp:962
double getFinalLength() const
get length that will be assigned to the lanes in the final network
Definition: NBEdge.cpp:4469
bool myIsMultipleStopPositions
Definition: NBPTStop.h:191
NBPTStop(std::string ptStopId, Position position, std::string edgeId, std::string origEdgeId, double length, std::string name, SVCPermissions svcPermissions, double parkingLength=0, const RGBColor color=RGBColor(false), double givenStartPos=-1)
Constructor.
Definition: NBPTStop.cpp:32
std::map< std::string, std::string > myAdditionalEdgeCandidates
Definition: NBPTStop.h:164
double myStartPos
Definition: NBPTStop.h:173
void registerAdditionalEdge(std::string wayId, std::string edgeId)
Definition: NBPTStop.cpp:189
const SVCPermissions myPermissions
Definition: NBPTStop.h:171
double myPTStopLength
Definition: NBPTStop.h:166
bool findLaneAndComputeBusStopExtent(const NBEdgeCont &ec)
Definition: NBPTStop.cpp:195
void addPlatformCand(NBPTPlatform platform)
Definition: NBPTStop.cpp:151
void clearAccess()
remove all access definitions
Definition: NBPTStop.cpp:238
std::string myLaneId
Definition: NBPTStop.h:170
std::string myPTStopId
Definition: NBPTStop.h:161
double myGivenStartPos
Definition: NBPTStop.h:193
std::vector< NBPTPlatform > myPlatformCands
Definition: NBPTStop.h:190
std::vector< std::string > myLines
list of public transport lines (for displaying)
Definition: NBPTStop.h:180
bool setEdgeId(std::string edgeId, const NBEdgeCont &ec)
Definition: NBPTStop.cpp:182
bool replaceEdge(const std::string &edgeID, const EdgeVector &replacement)
replace the stop edge with the closest edge on the given edge list in all stops
Definition: NBPTStop.cpp:259
std::string getID() const
Definition: NBPTStop.cpp:55
void mirrorX()
mirror coordinates along the x-axis
Definition: NBPTStop.cpp:85
bool getIsMultipleStopPositions() const
Definition: NBPTStop.cpp:163
void addAccess(std::string laneID, double offset, double length)
Definition: NBPTStop.cpp:244
void write(OutputDevice &device)
Definition: NBPTStop.cpp:100
const std::vector< NBPTPlatform > & getPlatformCands()
Definition: NBPTStop.cpp:157
const std::string myName
Definition: NBPTStop.h:167
std::vector< std::tuple< std::string, double, double > > myAccesses
laneId, lanePos, accessLength
Definition: NBPTStop.h:177
Position myPosition
Definition: NBPTStop.h:162
void addLine(const std::string &line)
register line that services this stop (for displaying)
Definition: NBPTStop.cpp:91
double getLength() const
Definition: NBPTStop.cpp:176
void reshiftPosition(const double offsetX, const double offsetY)
Definition: NBPTStop.cpp:136
double myEndPos
Definition: NBPTStop.h:174
void setIsMultipleStopPositions(bool multipleStopPositions, long long int areaID)
Definition: NBPTStop.cpp:169
SVCPermissions getPermissions() const
Definition: NBPTStop.cpp:145
const std::string & getEdgeId() const
Definition: NBPTStop.cpp:67
const double myParkingLength
Definition: NBPTStop.h:168
const Position & getPosition() const
Definition: NBPTStop.cpp:79
const RGBColor myColor
Definition: NBPTStop.h:169
std::string myOrigEdgeId
Definition: NBPTStop.h:165
long long int myAreaID
Definition: NBPTStop.h:192
const std::string getOrigEdgeId() const
Definition: NBPTStop.cpp:61
const std::string getName() const
Definition: NBPTStop.cpp:73
std::string myEdgeId
Definition: NBPTStop.h:163
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:251
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
void writeParams(OutputDevice &device) const
write Params in the given outputdevice
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
void add(const Position &pos)
Adds the given position to this one.
Definition: Position.h:125
void mul(double val)
Multiplies both positions with the given value.
Definition: Position.h:105
A list of positions.
double length2D() const
Returns the length.
double distance2D(const Position &p, bool perpendicular=false) const
closest 2D-distance to point p (or -1 if perpendicular is true and the point is beyond this vector)
double nearest_offset_to_point2D(const Position &p, bool perpendicular=true) const
return the nearest offest to point 2D
bool isValid() const
check if RGBColor is valid
Definition: RGBColor.cpp:120
static std::string getEdgeIDFromLane(const std::string laneID)
return edge id when given the lane ID
static std::string escapeXML(const std::string &orig, const bool maskDoubleHyphen=false)
Replaces the standard escapes by their XML entities.