Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2011-2024 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 : /****************************************************************************/
14 : /// @file NBLoadedSUMOTLDef.h
15 : /// @author Jakob Erdmann
16 : /// @author Michael Behrisch
17 : /// @date Mar 2011
18 : ///
19 : // A complete traffic light logic loaded from a sumo-net. (opted to reimplement
20 : // since NBLoadedTLDef is quite vissim specific)
21 : /****************************************************************************/
22 : #pragma once
23 : #include <config.h>
24 :
25 : #include <vector>
26 : #include <string>
27 : #include <set>
28 : #include "NBNode.h"
29 : #include "NBEdgeCont.h"
30 : #include "NBTrafficLightDefinition.h"
31 : #include "NBTrafficLightLogic.h"
32 : #include <utils/common/SUMOTime.h>
33 :
34 :
35 : // ===========================================================================
36 : // class definitions
37 : // ===========================================================================
38 : /**
39 : * @class NBLoadedSUMOTLDef
40 : * @brief A loaded (complete) traffic light logic
41 : */
42 : class NBLoadedSUMOTLDef : public NBTrafficLightDefinition {
43 : public:
44 :
45 : /** @brief Constructor
46 : * @param[in] id The id of the tls
47 : * @param[in] programID The programID for the computed logic
48 : * @param[in] offset The offset for the computed logic
49 : * @param[in] type The algorithm type for the computed logic
50 : */
51 : NBLoadedSUMOTLDef(const std::string& id, const std::string& programID, SUMOTime offset, TrafficLightType type);
52 :
53 : /** @brief Constructor that copies from an existing definition and its computed logic (used by netedit)
54 : * @param[in] def The definition to copy
55 : * @param[in] logic The computed logic of the given def
56 : */
57 : NBLoadedSUMOTLDef(const NBTrafficLightDefinition& def, const NBTrafficLightLogic& logic);
58 :
59 :
60 : /// @brief Destructor
61 : ~NBLoadedSUMOTLDef();
62 :
63 : void setID(const std::string& newID);
64 :
65 : /** @brief Sets the programID
66 : * @param[in] programID The new ID of the program (subID)
67 : */
68 : void setProgramID(const std::string& programID);
69 :
70 : /** @brief Informs edges about being controlled by a tls
71 : */
72 : void setTLControllingInformation() const;
73 :
74 : /** @brief Replaces occurrences of the removed edge in incoming/outgoing edges of all definitions
75 : * @param[in] removed The removed edge
76 : * @param[in] incoming The edges to use instead if an incoming edge was removed
77 : * @param[in] outgoing The edges to use instead if an outgoing edge was removed
78 : */
79 : void remapRemoved(NBEdge* removed,
80 : const EdgeVector& incoming, const EdgeVector& outgoing);
81 :
82 :
83 : /** @brief Replaces a removed edge/lane
84 : * @param[in] removed The edge to replace
85 : * @param[in] removedLane The lane of this edge to replace
86 : * @param[in] by The edge to insert instead
87 : * @param[in] byLane This edge's lane to insert instead
88 : */
89 : void replaceRemoved(NBEdge* removed, int removedLane,
90 : NBEdge* by, int byLane, bool incoming);
91 :
92 : /** @brief patches signal plans by modifying lane indices
93 : * with the given offset, only indices with a value above threshold are modified
94 : */
95 : void shiftTLConnectionLaneIndex(NBEdge* edge, int offset, int threshold = -1);
96 :
97 : /** @brief Adds a phase to the logic
98 : * the new phase is inserted at the end of the list of already added phases
99 : * @param[in] duration The duration of the phase to add
100 : * @param[in] state The state definition of a tls phase
101 : * @param[in] minDur The minimum duration of the phase to add
102 : * @param[in] maxDur The maximum duration of the phase to add
103 : * @param[in] vehExt The vehExt of the phase to add
104 : * @param[in] yellow The yellow of the phase to add
105 : * @param[in] red The red of the phase to add
106 : * @param[in] earliestEnd The early end of the phase to add
107 : * @param[in] latestEnd The latest end of the phase to add
108 : */
109 : void addPhase(const SUMOTime duration, const std::string& state, const SUMOTime minDur, const SUMOTime maxDur,
110 : const SUMOTime earliestEnd, const SUMOTime latestEnd, const SUMOTime vehExt, const SUMOTime yellow,
111 : const SUMOTime red, const std::vector<int>& next, const std::string& name);
112 :
113 : /// @brief mark phases as load
114 : void phasesLoaded() {
115 235 : myPhasesLoaded = true;
116 235 : }
117 :
118 : /** @brief Adds a connection and immediately informs the edges
119 : */
120 : void addConnection(NBEdge* from, NBEdge* to, int fromLane, int toLane, int linkIndex, int linkIndex2, bool reconstruct = true);
121 :
122 :
123 : /** @brief removes the given connection from the traffic light
124 : * if recontruct=true, reconstructs the logic and informs the edges for immediate use in netedit
125 : * @note: tlIndex is not necessarily unique. we need the whole connection data here
126 : */
127 : void removeConnection(const NBConnection& conn, bool reconstruct = true);
128 :
129 : /// @brief register changes that necessitate recomputation
130 : void registerModifications(bool addedConnections, bool removedConnections);
131 :
132 : /** @brief Returns the internal logic
133 : */
134 : NBTrafficLightLogic* getLogic() {
135 53 : return myTLLogic;
136 : }
137 :
138 : /** @brief Sets the offset of this tls
139 : * @param[in] offset The offset of this cycle
140 : */
141 : void setOffset(SUMOTime offset);
142 :
143 : /** @brief Sets the algorithm type of this tls
144 : * @param[in] offset The algorithm type of this tls
145 : */
146 : void setType(TrafficLightType type);
147 :
148 : /// @brief whether the given index must yield to the foeIndex while turing right on a red light
149 : bool rightOnRedConflict(int index, int foeIndex) const;
150 :
151 : /* @brief shortens phase states to remove states that are not referenced by
152 : * any controlled link and returns whether states were shortened
153 : */
154 : bool cleanupStates();
155 :
156 : /// @brief whether this definition uses signal group (multiple connections with the same link index)
157 : bool usingSignalGroups() const;
158 :
159 : /// @brief join nodes and states from the given logic (append red state)
160 : void joinLogic(NBTrafficLightDefinition* def);
161 :
162 : /// @brief heuristically add minDur and maxDur when switching from tlType fixed to actuated
163 : void guessMinMaxDuration();
164 :
165 : /// @brief let connections with the same state use the same link index
166 : void groupSignals();
167 :
168 : /// @brief let all connections use a distinct link index
169 : void ungroupSignals();
170 :
171 : /// @brief copy the assignment of link indices to connections from the given definition and rebuilt the states to match
172 : // Note: Issues a warning when the grouping of def is incompatible with the current states
173 : void copyIndices(NBTrafficLightDefinition* def);
174 :
175 : /// @brief perform optional final checks (on writing)
176 : void finalChecks() const;
177 :
178 : /// @brief replace the given link index in all connections
179 : void replaceIndex(int oldIndex, int newIndex);
180 :
181 : protected:
182 : /// @brief Collects the links participating in this traffic light (only if not previously loaded)
183 : void collectLinks();
184 :
185 : /// @brief Build the list of participating edges
186 : void collectEdges();
187 :
188 : /** @brief Computes the traffic light logic finally in dependence to the type
189 : * @param[in] brakingTime Duration a vehicle needs for braking in front of the tls in seconds
190 : * @return The computed logic
191 : */
192 : NBTrafficLightLogic* myCompute(int brakingTimeSeconds);
193 :
194 : bool amInvalid() const;
195 :
196 : /// @brief initialize myNeedsContRelation and set myNeedsContRelationReady to true
197 : void initNeedsContRelation() const;
198 :
199 : /// @brief return the highest known tls link index used by any controlled connection or crossing
200 : int getMaxIndex();
201 :
202 : ///@brief Returns the maximum index controlled by this traffic light
203 : int getMaxValidIndex();
204 :
205 : /// @brief get all states for the given link index
206 : std::string getStates(int index);
207 :
208 : /// @brief return whether the given link index is used by any connectons
209 : bool isUsed(int index) const;
210 :
211 : /// brief retrieve all edges with connections that use the given traffic light index
212 : std::set<const NBEdge*> getEdgesUsingIndex(int index) const;
213 :
214 : private:
215 :
216 : /// @brief phases are added directly to myTLLogic which is then returned in myCompute()
217 : NBTrafficLightLogic* myTLLogic;
218 :
219 : /// @brief repair the plan if controlled nodes received pedestrian crossings
220 : void patchIfCrossingsAdded();
221 :
222 : /// @brief set of edges with shifted lane indices (to avoid shifting twice)
223 : std::set<NBEdge*> myShifted;
224 :
225 : /// @brief whether the logic must be reconstructed
226 : bool myReconstructAddedConnections;
227 : bool myReconstructRemovedConnections;
228 : bool myPhasesLoaded;
229 :
230 : /** @brief Collects the edges for each tlIndex
231 : * @param[out] fromEdges The from-edge for each controlled tlIndex
232 : * @param[out] toEdges The to-edge for each controlled tlIndex
233 : * @param[out] fromLanes The from-lanes for each controlled tlIndex
234 : */
235 : void collectEdgeVectors(EdgeVector& fromEdges, EdgeVector& toEdges, std::vector<int>& fromLanes) const;
236 :
237 : /// @brief adapt to removal or addition of connections
238 : void reconstructLogic();
239 :
240 : /// @brief return whether all tls link indices are valid
241 : bool hasValidIndices() const;
242 :
243 : /// @brief return whether the given connection is still valid
244 : bool isValid(const NBConnection& con) const;
245 :
246 : private:
247 : /// @brief class for identifying connections
248 : class connection_equal {
249 : public:
250 : /// constructor
251 24 : connection_equal(const NBConnection& c) : myC(c) {}
252 :
253 33240 : bool operator()(const NBConnection& c) const {
254 41822 : return c.getFrom() == myC.getFrom() && c.getTo() == myC.getTo() &&
255 34824 : c.getFromLane() == myC.getFromLane() && c.getToLane() == myC.getToLane();
256 : }
257 : private:
258 : const NBConnection& myC;
259 : };
260 :
261 : };
|
