Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2002-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 MSLeaderInfo.h
15 : /// @author Jakob Erdmann
16 : /// @date Oct 2015
17 : ///
18 : // Information about vehicles ahead (may be multiple vehicles if
19 : // lateral-resolution is active)
20 : /****************************************************************************/
21 : #pragma once
22 : #include <config.h>
23 :
24 : #include <string>
25 : #include <vector>
26 : #include <utils/common/StdDefs.h>
27 :
28 : // ===========================================================================
29 : // class declarations
30 : // ===========================================================================
31 : class MSVehicle;
32 : class MSLane;
33 :
34 :
35 : // ===========================================================================
36 : // type definitions
37 : // ===========================================================================
38 : typedef std::pair<const MSVehicle*, double> CLeaderDist;
39 : typedef std::pair<MSVehicle*, double> LeaderDist;
40 :
41 :
42 : // ===========================================================================
43 : // class definitions
44 : // ===========================================================================
45 : /**
46 : * @class MSLeaderInfo
47 : */
48 2473412536 : class MSLeaderInfo {
49 : public:
50 : /// Constructor
51 : MSLeaderInfo(const double laneWidth, const MSVehicle* ego = nullptr, const double latOffset = 0.);
52 :
53 : /// Destructor
54 : virtual ~MSLeaderInfo();
55 :
56 : /* @brief adds this vehicle as a leader in the appropriate sublanes
57 : * @param[in] veh The vehicle to add
58 : * @param[in] beyond Whether the vehicle is beyond the existing leaders (and thus may be shadowed by them)
59 : * @param[in] latOffset The lateral offset that must be added to the position of veh
60 : * @return The number of free sublanes
61 : */
62 : virtual int addLeader(const MSVehicle* veh, bool beyond, double latOffset = 0.);
63 :
64 : /// @brief discard all information
65 : virtual void clear();
66 :
67 : /* @brief returns sublanes occupied by veh
68 : * @param[in] veh The vehicle to check
69 : * @param[in] latOffset The offset value to add to the vehicle position
70 : * @param[out] rightmost The rightmost sublane occupied by veh
71 : * @param[out] leftmost The rightmost sublane occupied by veh
72 : */
73 : void getSubLanes(const MSVehicle* veh, double latOffset, int& rightmost, int& leftmost) const;
74 :
75 : /* @brief returns the sublane boundaries of the ith sublane
76 : * @param[in] sublane The sublane to check
77 : * @param[in] latOffset The offset value to add to the result
78 : * @param[out] rightSide The right border of the given sublane
79 : * @param[out] leftSide The left border of the given sublane
80 : */
81 : void getSublaneBorders(int sublane, double latOffset, double& rightSide, double& leftSide) const;
82 :
83 : /// @brief return the vehicle for the given sublane
84 : const MSVehicle* operator[](int sublane) const;
85 :
86 : int numSublanes() const {
87 5263586871 : return (int)myVehicles.size();
88 : }
89 :
90 : int numFreeSublanes() const {
91 402018141 : return myFreeSublanes;
92 : }
93 :
94 : bool hasVehicles() const {
95 366951730 : return myHasVehicles;
96 : }
97 :
98 : const std::vector<const MSVehicle*>& getVehicles() const {
99 : return myVehicles;
100 : }
101 :
102 : int getSublaneOffset() const {
103 : return myOffset;
104 : }
105 :
106 : /// @brief set number of sublanes by which to shift positions
107 : void setSublaneOffset(int offset);
108 :
109 : /// @brief whether a stopped vehicle is leader
110 : bool hasStoppedVehicle() const;
111 :
112 : /// @brief remove vehicles that are driving in the opposite direction (fully or partially) on the given lane
113 : void removeOpposite(const MSLane* lane);
114 :
115 : /// @brief print a debugging representation
116 : virtual std::string toString() const;
117 :
118 : protected:
119 :
120 : /// @brief the width of the lane to which this instance applies
121 : // @note: not const to simplify assignment
122 : double myWidth;
123 :
124 : /// @brief an extra offset for shifting the interpretation of sublane borders (default [0,myWidth])
125 : int myOffset;
126 :
127 : std::vector<const MSVehicle*> myVehicles;
128 :
129 : /// @brief the number of free sublanes
130 : // if an ego vehicle is given in the constructor, the number of free
131 : // sublanes of those covered by ego
132 : int myFreeSublanes;
133 :
134 : /// @brief borders of the ego vehicle for filtering of free sublanes
135 : int egoRightMost;
136 : int egoLeftMost;
137 :
138 : bool myHasVehicles;
139 :
140 : };
141 :
142 :
143 : /// @brief saves leader/follower vehicles and their distances relative to an ego vehicle
144 : class MSLeaderDistanceInfo : public MSLeaderInfo {
145 : public:
146 : /// Constructor
147 : MSLeaderDistanceInfo(const double laneWidth, const MSVehicle* ego, const double latOffset);
148 :
149 : /// @brief Construct for the non-sublane-case
150 : MSLeaderDistanceInfo(const CLeaderDist& cLeaderDist, const double laneWidth);
151 :
152 : /// Destructor
153 : virtual ~MSLeaderDistanceInfo();
154 :
155 : /* @brief adds this vehicle as a leader in the appropriate sublanes
156 : * @param[in] veh The vehicle to add
157 : * @param[in] gap The gap between the egoFront+minGap to the back of veh
158 : * or from the back of ego to the front+minGap of veh
159 : * @param[in] latOffset The lateral offset that must be added to the position of veh
160 : * @param[in] sublane The single sublane to which this leader shall be checked (-1 means: check for all)
161 : * @return The number of free sublanes
162 : */
163 : virtual int addLeader(const MSVehicle* veh, double gap, double latOffset = 0, int sublane = -1);
164 :
165 0 : virtual int addLeader(const MSVehicle* veh, bool beyond, double latOffset = 0) {
166 : UNUSED_PARAMETER(veh);
167 : UNUSED_PARAMETER(beyond);
168 : UNUSED_PARAMETER(latOffset);
169 0 : throw ProcessError(TL("Method not supported"));
170 : }
171 :
172 : /// @brief updatd empty sublanes with vehicles and gaps from other
173 : virtual void addLeaders(MSLeaderDistanceInfo& other);
174 :
175 : /// @brief discard all information
176 : virtual void clear();
177 :
178 : /// @brief return the vehicle and its distance for the given sublane
179 : CLeaderDist operator[](int sublane) const;
180 :
181 : /// @brief print a debugging representation
182 : virtual std::string toString() const;
183 :
184 : const std::vector<double>& getDistances() const {
185 : return myDistances;
186 : }
187 :
188 : /// @brief subtract vehicle length from all gaps if the leader vehicle is driving in the opposite direction
189 : void fixOppositeGaps(bool isFollower);
190 :
191 : /// @brief add given value to all gaps
192 : void patchGaps(double amount);
193 :
194 : /// @brief return vehicle with the smalles gap
195 : CLeaderDist getClosest() const;
196 :
197 : void moveSamePosTo(const MSVehicle* ego, MSLeaderDistanceInfo& other);
198 :
199 : protected:
200 :
201 : std::vector<double> myDistances;
202 :
203 : };
204 :
205 :
206 : /* @brief saves follower vehicles and their distances as well as their required gap relative to an ego vehicle
207 : * when adding new followers, the one with the largest required gap is recored
208 : * (rather than the one with the smallest gap) */
209 : class MSCriticalFollowerDistanceInfo : public MSLeaderDistanceInfo {
210 : public:
211 : /// Constructor
212 : MSCriticalFollowerDistanceInfo(const double laneWidth, const MSVehicle* ego, const double latOffset, const bool haveOppositeLeaders = false);
213 :
214 : /// Destructor
215 : virtual ~MSCriticalFollowerDistanceInfo();
216 :
217 : /* @brief adds this vehicle as a follower in the appropriate sublanes
218 : * @param[in] veh The vehicle to add
219 : * @param[in] ego The vehicle which is being followed
220 : * @param[in] gap The distance from the back of ego to the follower
221 : * @param[in] latOffset The lateral offset that must be added to the position of veh
222 : * @param[in] sublane The single sublane to which this leader shall be checked (-1 means: check for all)
223 : * @return The number of free sublanes
224 : */
225 : int addFollower(const MSVehicle* veh, const MSVehicle* ego, double gap, double latOffset = 0, int sublane = -1);
226 :
227 0 : virtual int addLeader(const MSVehicle* veh, double gap, double latOffset = 0, int sublane = -1) {
228 : UNUSED_PARAMETER(veh);
229 : UNUSED_PARAMETER(gap);
230 : UNUSED_PARAMETER(latOffset);
231 : UNUSED_PARAMETER(sublane);
232 0 : throw ProcessError(TL("Method not supported"));
233 : }
234 :
235 0 : virtual int addLeader(const MSVehicle* veh, bool beyond, double latOffset = 0) {
236 : UNUSED_PARAMETER(veh);
237 : UNUSED_PARAMETER(beyond);
238 : UNUSED_PARAMETER(latOffset);
239 0 : throw ProcessError(TL("Method not supported"));
240 : }
241 :
242 : /// @brief discard all information
243 : void clear();
244 :
245 : /// @brief print a debugging representation
246 : std::string toString() const;
247 :
248 : protected:
249 :
250 : // @brief the differences between requriedGap and actual gap for each of the followers
251 : std::vector<double> myMissingGaps;
252 :
253 : // @brief whether this Info objects tracks leaders instead of followers
254 : bool myHaveOppositeLeaders;
255 :
256 : };
|
