Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
NLEdgeControlBuilder.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2023 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/****************************************************************************/
21// Interface for building edges
22/****************************************************************************/
23#include <config.h>
24
25#include <vector>
26#include <string>
27#include <map>
28#include <algorithm>
29#include <iterator>
30#include <mesosim/MELoop.h>
31#include <microsim/MSGlobals.h>
32#include <microsim/MSLane.h>
33#include <microsim/MSEdge.h>
38#include "NLBuilder.h"
41
42
43// ===========================================================================
44// method definitions
45// ===========================================================================
47 : myCurrentNumericalLaneID(0), myCurrentNumericalEdgeID(0), myEdges(0), myCurrentLaneIndex(-1) {
48 myActiveEdge = (MSEdge*) nullptr;
49 myLaneStorage = new std::vector<MSLane*>();
50}
51
52
56
57
58void
60 const std::string& id, const SumoXMLEdgeFunc function,
61 const std::string& streetName,
62 const std::string& edgeType,
63 int priority,
64 const std::string& bidi,
65 double distance) {
66 // closeEdge might not have been called because the last edge had an error, so we clear the lane storage
67 myLaneStorage->clear();
68 myActiveEdge = buildEdge(id, function, streetName, edgeType, priority, distance);
69 if (MSEdge::dictionary(id) != nullptr) {
70 throw InvalidArgument("Another edge with the id '" + id + "' exists.");
71 }
72 myEdges.push_back(myActiveEdge);
73 if (bidi != "") {
75 }
76}
77
78
79MSLane*
80NLEdgeControlBuilder::addLane(const std::string& id,
81 double maxSpeed, double friction, double length,
82 const PositionVector& shape, double width,
83 SVCPermissions permissions,
84 SVCPermissions changeLeft, SVCPermissions changeRight,
85 int index, bool isRampAccel,
86 const std::string& type) {
87 MSLane* lane = new MSLane(id, maxSpeed, friction, length, myActiveEdge, myCurrentNumericalLaneID++, shape, width, permissions, changeLeft, changeRight, index, isRampAccel, type);
88 myLaneStorage->push_back(lane);
89 myCurrentLaneIndex = index;
90 return lane;
91}
92
93
94void
96 if (myCurrentLaneIndex == -1) {
97 setDefaultStopOffset(stopOffset);
98 } else {
100 }
101}
102
103
104std::string
106 std::stringstream ss;
107 if (myCurrentLaneIndex != -1) {
108 ss << "lane " << myCurrentLaneIndex << " of ";
109 }
110 ss << "edge '" << myActiveEdge->getID() << "'";
111 return ss.str();
112}
113
114
115void
117 if (myLaneStorage->size() == 0) {
118 throw ProcessError("myLaneStorage cannot be empty");
119 }
120 if (stopOffset.isDefined()) {
121 if (myLaneStorage->back()->getLaneStopOffsets().isDefined()) {
122 WRITE_WARNING("Duplicate stopOffset definition for lane " + toString(myLaneStorage->back()->getIndex()) +
123 " on edge " + myActiveEdge->getID() + "!")
124 } else {
125 myLaneStorage->back()->setLaneStopOffset(stopOffset);
126 }
127 }
128}
129
130
131void
134 WRITE_WARNING("Duplicate stopOffset definition for edge " + myActiveEdge->getID() + ". Ignoring duplicate specification.")
135 } else {
136 myCurrentDefaultStopOffset = stopOffsets;
137 }
138}
139
140
141void
143 if (myActiveEdge == nullptr) {
144 throw ProcessError("myActiveEdge cannot be nullptr");
145 }
147 for (const auto& l : *myLaneStorage) {
148 if (!l->getLaneStopOffsets().isDefined()) {
149 l->setLaneStopOffset(myCurrentDefaultStopOffset);
150 }
151 }
152 }
153}
154
155
156void
157NLEdgeControlBuilder::addNeigh(const std::string id) {
158 myOppositeLanes.push_back({myLaneStorage->back(), id});
159}
160
161
162MSEdge*
165 std::vector<MSLane*>* lanes = new std::vector<MSLane*>();
166 lanes->reserve(myLaneStorage->size());
167 copy(myLaneStorage->begin(), myLaneStorage->end(), back_inserter(*lanes));
168 myLaneStorage->clear();
169 myActiveEdge->initialize(lanes);
171 return myActiveEdge;
172}
173
174
175void
179
180
183 if (MSGlobals::gUseMesoSim && !OptionsCont::getOptions().getBool("meso-lane-queue")) {
184 MSEdge::setMesoIgnoredVClasses(parseVehicleClasses(OptionsCont::getOptions().getStringVector("meso-ignore-lanes-by-vclass")));
185 }
186 // connecting opposite lanes must happen before MSEdge::closeBuilding
187 for (auto item : myOppositeLanes) {
188 MSLane* oppo = MSLane::dictionary(item.second);
189 if (oppo == nullptr) {
190 WRITE_ERRORF("Unknown neigh lane '%' for lane '%'", item.second, item.first->getID());
191 } else {
192 item.first->setOpposite(oppo);
193 }
194 }
195 // consistency check
196 for (auto item : myOppositeLanes) {
197 if (item.first->getOpposite() != nullptr && item.first->getOpposite()->getOpposite() != item.first) {
198 WRITE_WARNINGF(TL("Asymmetrical neigh lane '%' for lane '%'"), item.second, item.first->getID());
199 item.first->getOpposite()->setOpposite(item.first);
200 }
201 }
202 for (MSEdge* const edge : myEdges) {
203 edge->closeBuilding();
204 }
205 for (MSEdge* const edge : myEdges) {
206 edge->rebuildAllowedTargets(false);
207 // segment building depends on the finished list of successors (for multi-queue)
208 if (MSGlobals::gUseMesoSim && !edge->getLanes().empty()) {
210 }
211 edge->buildLaneChanger();
212 }
213 // mark internal edges belonging to a roundabout (after all edges are build)
215 for (MSEdge* const edge : myEdges) {
216 if (edge->isInternal()) {
217 if (edge->getNumSuccessors() != 1 || edge->getNumPredecessors() != 1) {
218 throw ProcessError(TLF("Internal edge '%' is not properly connected (probably a manually modified net.xml).", edge->getID()));
219 }
220 if (edge->getSuccessors()[0]->isRoundabout() || edge->getPredecessors()[0]->isRoundabout()) {
221 edge->markAsRoundabout();
222 }
223 }
224 }
225 }
226 if (!deprecatedVehicleClassesSeen.empty()) {
227 WRITE_WARNINGF(TL("Deprecated vehicle classes '%' in input network."), toString(deprecatedVehicleClassesSeen));
229 }
230 // check for bi-directional edges (this are edges in opposing direction and superposable/congruent shapes)
231 if (myBidiEdges.size() > 0 || networkVersion > MMVersion(1, 0)) {
232 for (auto& item : myBidiEdges) {
233 item.first->checkAndRegisterBiDirEdge(item.second);
234 }
235 //WRITE_MESSAGEF(TL("Loaded % bidirectional edges"), toString(myBidiEdges.size()));
236 } else {
237 // legacy network
238 for (MSEdge* e : myEdges) {
239 e->checkAndRegisterBiDirEdge();
240 }
241 }
242 return new MSEdgeControl(myEdges);
243}
244
245
246MSEdge*
247NLEdgeControlBuilder::buildEdge(const std::string& id, const SumoXMLEdgeFunc function,
248 const std::string& streetName, const std::string& edgeType, const int priority, const double distance) {
249 return new MSEdge(id, myCurrentNumericalEdgeID++, function, streetName, edgeType, priority, distance);
250}
251
252void NLEdgeControlBuilder::addCrossingEdges(const std::vector<std::string>& crossingEdges) {
253 myActiveEdge->setCrossingEdges(crossingEdges);
254}
255
256
257/****************************************************************************/
#define WRITE_WARNINGF(...)
Definition MsgHandler.h:271
#define WRITE_ERRORF(...)
Definition MsgHandler.h:280
#define WRITE_WARNING(msg)
Definition MsgHandler.h:270
#define TL(string)
Definition MsgHandler.h:287
#define TLF(string,...)
Definition MsgHandler.h:288
std::set< std::string > deprecatedVehicleClassesSeen
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
std::pair< int, double > MMVersion
(M)ajor/(M)inor version for written networks and default version for loading
Definition StdDefs.h:67
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition ToString.h:46
void buildSegmentsFor(const MSEdge &e, const OptionsCont &oc)
Build the segments for a given edge.
Definition MELoop.cpp:289
Stores edges and lanes, performs moving of vehicle.
A road/street connecting two junctions.
Definition MSEdge.h:77
void setCrossingEdges(const std::vector< std::string > &crossingEdges)
Sets the crossed edge ids for a crossing edge.
Definition MSEdge.h:348
static void setMesoIgnoredVClasses(SVCPermissions ignored)
Definition MSEdge.h:789
void initialize(const std::vector< MSLane * > *lanes)
Initialize the edge.
Definition MSEdge.cpp:101
static bool dictionary(const std::string &id, MSEdge *edge)
Inserts edge into the static dictionary Returns true if the key id isn't already in the dictionary....
Definition MSEdge.cpp:945
static bool gUseMesoSim
Definition MSGlobals.h:103
static MELoop * gMesoNet
mesoscopic simulation infrastructure
Definition MSGlobals.h:109
static bool gUsingInternalLanes
Information whether the simulation regards internal lanes.
Definition MSGlobals.h:78
Representation of a lane in the micro simulation.
Definition MSLane.h:84
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
Definition MSLane.cpp:2325
std::map< MSEdge *, std::string > myBidiEdges
temporary storage for bidi attributes (to be resolved after loading all edges)
virtual MSEdge * closeEdge()
Closes the building of an edge; The edge is completely described by now and may not be opened again.
virtual void addNeigh(const std::string id)
Adds a neighbor to the current lane.
MSEdgeVector myEdges
Temporary, internal storage for built edges.
MSEdge * myActiveEdge
pointer to the currently chosen edge
void updateCurrentLaneStopOffset(const StopOffset &stopOffset)
set the stopOffset for the last added lane.
void closeLane()
Closes the building of a lane; The edge is completely described by now and may not be opened again.
int myCurrentLaneIndex
The index of the currently active lane (-1 if none is active)
virtual MSLane * addLane(const std::string &id, double maxSpeed, double friction, double length, const PositionVector &shape, double width, SVCPermissions permissions, SVCPermissions changeLeft, SVCPermissions changeRight, int index, bool isRampAccel, const std::string &type)
Adds a lane to the current edge.
std::vector< std::pair< MSLane *, std::string > > myOppositeLanes
std::string reportCurrentEdgeOrLane() const
Return info about currently processed edge or lane.
int myCurrentNumericalLaneID
A running number for lane numbering.
void beginEdgeParsing(const std::string &id, const SumoXMLEdgeFunc function, const std::string &streetName, const std::string &edgeType, int priority, const std::string &bidi, double distance)
Begins building of an MSEdge.
void setDefaultStopOffset(const StopOffset &stopOffset)
set the stopOffset for the last added lane.
virtual void addCrossingEdges(const std::vector< std::string > &)
add the crossingEdges in a crossing edge if present
void addStopOffsets(const StopOffset &stopOffsets)
process a stopOffset element (originates either from the active edge or lane).
virtual MSEdge * buildEdge(const std::string &id, const SumoXMLEdgeFunc function, const std::string &streetName, const std::string &edgeType, const int priority, const double distance)
Builds an edge instance (MSEdge in this case)
std::vector< MSLane * > * myLaneStorage
pointer to a temporary lane storage
int myCurrentNumericalEdgeID
A running number for edge numbering.
StopOffset myCurrentDefaultStopOffset
The default stop offset for all lanes belonging to the active edge (this is set if the edge was given...
virtual ~NLEdgeControlBuilder()
Destructor.
MSEdgeControl * build(const MMVersion &networkVersion)
builds the MSEdgeControl-class which holds all edges
const std::string & getID() const
Returns the id.
Definition Named.h:74
static OptionsCont & getOptions()
Retrieves the options.
A list of positions.
stop offset
bool isDefined() const
check if stopOffset was defined
void reset()
reset stopOffset