Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2025 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 GUIVisualizationSettings.cpp
15 : /// @author Daniel Krajzewicz
16 : /// @author Jakob Erdmann
17 : /// @author Michael Behrisch
18 : /// @author Mirko Barthauer
19 : /// @date Sept 2002
20 : ///
21 : // Stores the information about how to visualize structures
22 : /****************************************************************************/
23 : #include <config.h>
24 :
25 : #include <map>
26 : #include <vector>
27 : #include <utils/common/MsgHandler.h>
28 : #include <utils/gui/div/GUIGlobalSelection.h>
29 :
30 : #include "GUIVisualizationSettings.h"
31 : #include "GUIPropertyScheme.h"
32 :
33 : // ===========================================================================
34 : // static members
35 : // ===========================================================================
36 :
37 : bool GUIVisualizationSettings::UseMesoSim = false;
38 :
39 : // -------------------------------------------------------------------------
40 : // color constants for link states
41 : // -------------------------------------------------------------------------
42 :
43 : const RGBColor SUMO_color_TL_GREEN_MAJOR(0, 255, 0);
44 : const RGBColor SUMO_color_TL_GREEN_MINOR(0, 179, 0);
45 : const RGBColor SUMO_color_TL_RED(255, 0, 0);
46 : const RGBColor SUMO_color_TL_REDYELLOW(255, 128, 0);
47 : const RGBColor SUMO_color_TL_YELLOW_MAJOR(255, 255, 128);
48 : const RGBColor SUMO_color_TL_YELLOW_MINOR(255, 255, 0);
49 : const RGBColor SUMO_color_TL_OFF_BLINKING(128, 64, 0);
50 : const RGBColor SUMO_color_TL_OFF_NOSIGNAL(0, 255, 255);
51 : const RGBColor SUMO_color_MAJOR(255, 255, 255);
52 : const RGBColor SUMO_color_MINOR(51, 51, 51);
53 : const RGBColor SUMO_color_EQUAL(128, 128, 128);
54 : const RGBColor SUMO_color_STOP(128, 0, 128);
55 : const RGBColor SUMO_color_ALLWAY_STOP(0, 0, 192);
56 : const RGBColor SUMO_color_ZIPPER(192, 128, 64);
57 : const RGBColor SUMO_color_DEADEND(0, 0, 0);
58 :
59 : // -------------------------------------------------------------------------
60 : // color constants for other objects
61 : // -------------------------------------------------------------------------
62 :
63 : const RGBColor GUIVisualizationColorSettings::SUMO_color_DEADEND_SHOW(255, 0, 255);
64 : const RGBColor GUIVisualizationColorSettings::childConnectionColor(255, 235, 0);
65 : const RGBColor GUIVisualizationColorSettings::editShapeColor(0, 200, 0);
66 : const RGBColor GUIVisualizationColorSettings::crossingColor(25, 25, 25);
67 : const RGBColor GUIVisualizationColorSettings::crossingPriorityColor(229, 229, 229);
68 : const RGBColor GUIVisualizationColorSettings::crossingInvalidColor(255, 25, 25);
69 :
70 :
71 : // -------------------------------------------------------------------------
72 : // color constants for other objects
73 : // -------------------------------------------------------------------------
74 :
75 : const RGBColor GUIVisualizationCandidateColorSettings::possible(0, 64, 0, 255);
76 : const RGBColor GUIVisualizationCandidateColorSettings::source(0, 255, 255, 255); // Cyan
77 : const RGBColor GUIVisualizationCandidateColorSettings::target(0, 255, 0, 255); // Green
78 : const RGBColor GUIVisualizationCandidateColorSettings::special(255, 0, 255, 255); // Magenta
79 : const RGBColor GUIVisualizationCandidateColorSettings::conflict(255, 255, 0, 255); // Yellow
80 : const RGBColor GUIVisualizationCandidateColorSettings::invalid(128, 128, 128, 255); // Yellow
81 :
82 : // -------------------------------------------------------------------------
83 : // Netedit size values
84 : // -------------------------------------------------------------------------
85 :
86 : const double GUIVisualizationNeteditSizeSettings::junctionBubbleRadius(4);
87 : const double GUIVisualizationNeteditSizeSettings::junctionGeometryPointRadius(1);
88 : const double GUIVisualizationNeteditSizeSettings::edgeGeometryPointRadius(1.2);
89 : const double GUIVisualizationNeteditSizeSettings::laneGeometryPointRadius(1);
90 : const double GUIVisualizationNeteditSizeSettings::connectionGeometryPointRadius(0.8);
91 : const double GUIVisualizationNeteditSizeSettings::crossingGeometryPointRadius(1);
92 : const double GUIVisualizationNeteditSizeSettings::polygonGeometryPointRadius(1.2);
93 : const double GUIVisualizationNeteditSizeSettings::polygonContourWidth(0.3);
94 : const double GUIVisualizationNeteditSizeSettings::polylineWidth(1);
95 : const double GUIVisualizationNeteditSizeSettings::additionalGeometryPointRadius(0.9);
96 :
97 : // -------------------------------------------------------------------------
98 : // additional values
99 : // -------------------------------------------------------------------------
100 :
101 : const double GUIVisualizationConnectionSettings::connectionWidth(0.2);
102 :
103 : // -------------------------------------------------------------------------
104 : // additional values
105 : // -------------------------------------------------------------------------
106 :
107 : const RGBColor GUIVisualizationAdditionalSettings::rerouterColor(255, 0, 0, 255);
108 : const double GUIVisualizationAdditionalSettings::rerouterSize(1);
109 : const RGBColor GUIVisualizationAdditionalSettings::VSSColor(255, 255, 255, 255);
110 : const double GUIVisualizationAdditionalSettings::VSSSize(1);
111 : const RGBColor GUIVisualizationAdditionalSettings::calibratorColor(255, 204, 0, 255);
112 : const double GUIVisualizationAdditionalSettings::calibratorWidth(1.4);
113 : const double GUIVisualizationAdditionalSettings::calibratorHeight(6);
114 : const RGBColor GUIVisualizationAdditionalSettings::routeProbeColor(255, 216, 0, 255);
115 : const double GUIVisualizationAdditionalSettings::routeProbeSize(1);
116 : const RGBColor GUIVisualizationAdditionalSettings::vaporizerColor(120, 216, 0, 255);
117 : const double GUIVisualizationAdditionalSettings::vaporizerSize(1);
118 : const double GUIVisualizationAdditionalSettings::stopEdgeSize(1);
119 : const RGBColor GUIVisualizationAdditionalSettings::connectionColor(255, 216, 0, 255);
120 : const RGBColor GUIVisualizationAdditionalSettings::connectionColorSelected(0, 0, 150, 255);
121 : const double GUIVisualizationAdditionalSettings::tractionSubstationSize(1);
122 : const RGBColor GUIVisualizationAdditionalSettings::overheadWireColorTop(255, 0, 0);
123 : const RGBColor GUIVisualizationAdditionalSettings::overheadWireColorBot(0, 255, 0);
124 : const RGBColor GUIVisualizationAdditionalSettings::overheadWireColorSelected(0, 0, 150, 255);
125 : const double GUIVisualizationAdditionalSettings::arrowWidth(1);
126 : const double GUIVisualizationAdditionalSettings::arrowLength(0.25);
127 : const double GUIVisualizationAdditionalSettings::arrowOffset(0.1);
128 : const RGBColor GUIVisualizationAdditionalSettings::TLSConnectionColor(0, 255, 0, 255);
129 :
130 : // -------------------------------------------------------------------------
131 : // detector values
132 : // -------------------------------------------------------------------------
133 :
134 : const RGBColor GUIVisualizationDetectorSettings::E1Color(255, 255, 0);
135 : const double GUIVisualizationDetectorSettings::E1Width(1);
136 : const double GUIVisualizationDetectorSettings::E1Height(2);
137 : const RGBColor GUIVisualizationDetectorSettings::E1InstantColor(255, 0, 255);
138 : const double GUIVisualizationDetectorSettings::E1InstantWidth(1);
139 : const double GUIVisualizationDetectorSettings::E1InstantHeight(2);
140 : const RGBColor GUIVisualizationDetectorSettings::E2Color(0, 204, 204);
141 : const double GUIVisualizationDetectorSettings::E2Width(1);
142 : const double GUIVisualizationDetectorSettings::E3Size(1);
143 : const RGBColor GUIVisualizationDetectorSettings::E3EntryColor(0, 92, 64);
144 : const RGBColor GUIVisualizationDetectorSettings::E3ExitColor(92, 0, 0);
145 : const double GUIVisualizationDetectorSettings::E3EntryExitWidth(1.7);
146 : const double GUIVisualizationDetectorSettings::E3EntryExitHeight(0.5);
147 :
148 : // -------------------------------------------------------------------------
149 : // StoppingPlace values
150 : // -------------------------------------------------------------------------
151 :
152 : const double GUIVisualizationStoppingPlaceSettings::stoppingPlaceSignOffset(1.5);
153 : const double GUIVisualizationStoppingPlaceSettings::busStopWidth(1);
154 : const double GUIVisualizationStoppingPlaceSettings::trainStopWidth(0.5);
155 : const double GUIVisualizationStoppingPlaceSettings::containerStopWidth(3);
156 : const double GUIVisualizationStoppingPlaceSettings::chargingStationWidth(1);
157 : const double GUIVisualizationStoppingPlaceSettings::symbolExternalRadius(1.1);
158 : const double GUIVisualizationStoppingPlaceSettings::symbolInternalRadius(0.9);
159 : const double GUIVisualizationStoppingPlaceSettings::symbolInternalTextSize(1.6);
160 :
161 : // -------------------------------------------------------------------------
162 : // Dotted contour values
163 : // -------------------------------------------------------------------------
164 :
165 : const double GUIVisualizationDottedContourSettings::segmentWidth(0.2);
166 : const double GUIVisualizationDottedContourSettings::segmentWidthSmall(0.1);
167 : const double GUIVisualizationDottedContourSettings::segmentWidthLarge(0.5);
168 : const double GUIVisualizationDottedContourSettings::segmentLength(2);
169 : const RGBColor GUIVisualizationDottedContourSettings::firstInspectedColor(235, 235, 235);
170 : const RGBColor GUIVisualizationDottedContourSettings::secondInspectedColor(20, 20, 20);
171 : const RGBColor GUIVisualizationDottedContourSettings::firstFrontColor(0, 0, 235);
172 : const RGBColor GUIVisualizationDottedContourSettings::secondFrontColor(0, 255, 0);
173 :
174 : // -------------------------------------------------------------------------
175 : // 3D light presets
176 : // -------------------------------------------------------------------------
177 : const RGBColor OSG_color_AMBIENT(32, 32, 32, 255);
178 : const RGBColor OSG_color_DIFFUSE(64, 64, 64, 255);
179 : const RGBColor OSG_color_SKY(51, 51, 102, 255);
180 :
181 : // -------------------------------------------------------------------------
182 : // widths of certain netedit objects
183 : // -------------------------------------------------------------------------
184 :
185 : const double GUIVisualizationWidthSettings::routeWidth(0.66);
186 : const double GUIVisualizationWidthSettings::embeddedRouteWidth(0.55);
187 :
188 : // -------------------------------------------------------------------------
189 : // details of certain netedit objects (0 = drawn always)
190 : // -------------------------------------------------------------------------
191 :
192 : const double GUIVisualizationDetailSettings::tmp(5);
193 :
194 : // -------------------------------------------------------------------------
195 : // scheme names
196 : // -------------------------------------------------------------------------
197 :
198 : const std::string GUIVisualizationSettings::SCHEME_NAME_EDGE_PARAM_NUMERICAL(TL("by param (numerical, streetwise)"));
199 : const std::string GUIVisualizationSettings::SCHEME_NAME_LANE_PARAM_NUMERICAL(TL("by param (numerical, lanewise)"));
200 : const std::string GUIVisualizationSettings::SCHEME_NAME_PARAM_NUMERICAL(TL("by param (numerical)"));
201 : const std::string GUIVisualizationSettings::SCHEME_NAME_EDGEDATA_NUMERICAL(TL("by edgeData (numerical, streetwise)"));
202 : const std::string GUIVisualizationSettings::SCHEME_NAME_DATA_ATTRIBUTE_NUMERICAL(TL("by attribute (numerical)"));
203 : const std::string GUIVisualizationSettings::SCHEME_NAME_SELECTION(TL("by selection"));
204 : const std::string GUIVisualizationSettings::SCHEME_NAME_TYPE(TL("by type"));
205 : const std::string GUIVisualizationSettings::SCHEME_NAME_PERMISSION_CODE(TL("by permission code"));
206 : const std::string GUIVisualizationSettings::SCHEME_NAME_EDGEDATA_LIVE(TL("by live edgeData"));
207 :
208 : const double GUIVisualizationSettings::MISSING_DATA(std::numeric_limits<double>::max());
209 : RGBColor GUIVisualizationSettings::COL_MISSING_DATA(225, 225, 225);
210 :
211 : std::map<std::string, std::vector<RGBColor> > GUIVisualizationSettings::RAINBOW_SCHEMES({
212 : // cannot use predefined colors to avoid "static initialization order fiasco"
213 : {"classic", std::vector<RGBColor>({RGBColor(255, 0, 0), RGBColor(255, 128, 0), RGBColor(255, 255, 0), RGBColor(0, 255, 0), RGBColor(0, 255, 255), RGBColor(0, 0, 255), RGBColor(255, 0, 255)})},
214 : {"YlOrRd", std::vector<RGBColor>({RGBColor(255, 255, 178), RGBColor(254, 217, 118), RGBColor(254, 178, 76), RGBColor(253, 141, 60), RGBColor(252, 78, 42), RGBColor(227, 26, 28), RGBColor(177, 0, 38)})},
215 : {"RdBu", std::vector<RGBColor>({RGBColor(178, 24, 43), RGBColor(239, 138, 98), RGBColor(253, 219, 199), RGBColor(247, 247, 247), RGBColor(209, 229, 240), RGBColor(103, 169, 207), RGBColor(33, 102, 172)})},
216 : });
217 :
218 : // color constants for scheme background
219 : #define COL_SCHEME_EMISSION RGBColor(255,255,210)
220 : #define COL_SCHEME_MISC RGBColor(210,220,255)
221 : #define COL_SCHEME_STATIC RGBColor(230,230,230)
222 : #define COL_SCHEME_DYNAMIC RGBColor(220,255,220)
223 :
224 : // ===========================================================================
225 : // member method definitions
226 : // ===========================================================================
227 :
228 : // ---------------------------------------------------------------------------
229 : // GUIVisualizationTextSettings - methods
230 : // ---------------------------------------------------------------------------
231 :
232 2339012 : GUIVisualizationTextSettings::GUIVisualizationTextSettings(bool _showText, double _size, RGBColor _color, RGBColor _bgColor, bool _constSize, bool _onlySelected) :
233 2339012 : showText(_showText),
234 2339012 : size(_size),
235 2339012 : color(_color),
236 2339012 : bgColor(_bgColor),
237 2339012 : constSize(_constSize),
238 2339012 : onlySelected(_onlySelected) {
239 2339012 : }
240 :
241 :
242 : bool
243 0 : GUIVisualizationTextSettings::operator==(const GUIVisualizationTextSettings& other) {
244 0 : return (showText == other.showText) &&
245 0 : (size == other.size) &&
246 0 : (color == other.color) &&
247 0 : (bgColor == other.bgColor) &&
248 0 : (constSize == other.constSize) &&
249 0 : (onlySelected == other.onlySelected);
250 : }
251 :
252 :
253 : bool
254 0 : GUIVisualizationTextSettings::operator!=(const GUIVisualizationTextSettings& other) {
255 0 : return (showText != other.showText) ||
256 0 : (size != other.size) ||
257 0 : (color != other.color) ||
258 0 : (bgColor != other.bgColor) ||
259 0 : (constSize != other.constSize) ||
260 0 : (onlySelected != other.onlySelected);
261 : }
262 :
263 :
264 : void
265 0 : GUIVisualizationTextSettings::print(OutputDevice& dev, const std::string& name) const {
266 0 : dev.writeAttr(name + "_show", showText);
267 0 : dev.writeAttr(name + "_size", size);
268 0 : dev.writeAttr(name + "_color", color);
269 0 : dev.writeAttr(name + "_bgColor", bgColor);
270 0 : dev.writeAttr(name + "_constantSize", constSize);
271 0 : dev.writeAttr(name + "_onlySelected", onlySelected);
272 0 : }
273 :
274 :
275 : double
276 0 : GUIVisualizationTextSettings::scaledSize(double scale, double constFactor) const {
277 0 : return constSize ? (size / scale) : (size * constFactor);
278 : }
279 :
280 :
281 : bool
282 311397506 : GUIVisualizationTextSettings::show(const GUIGlObject* o) const {
283 311397506 : return showText && (!onlySelected || o == nullptr || gSelected.isSelected(o));
284 : }
285 :
286 : // ---------------------------------------------------------------------------
287 : // GUIVisualizationRainbowSettings - methods
288 : // ---------------------------------------------------------------------------
289 :
290 322597 : GUIVisualizationRainbowSettings::GUIVisualizationRainbowSettings(bool _hideMin, double _minThreshold, bool _hideMax, double _maxThreshold, bool _setNeutral,
291 322597 : double _neutralThreshold, bool _fixRange, int _rainbowScheme) :
292 322597 : hideMin(_hideMin),
293 322597 : minThreshold(_minThreshold),
294 322597 : hideMax(_hideMax),
295 322597 : maxThreshold(_maxThreshold),
296 322597 : setNeutral(_setNeutral),
297 322597 : neutralThreshold(_neutralThreshold),
298 322597 : fixRange(_fixRange),
299 322597 : rainbowScheme(_rainbowScheme),
300 322597 : colors(GUIVisualizationSettings::RAINBOW_SCHEMES["classic"])
301 322597 : { }
302 :
303 :
304 : bool
305 0 : GUIVisualizationRainbowSettings::operator==(const GUIVisualizationRainbowSettings& other) {
306 0 : return (hideMin == other.hideMin) &&
307 0 : (minThreshold == other.minThreshold) &&
308 0 : (hideMin == other.hideMin) &&
309 0 : (maxThreshold == other.maxThreshold) &&
310 0 : (setNeutral == other.setNeutral) &&
311 0 : (neutralThreshold == other.neutralThreshold) &&
312 0 : (fixRange == other.fixRange) &&
313 0 : (rainbowScheme == other.rainbowScheme);
314 : }
315 :
316 :
317 : bool
318 0 : GUIVisualizationRainbowSettings::operator!=(const GUIVisualizationRainbowSettings& other) {
319 0 : return !((*this) == other);
320 : }
321 :
322 :
323 : void
324 0 : GUIVisualizationRainbowSettings::print(OutputDevice& dev, const std::string& name) const {
325 0 : dev.writeAttr(name + "HideCheck", hideMin);
326 0 : dev.writeAttr(name + "HideThreshold", minThreshold);
327 0 : dev.writeAttr(name + "HideCheck2", hideMax);
328 0 : dev.writeAttr(name + "HideThreshold2", maxThreshold);
329 0 : dev.writeAttr(name + "SetNeutral", setNeutral);
330 0 : dev.writeAttr(name + "NeutralThreshold", neutralThreshold);
331 0 : dev.writeAttr(name + "FixRange", fixRange);
332 0 : dev.writeAttr(name + "RainbowScheme", rainbowScheme);
333 0 : }
334 :
335 :
336 : // ---------------------------------------------------------------------------
337 : // GUIVisualizationSizeSettings - methods
338 : // ---------------------------------------------------------------------------
339 :
340 564584 : GUIVisualizationSizeSettings::GUIVisualizationSizeSettings(double _minSize, double _exaggeration, bool _constantSize, bool _constantSizeSelected) :
341 564584 : minSize(_minSize),
342 564584 : exaggeration(_exaggeration),
343 564584 : constantSize(_constantSize),
344 564584 : constantSizeSelected(_constantSizeSelected) {
345 564584 : }
346 :
347 :
348 : double
349 130708197 : GUIVisualizationSizeSettings::getExaggeration(const GUIVisualizationSettings& s, const GUIGlObject* o, double factor) const {
350 : // declare exaggeration final
351 : double exaggerationFinal;
352 : /// @note should look normal-sized at zoom 1000
353 130708197 : if (constantSize && (!constantSizeSelected || (o == nullptr) || gSelected.isSelected(o))) {
354 0 : exaggerationFinal = MAX2(exaggeration, exaggeration * factor / s.scale);
355 130708197 : } else if (!constantSizeSelected || (o == nullptr) || gSelected.isSelected(o)) {
356 130708197 : exaggerationFinal = exaggeration;
357 : } else {
358 : exaggerationFinal = 1;
359 : }
360 130708197 : if (o != nullptr) {
361 22911437 : exaggerationFinal *= o->getScaleVisual();
362 : }
363 : // add selectorFrameScale
364 22911437 : if ((o != nullptr) && gSelected.isSelected(o)) {
365 546 : return (exaggerationFinal * s.selectorFrameScale);
366 : } else {
367 130707651 : return exaggerationFinal;
368 : }
369 : }
370 :
371 :
372 : bool
373 0 : GUIVisualizationSizeSettings::operator==(const GUIVisualizationSizeSettings& other) {
374 0 : return (constantSize == other.constantSize) &&
375 0 : (constantSizeSelected == other.constantSizeSelected) &&
376 0 : (minSize == other.minSize) &&
377 0 : (exaggeration == other.exaggeration);
378 : }
379 :
380 :
381 : bool
382 0 : GUIVisualizationSizeSettings::operator!=(const GUIVisualizationSizeSettings& other) {
383 0 : return (constantSize != other.constantSize) ||
384 0 : (constantSizeSelected != other.constantSizeSelected) ||
385 0 : (minSize != other.minSize) ||
386 0 : (exaggeration != other.exaggeration);
387 : }
388 :
389 :
390 : void
391 0 : GUIVisualizationSizeSettings::print(OutputDevice& dev, const std::string& name) const {
392 0 : dev.writeAttr(name + "_minSize", minSize);
393 0 : dev.writeAttr(name + "_exaggeration", exaggeration);
394 0 : dev.writeAttr(name + "_constantSize", constantSize);
395 0 : dev.writeAttr(name + "_constantSizeSelected", constantSizeSelected);
396 0 : }
397 :
398 : // ---------------------------------------------------------------------------
399 : // GUIVisualizationColorSettings - methods
400 : // ---------------------------------------------------------------------------
401 :
402 80623 : GUIVisualizationColorSettings::GUIVisualizationColorSettings() :
403 80623 : selectionColor(0, 0, 204, 255),
404 80623 : selectedEdgeColor(0, 0, 204, 255),
405 80623 : selectedLaneColor(0, 0, 128, 255),
406 80623 : selectedConnectionColor(0, 0, 100, 255),
407 80623 : selectedProhibitionColor(0, 0, 120, 255),
408 80623 : selectedCrossingColor(0, 100, 196, 255),
409 80623 : selectedAdditionalColor(0, 0, 150, 255),
410 80623 : selectedRouteColor(0, 0, 150, 255),
411 80623 : selectedVehicleColor(0, 0, 100, 255),
412 80623 : selectedPersonColor(0, 0, 120, 255),
413 80623 : selectedPersonPlanColor(0, 0, 130, 255),
414 80623 : selectedContainerColor(0, 0, 120, 255),
415 80623 : selectedContainerPlanColor(0, 0, 130, 255),
416 80623 : selectedEdgeDataColor(0, 0, 150, 255),
417 80623 : busStopColor(76, 170, 50),
418 80623 : busStopColorSign(255, 235, 0),
419 80623 : trainStopColor(76, 170, 50),
420 80623 : trainStopColorSign(255, 235, 0),
421 80623 : containerStopColor(83, 89, 172),
422 80623 : containerStopColorSign(177, 184, 186, 171),
423 80623 : chargingStationColor(114, 210, 252),
424 80623 : chargingStationColorSign(255, 235, 0),
425 80623 : chargingStationColorCharge(255, 180, 0),
426 80623 : parkingAreaColor(83, 89, 172),
427 80623 : parkingAreaColorSign(177, 184, 186),
428 80623 : parkingSpaceColorContour(0, 255, 0),
429 80623 : parkingSpaceColor(255, 200, 200),
430 80623 : stopColor(220, 20, 30),
431 80623 : waypointColor(0, 127, 14),
432 80623 : vehicleTripColor(255, 128, 0),
433 80623 : stopPersonColor(255, 0, 0),
434 80623 : personTripColor(200, 0, 255),
435 80623 : walkColor(0, 255, 0),
436 80623 : rideColor(0, 0, 255),
437 80623 : stopContainerColor(255, 0, 0),
438 80623 : transportColor(100, 200, 0),
439 80623 : transhipColor(100, 0, 200) {
440 80623 : }
441 :
442 :
443 : bool
444 0 : GUIVisualizationColorSettings::operator==(const GUIVisualizationColorSettings& v2) {
445 0 : return (selectionColor == v2.selectionColor) &&
446 0 : (selectedEdgeColor == v2.selectedEdgeColor) &&
447 0 : (selectedLaneColor == v2.selectedLaneColor) &&
448 0 : (selectedConnectionColor == v2.selectedConnectionColor) &&
449 0 : (selectedProhibitionColor == v2.selectedProhibitionColor) &&
450 0 : (selectedCrossingColor == v2.selectedCrossingColor) &&
451 0 : (selectedAdditionalColor == v2.selectedAdditionalColor) &&
452 0 : (selectedRouteColor == v2.selectedRouteColor) &&
453 0 : (selectedVehicleColor == v2.selectedVehicleColor) &&
454 0 : (selectedPersonColor == v2.selectedPersonColor) &&
455 0 : (selectedContainerColor == v2.selectedContainerColor) &&
456 0 : (selectedPersonPlanColor == v2.selectedPersonPlanColor) &&
457 0 : (selectedEdgeDataColor == v2.selectedEdgeDataColor) &&
458 0 : (busStopColor == v2.busStopColor) &&
459 0 : (busStopColorSign == v2.busStopColorSign) &&
460 0 : (trainStopColor == v2.trainStopColor) &&
461 0 : (trainStopColorSign == v2.trainStopColorSign) &&
462 0 : (containerStopColor == v2.containerStopColor) &&
463 0 : (containerStopColorSign == v2.containerStopColorSign) &&
464 0 : (chargingStationColor == v2.chargingStationColor) &&
465 0 : (chargingStationColorSign == v2.chargingStationColorSign) &&
466 0 : (chargingStationColorCharge == v2.chargingStationColorCharge) &&
467 0 : (parkingAreaColor == v2.parkingAreaColor) &&
468 0 : (parkingAreaColorSign == v2.parkingAreaColorSign) &&
469 0 : (parkingSpaceColorContour == v2.parkingSpaceColorContour) &&
470 0 : (parkingSpaceColor == v2.parkingSpaceColor) &&
471 0 : (stopColor == v2.stopColor) &&
472 0 : (waypointColor == v2.waypointColor) &&
473 0 : (vehicleTripColor == v2.vehicleTripColor) &&
474 0 : (stopPersonColor == v2.stopPersonColor) &&
475 0 : (personTripColor == v2.personTripColor) &&
476 0 : (walkColor == v2.walkColor) &&
477 0 : (rideColor == v2.rideColor) &&
478 0 : (stopContainerColor == v2.stopContainerColor) &&
479 0 : (transportColor == v2.transportColor) &&
480 0 : (transhipColor == v2.transhipColor);
481 : }
482 :
483 :
484 : bool
485 0 : GUIVisualizationColorSettings::operator!=(const GUIVisualizationColorSettings& v2) {
486 0 : return (selectionColor != v2.selectionColor) ||
487 0 : (selectedEdgeColor != v2.selectedEdgeColor) ||
488 0 : (selectedLaneColor != v2.selectedLaneColor) ||
489 0 : (selectedConnectionColor != v2.selectedConnectionColor) ||
490 0 : (selectedProhibitionColor != v2.selectedProhibitionColor) ||
491 0 : (selectedCrossingColor != v2.selectedCrossingColor) ||
492 0 : (selectedAdditionalColor != v2.selectedAdditionalColor) ||
493 0 : (selectedRouteColor != v2.selectedRouteColor) ||
494 0 : (selectedVehicleColor != v2.selectedVehicleColor) ||
495 0 : (selectedPersonColor != v2.selectedPersonColor) ||
496 0 : (selectedContainerColor != v2.selectedContainerColor) ||
497 0 : (selectedPersonPlanColor != v2.selectedPersonPlanColor) ||
498 0 : (selectedEdgeDataColor != v2.selectedEdgeDataColor) ||
499 0 : (busStopColor != v2.busStopColor) ||
500 0 : (busStopColorSign != v2.busStopColorSign) ||
501 0 : (trainStopColor != v2.trainStopColor) ||
502 0 : (trainStopColorSign != v2.trainStopColorSign) ||
503 0 : (containerStopColor != v2.containerStopColor) ||
504 0 : (containerStopColorSign != v2.containerStopColorSign) ||
505 0 : (chargingStationColor != v2.chargingStationColor) ||
506 0 : (chargingStationColorSign != v2.chargingStationColorSign) ||
507 0 : (chargingStationColorCharge != v2.chargingStationColorCharge) ||
508 0 : (parkingAreaColor != v2.parkingAreaColor) ||
509 0 : (parkingAreaColorSign != v2.parkingAreaColorSign) ||
510 0 : (parkingSpaceColorContour != v2.parkingSpaceColorContour) ||
511 0 : (parkingSpaceColor != v2.parkingSpaceColor) ||
512 0 : (stopColor != v2.stopColor) ||
513 0 : (waypointColor != v2.waypointColor) ||
514 0 : (vehicleTripColor != v2.vehicleTripColor) ||
515 0 : (stopPersonColor != v2.stopPersonColor) ||
516 0 : (personTripColor != v2.personTripColor) ||
517 0 : (walkColor != v2.walkColor) ||
518 0 : (rideColor != v2.rideColor) ||
519 0 : (stopContainerColor != v2.stopContainerColor) ||
520 0 : (transportColor != v2.transportColor) ||
521 0 : (transhipColor != v2.transhipColor);
522 : }
523 :
524 : // ---------------------------------------------------------------------------
525 : // GUIVisualizationWidthSettings - methods
526 : // ---------------------------------------------------------------------------
527 :
528 80623 : GUIVisualizationWidthSettings::GUIVisualizationWidthSettings() :
529 80623 : tripWidth(0.2),
530 80623 : personTripWidth(0.25),
531 80623 : walkWidth(0.25),
532 80623 : rideWidth(0.25),
533 80623 : transportWidth(0.25),
534 80623 : transhipWidth(0.25) {
535 80623 : }
536 :
537 :
538 : bool
539 0 : GUIVisualizationWidthSettings::operator==(const GUIVisualizationWidthSettings& v2) {
540 0 : return (tripWidth == v2.tripWidth) &&
541 0 : (personTripWidth == v2.personTripWidth) &&
542 0 : (walkWidth == v2.walkWidth) &&
543 0 : (rideWidth == v2.rideWidth) &&
544 0 : (transportWidth == v2.transportWidth) &&
545 0 : (transhipWidth == v2.transhipWidth);
546 : }
547 :
548 :
549 : bool
550 0 : GUIVisualizationWidthSettings::operator!=(const GUIVisualizationWidthSettings& v2) {
551 0 : return (tripWidth != v2.tripWidth) ||
552 0 : (personTripWidth != v2.personTripWidth) ||
553 0 : (walkWidth != v2.walkWidth) ||
554 0 : (rideWidth != v2.rideWidth) ||
555 0 : (transportWidth != v2.transportWidth) ||
556 0 : (transhipWidth != v2.transhipWidth);
557 : }
558 :
559 : // ---------------------------------------------------------------------------
560 : // GUIVisualizationWidthSettings - methods
561 : // ---------------------------------------------------------------------------
562 :
563 80623 : GUIVisualizationSettings::GUIVisualizationSettings(const std::string& _name, bool _netedit) :
564 80623 : name(_name),
565 80623 : netedit(_netedit),
566 80623 : angle(0),
567 80623 : dither(false),
568 80623 : fps(false),
569 80623 : trueZ(false),
570 80623 : backgroundColor(RGBColor::WHITE),
571 80623 : showGrid(false), gridXSize(100), gridYSize(100),
572 80623 : laneShowBorders(false), showBikeMarkings(true), showLinkDecals(true),
573 80623 : realisticLinkRules(false),
574 80623 : showLinkRules(true),
575 80623 : showRails(true),
576 80623 : edgeName(false, 60, RGBColor::ORANGE),
577 80623 : internalEdgeName(false, 45, RGBColor(128, 64, 0, 255)),
578 80623 : cwaEdgeName(false, 60, RGBColor::MAGENTA),
579 80623 : streetName(false, 60, RGBColor::YELLOW),
580 80623 : edgeValue(false, 100, RGBColor::CYAN),
581 80623 : edgeScaleValue(false, 100, RGBColor::BLUE),
582 80623 : hideConnectors(false),
583 80623 : laneWidthExaggeration(1),
584 80623 : laneMinSize(0),
585 80623 : showLaneDirection(false),
586 80623 : showSublanes(true),
587 80623 : spreadSuperposed(false),
588 80623 : disableHideByZoom(true),
589 80623 : edgeParam("EDGE_KEY"),
590 80623 : laneParam("LANE_KEY"),
591 80623 : vehicleParam("PARAM_NUMERICAL"),
592 80623 : vehicleScaleParam("PARAM_NUMERICAL"),
593 80623 : vehicleTextParam("PARAM_TEXT"),
594 80623 : edgeData("speed"),
595 80623 : edgeDataID(""),
596 80623 : edgeDataScaling(""),
597 80623 : edgeValueRainBow(false, 0, false, 200, false, 0, false, 1),
598 80623 : vehicleQuality(0), showBlinker(true),
599 80623 : drawLaneChangePreference(false),
600 80623 : drawMinGap(false),
601 80623 : drawBrakeGap(false),
602 80623 : showBTRange(false),
603 80623 : showRouteIndex(false),
604 80623 : scaleLength(true),
605 80623 : drawReversed(false),
606 80623 : showParkingInfo(false),
607 80623 : showChargingInfo(false),
608 80623 : vehicleSize(1),
609 80623 : vehicleName(false, 60, RGBColor(204, 153, 0, 255)),
610 80623 : vehicleValue(false, 80, RGBColor::CYAN),
611 80623 : vehicleScaleValue(false, 80, RGBColor::GREY),
612 80623 : vehicleText(false, 80, RGBColor::RED),
613 80623 : vehicleValueRainBow(false, 0, false, 100, false, 0, false, 1),
614 80623 : personQuality(netedit ? 2 : 0),
615 80623 : personSize(1),
616 80623 : personName(false, 60, RGBColor(0, 153, 204, 255)),
617 80623 : personValue(false, 80, RGBColor::CYAN),
618 80623 : showPedestrianNetwork(true),
619 80623 : pedestrianNetworkColor(RGBColor(179, 217, 255)),
620 80623 : containerQuality(0),
621 80623 : containerSize(1),
622 80623 : containerName(false, 60, RGBColor(0, 153, 204, 255)),
623 80623 : drawLinkTLIndex(false, 65, RGBColor(128, 128, 255, 255), RGBColor::INVISIBLE, false),
624 80623 : drawLinkJunctionIndex(false, 65, RGBColor(128, 128, 255, 255), RGBColor::INVISIBLE, false),
625 80623 : junctionID(false, 60, RGBColor(0, 255, 128, 255)),
626 80623 : junctionName(false, 60, RGBColor(192, 255, 128, 255)),
627 80623 : internalJunctionName(false, 50, RGBColor(0, 204, 128, 255)),
628 80623 : tlsPhaseIndex(false, 150, RGBColor::YELLOW),
629 80623 : tlsPhaseName(false, 150, RGBColor::ORANGE),
630 80623 : showLane2Lane(false),
631 80623 : drawJunctionShape(true),
632 80623 : drawCrossingsAndWalkingareas(true),
633 80623 : junctionSize(1),
634 80623 : junctionValueRainBow(false, 0, false, 100, false, 0, false, 1),
635 80623 : addMode(0),
636 80623 : addSize(1),
637 80623 : addName(false, 60, RGBColor(255, 0, 128, 255)),
638 80623 : addFullName(false, 60, RGBColor(255, 0, 128, 255)),
639 80623 : poiSize(0),
640 80623 : poiDetail(16),
641 80623 : poiName(false, 50, RGBColor(0, 127, 70, 255)),
642 80623 : poiType(false, 60, RGBColor(0, 127, 70, 255)),
643 80623 : poiText(false, 80, RGBColor(140, 0, 255, 255)),
644 80623 : poiTextParam("PARAM_TEXT"),
645 80623 : poiUseCustomLayer(false),
646 80623 : poiCustomLayer(0),
647 80623 : polySize(0), polyName(false, 50, RGBColor(255, 0, 128, 255)),
648 80623 : polyType(false, 60, RGBColor(255, 0, 128, 255)),
649 80623 : polyUseCustomLayer(false),
650 80623 : polyCustomLayer(0),
651 80623 : dataValue(false, 100, RGBColor::CYAN),
652 80623 : tazRelWidthExaggeration(1),
653 80623 : edgeRelWidthExaggeration(1),
654 80623 : relDataAttr("count"),
655 80623 : relDataScaleAttr("count"),
656 80623 : dataValueRainBow(false, -100, false, 100, false, 0, false, 1),
657 80623 : ignoreColorSchemeFor3DVehicles(false),
658 80623 : show3DTLSLinkMarkers(true),
659 80623 : show3DTLSDomes(true),
660 80623 : generate3DTLSModels(false),
661 80623 : show3DHeadUpDisplay(true),
662 80623 : ambient3DLight(OSG_color_AMBIENT),
663 80623 : diffuse3DLight(OSG_color_DIFFUSE),
664 80623 : skyColor(OSG_color_SKY),
665 80623 : showSizeLegend(true),
666 80623 : showColorLegend(false),
667 80623 : showVehicleColorLegend(false),
668 80623 : gaming(false),
669 80623 : drawBoundaries(false),
670 80623 : selectorFrameScale(1.),
671 80623 : drawForViewObjectsHandler(false),
672 80623 : drawForRectangleSelection(false),
673 80623 : forceDrawForRectangleSelection(false),
674 80623 : disableDottedContours(false),
675 80623 : geometryIndices(false, 50, RGBColor(255, 0, 128, 255)),
676 80623 : secondaryShape(false),
677 80623 : lefthand(false),
678 80623 : disableLaneIcons(false),
679 80623 : myIgnoreHideByZoom(false) {
680 : // init defaults depending of netedit or SUMO-GUI
681 80623 : if (netedit) {
682 0 : initNeteditDefaults();
683 : } else {
684 80623 : initSumoGuiDefaults();
685 : }
686 80623 : }
687 :
688 :
689 : bool
690 0 : GUIVisualizationSettings::checkDrawJunction(const Boundary& b, const bool selected) const {
691 0 : if (drawForViewObjectsHandler) {
692 : return false;
693 0 : } else if (junctionSize.constantSize) {
694 : return true;
695 0 : } else if (junctionSize.constantSizeSelected && selected) {
696 : return true;
697 0 : } else if (drawLinkTLIndex.showText && drawLinkTLIndex.constSize) {
698 : return true;
699 0 : } else if (drawLinkJunctionIndex.showText && drawLinkJunctionIndex.constSize) {
700 : return true;
701 0 : } else if (junctionID.showText && junctionID.constSize) {
702 : return true;
703 0 : } else if (junctionName.showText && junctionName.constSize) {
704 : return true;
705 0 : } else if (internalJunctionName.showText && internalJunctionName.constSize) {
706 : return true;
707 0 : } else if (tlsPhaseIndex.showText && tlsPhaseIndex.constSize) {
708 : return true;
709 0 : } else if (tlsPhaseName.showText && tlsPhaseName.constSize) {
710 : return true;
711 : } else {
712 0 : return (scale * MAX2(b.getWidth(), b.getHeight())) > BoundarySizeDrawing;
713 : }
714 : }
715 :
716 :
717 : bool
718 0 : GUIVisualizationSettings::checkDrawEdge(const Boundary& b) const {
719 0 : if (drawForViewObjectsHandler) {
720 : // needed if we're selecting using a rectangle
721 : return true;
722 0 : } else if (disableHideByZoom) {
723 : return true;
724 0 : } else if (myIgnoreHideByZoom) {
725 : return true;
726 : } else {
727 0 : return (scale * MAX2(b.getWidth(), b.getHeight())) > BoundarySizeDrawing;
728 : }
729 : }
730 :
731 :
732 : void
733 0 : GUIVisualizationSettings::updateIgnoreHideByZoom() {
734 : // general
735 0 : if (disableHideByZoom) {
736 0 : myIgnoreHideByZoom = true;
737 : // junctions
738 0 : } else if (junctionSize.constantSize && junctionSize.constantSizeSelected) {
739 0 : myIgnoreHideByZoom = true;
740 0 : } else if (drawLinkTLIndex.showText && drawLinkTLIndex.constSize) {
741 0 : myIgnoreHideByZoom = true;
742 0 : } else if (drawLinkJunctionIndex.showText && drawLinkJunctionIndex.constSize) {
743 0 : myIgnoreHideByZoom = true;
744 0 : } else if (junctionID.showText && junctionID.constSize) {
745 0 : myIgnoreHideByZoom = true;
746 0 : } else if (junctionName.showText && junctionName.constSize) {
747 0 : myIgnoreHideByZoom = true;
748 0 : } else if (internalJunctionName.showText && internalJunctionName.constSize) {
749 0 : myIgnoreHideByZoom = true;
750 0 : } else if (tlsPhaseIndex.showText && tlsPhaseIndex.constSize) {
751 0 : myIgnoreHideByZoom = true;
752 0 : } else if (tlsPhaseName.showText && tlsPhaseName.constSize) {
753 0 : myIgnoreHideByZoom = true;
754 : // edges
755 0 : } else if (edgeName.showText) {
756 0 : myIgnoreHideByZoom = true;
757 0 : } else if (internalEdgeName.showText && internalEdgeName.constSize) {
758 0 : myIgnoreHideByZoom = true;
759 0 : } else if (cwaEdgeName.showText && cwaEdgeName.constSize) {
760 0 : myIgnoreHideByZoom = true;
761 0 : } else if (streetName.showText && streetName.constSize) {
762 0 : myIgnoreHideByZoom = true;
763 0 : } else if (edgeValue.showText && edgeValue.constSize) {
764 0 : myIgnoreHideByZoom = true;
765 0 : } else if (edgeScaleValue.showText && edgeScaleValue.constSize) {
766 0 : myIgnoreHideByZoom = true;
767 : // additionals
768 0 : } else if (addSize.constantSize) {
769 0 : myIgnoreHideByZoom = true;
770 0 : } else if (addSize.constantSizeSelected) {
771 0 : myIgnoreHideByZoom = true;
772 0 : } else if (addName.showText && addName.constSize) {
773 0 : myIgnoreHideByZoom = true;
774 0 : } else if (addFullName.showText && addFullName.constSize) {
775 0 : myIgnoreHideByZoom = true;
776 : // POIs
777 0 : } else if (poiSize.constantSize) {
778 0 : myIgnoreHideByZoom = true;
779 0 : } else if (poiSize.constantSizeSelected) {
780 0 : myIgnoreHideByZoom = true;
781 0 : } else if (poiName.showText && poiName.constSize) {
782 0 : myIgnoreHideByZoom = true;
783 0 : } else if (poiType.showText && poiType.constSize) {
784 0 : myIgnoreHideByZoom = true;
785 0 : } else if (poiText.showText && poiText.constSize) {
786 0 : myIgnoreHideByZoom = true;
787 : // vehicles
788 0 : } else if (vehicleSize.constantSize) {
789 0 : myIgnoreHideByZoom = true;
790 0 : } else if (vehicleSize.constantSizeSelected) {
791 0 : myIgnoreHideByZoom = true;
792 0 : } else if (vehicleName.showText && vehicleName.constSize) {
793 0 : myIgnoreHideByZoom = true;
794 0 : } else if (vehicleValue.showText && vehicleValue.constSize) {
795 0 : myIgnoreHideByZoom = true;
796 0 : } else if (vehicleScaleValue.showText && vehicleScaleValue.constSize) {
797 0 : myIgnoreHideByZoom = true;
798 0 : } else if (vehicleText.showText && vehicleText.constSize) {
799 0 : myIgnoreHideByZoom = true;
800 : // persons
801 0 : } else if (personSize.constantSize) {
802 0 : myIgnoreHideByZoom = true;
803 0 : } else if (personSize.constantSizeSelected) {
804 0 : myIgnoreHideByZoom = true;
805 0 : } else if (personName.showText && personName.constSize) {
806 0 : myIgnoreHideByZoom = true;
807 0 : } else if (personValue.showText && personValue.constSize) {
808 0 : myIgnoreHideByZoom = true;
809 : // containers
810 0 : } else if (containerSize.constantSize) {
811 0 : myIgnoreHideByZoom = true;
812 0 : } else if (containerSize.constantSizeSelected) {
813 0 : myIgnoreHideByZoom = true;
814 0 : } else if (containerName.showText && containerName.constSize) {
815 0 : myIgnoreHideByZoom = true;
816 : } else {
817 0 : myIgnoreHideByZoom = false;
818 : }
819 0 : }
820 :
821 :
822 : bool
823 0 : GUIVisualizationSettings::checkDrawAdditional(const Detail d, const bool selected) const {
824 0 : if (drawForViewObjectsHandler) {
825 : return false;
826 0 : } else if (myIgnoreHideByZoom) {
827 : return true;
828 0 : } else if (addSize.constantSize) {
829 : return true;
830 0 : } else if (addSize.constantSizeSelected && selected) {
831 : return true;
832 0 : } else if (addName.showText && addName.constSize) {
833 : return true;
834 0 : } else if (addFullName.showText && addFullName.constSize) {
835 : return true;
836 : } else {
837 0 : return d <= GUIVisualizationSettings::Detail::Additionals;
838 : }
839 : }
840 :
841 :
842 : bool
843 0 : GUIVisualizationSettings::checkDrawPoly(const Boundary& b, const bool selected) const {
844 0 : if (drawForViewObjectsHandler) {
845 : return false;
846 0 : } else if (myIgnoreHideByZoom) {
847 : return true;
848 0 : } else if (polySize.constantSize) {
849 : return true;
850 0 : } else if (polySize.constantSizeSelected && selected) {
851 : return true;
852 0 : } else if (polyName.showText && polyName.constSize) {
853 : return true;
854 0 : } else if (polyType.showText && polyType.constSize) {
855 : return true;
856 : } else {
857 0 : return (scale * MAX2(b.getWidth(), b.getHeight())) > BoundarySizeDrawing;
858 : }
859 : }
860 :
861 :
862 : bool
863 0 : GUIVisualizationSettings::checkDrawPOI(const double w, const double h, const Detail d, const bool selected) const {
864 0 : if (drawForViewObjectsHandler) {
865 : return false;
866 0 : } else if (myIgnoreHideByZoom) {
867 : return true;
868 0 : } else if (poiSize.constantSize) {
869 : return true;
870 0 : } else if (poiSize.constantSizeSelected && selected) {
871 : return true;
872 0 : } else if (poiName.showText && poiName.constSize) {
873 : return true;
874 0 : } else if (poiType.showText && poiType.constSize) {
875 : return true;
876 0 : } else if (poiText.showText && poiText.constSize) {
877 : return true;
878 0 : } else if ((w > 0) && (h > 0)) {
879 0 : return (scale * MAX2(w, h)) > BoundarySizeDrawing;
880 : } else {
881 0 : return d <= GUIVisualizationSettings::Detail::Additionals;
882 : }
883 : }
884 :
885 :
886 : bool
887 0 : GUIVisualizationSettings::checkDrawVehicle(const Detail d, const bool selected) const {
888 0 : if (drawForViewObjectsHandler) {
889 : return false;
890 0 : } else if (myIgnoreHideByZoom) {
891 : return true;
892 0 : } else if (vehicleSize.constantSize) {
893 : return true;
894 0 : } else if (vehicleSize.constantSizeSelected && selected) {
895 : return true;
896 0 : } else if (vehicleName.showText && vehicleName.constSize) {
897 : return true;
898 0 : } else if (vehicleValue.showText && vehicleValue.constSize) {
899 : return true;
900 0 : } else if (vehicleScaleValue.showText && vehicleScaleValue.constSize) {
901 : return true;
902 0 : } else if (vehicleText.showText && vehicleText.constSize) {
903 : return true;
904 : } else {
905 0 : return d <= GUIVisualizationSettings::Detail::Additionals;
906 : }
907 : }
908 :
909 :
910 : bool
911 0 : GUIVisualizationSettings::checkDrawPerson(const Detail d, const bool selected) const {
912 0 : if (drawForViewObjectsHandler) {
913 : return false;
914 0 : } else if (myIgnoreHideByZoom) {
915 : return true;
916 0 : } else if (personSize.constantSize) {
917 : return true;
918 0 : } else if (personSize.constantSizeSelected && selected) {
919 : return true;
920 0 : } else if (personName.showText && personName.constSize) {
921 : return true;
922 0 : } else if (personValue.showText && personValue.constSize) {
923 : return true;
924 : } else {
925 0 : return d <= GUIVisualizationSettings::Detail::Additionals;
926 : }
927 : }
928 :
929 :
930 : bool
931 0 : GUIVisualizationSettings::checkDrawContainer(const Detail d, const bool selected) const {
932 0 : if (drawForViewObjectsHandler) {
933 : return false;
934 0 : } else if (myIgnoreHideByZoom) {
935 : return true;
936 0 : } else if (containerSize.constantSize) {
937 : return true;
938 0 : } else if (containerSize.constantSizeSelected && selected) {
939 : return true;
940 0 : } else if (containerName.showText && containerName.constSize) {
941 : return true;
942 : } else {
943 0 : return d <= GUIVisualizationSettings::Detail::Additionals;
944 : }
945 : }
946 :
947 :
948 : void
949 40310 : GUIVisualizationSettings::copy(const GUIVisualizationSettings& s) {
950 : // just copy. Note: By default = operator is disabled to avoid accidental copies)
951 40310 : *this = s;
952 40310 : }
953 :
954 :
955 : void
956 80623 : GUIVisualizationSettings::initSumoGuiDefaults() {
957 : /// add lane coloring schemes
958 161246 : GUIColorScheme scheme = GUIColorScheme("uniform", TL("uniform"), RGBColor::BLACK, TL("road"), true, 0);
959 80623 : scheme.addColor(RGBColor::GREY, 1, TL("sidewalk"));
960 80623 : scheme.addColor(RGBColor(192, 66, 44), 2, TL("bike lane"));
961 80623 : scheme.addColor(RGBColor(0, 0, 0, 0), 3, TL("green verge"));
962 80623 : scheme.addColor(RGBColor(150, 200, 200), 4, TL("waterway"));
963 80623 : scheme.addColor(RGBColor::BLACK, 5, TL("railway"));
964 80623 : scheme.addColor(RGBColor(64, 0, 64), 6, TL("rails on road"));
965 80623 : scheme.addColor(RGBColor(92, 92, 92), 7, TL("no passenger")); // paths, service roads etc
966 80623 : scheme.addColor(RGBColor::RED, 8, TL("closed")); // road closing
967 80623 : scheme.addColor(RGBColor::GREEN, 9, TL("connector")); // macro-connector
968 80623 : scheme.addColor(RGBColor::ORANGE, 10, TL("forbidden")); // forbidden road
969 80623 : scheme.addColor(RGBColor(200, 240, 240), 11, TL("airway"));
970 161246 : laneColorer.addScheme(scheme);
971 161246 : scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(128, 128, 128, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
972 80623 : scheme.addColor(RGBColor(0, 80, 180, 255), 1, TL("selected"));
973 161246 : laneColorer.addScheme(scheme);
974 161246 : scheme = GUIColorScheme(SCHEME_NAME_PERMISSION_CODE, TL(SCHEME_NAME_PERMISSION_CODE.c_str()), RGBColor(240, 240, 240), "nobody");
975 80623 : scheme.addColor(RGBColor(10, 10, 10), (double)SVC_PASSENGER, "passenger");
976 80623 : scheme.addColor(RGBColor(128, 128, 128), (double)SVC_PEDESTRIAN, "pedestrian");
977 80623 : scheme.addColor(RGBColor(80, 80, 80), (double)(SVC_PEDESTRIAN | SVC_DELIVERY), "pedestrian_delivery");
978 80623 : scheme.addColor(RGBColor(192, 66, 44), (double)SVC_BICYCLE, "bicycle");
979 80623 : scheme.addColor(RGBColor(40, 100, 40), (double)SVC_BUS, "bus");
980 80623 : scheme.addColor(RGBColor(166, 147, 26), (double)SVC_TAXI, "taxi");
981 80623 : scheme.addColor(RGBColor::BLACK, (double)(SVCAll & ~SVC_NON_ROAD), "normal_road");
982 80623 : scheme.addColor(RGBColor::BLACK, (double)(SVCAll & ~(SVC_PEDESTRIAN | SVC_NON_ROAD)), "disallow_pedestrian");
983 80623 : scheme.addColor(RGBColor(255, 206, 0), (double)(SVCAll & ~(SVC_PEDESTRIAN | SVC_BICYCLE | SVC_MOPED | SVC_NON_ROAD)), "motorway");
984 80623 : scheme.addColor(RGBColor(150, 200, 200), (double)SVC_SHIP, "waterway");
985 80623 : scheme.addColor(RGBColor::GREEN, (double)SVCAll, "all");
986 161246 : laneColorer.addScheme(scheme);
987 : // ... traffic states ...
988 161246 : scheme = GUIColorScheme("by allowed speed (lanewise)", TL("by allowed speed (lanewise)"), RGBColor::RED);
989 80623 : scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
990 80623 : scheme.addColor(RGBColor::GREEN, 55. / 3.6);
991 80623 : scheme.addColor(RGBColor::CYAN, 80. / 3.6);
992 80623 : scheme.addColor(RGBColor::BLUE, 120. / 3.6);
993 80623 : scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
994 161246 : laneColorer.addScheme(scheme);
995 161246 : scheme = GUIColorScheme("by current occupancy (lanewise, brutto)", TL("by current occupancy (lanewise, brutto)"), RGBColor(235, 235, 235), "", false, 0, COL_SCHEME_DYNAMIC);
996 80623 : scheme.addColor(RGBColor::GREEN, 0.25);
997 80623 : scheme.addColor(RGBColor::YELLOW, 0.5);
998 80623 : scheme.addColor(RGBColor::ORANGE, 0.75);
999 80623 : scheme.addColor(RGBColor::RED, 1.0);
1000 161246 : laneColorer.addScheme(scheme);
1001 161246 : scheme = GUIColorScheme("by current occupancy (lanewise, netto)", TL("by current occupancy (lanewise, netto)"), RGBColor(235, 235, 235), "", false, 0, COL_SCHEME_DYNAMIC);
1002 80623 : scheme.addColor(RGBColor::GREEN, 0.25);
1003 80623 : scheme.addColor(RGBColor::YELLOW, 0.5);
1004 80623 : scheme.addColor(RGBColor::ORANGE, 0.75);
1005 80623 : scheme.addColor(RGBColor::RED, 1.0);
1006 161246 : laneColorer.addScheme(scheme);
1007 161246 : scheme = GUIColorScheme("by first vehicle waiting time (lanewise)", TL("by first vehicle waiting time (lanewise)"), RGBColor(235, 235, 235), "", false, 0, COL_SCHEME_DYNAMIC);
1008 80623 : scheme.addColor(RGBColor::CYAN, 30.);
1009 80623 : scheme.addColor(RGBColor::GREEN, 100.);
1010 80623 : scheme.addColor(RGBColor::YELLOW, 200.);
1011 80623 : scheme.addColor(RGBColor::RED, 300.);
1012 161246 : laneColorer.addScheme(scheme);
1013 161246 : scheme = GUIColorScheme("by lane number (streetwise)", TL("by lane number (streetwise)"), RGBColor::RED);
1014 80623 : scheme.addColor(RGBColor::BLUE, 5.);
1015 161246 : laneColorer.addScheme(scheme);
1016 : // ... emissions ...
1017 161246 : scheme = GUIColorScheme("by CO2 emissions", TL("by CO2 emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1018 80623 : scheme.addColor(RGBColor::CYAN, 450);
1019 80623 : scheme.addColor(RGBColor::GREEN, 900);
1020 80623 : scheme.addColor(RGBColor::YELLOW, 1350);
1021 80623 : scheme.addColor(RGBColor::ORANGE, 1800);
1022 80623 : scheme.addColor(RGBColor::RED, 2250);
1023 80623 : scheme.addColor(RGBColor::MAGENTA, 3000);
1024 161246 : laneColorer.addScheme(scheme);
1025 161246 : scheme = GUIColorScheme("by CO emissions", TL("by CO emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1026 80623 : scheme.addColor(RGBColor::CYAN, 30);
1027 80623 : scheme.addColor(RGBColor::GREEN, 60);
1028 80623 : scheme.addColor(RGBColor::YELLOW, 90);
1029 80623 : scheme.addColor(RGBColor::ORANGE, 120);
1030 80623 : scheme.addColor(RGBColor::RED, 150);
1031 80623 : scheme.addColor(RGBColor::MAGENTA, 200);
1032 161246 : laneColorer.addScheme(scheme);
1033 161246 : scheme = GUIColorScheme("by PMx emissions", TL("by PMx emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1034 80623 : scheme.addColor(RGBColor::CYAN, 0.3);
1035 80623 : scheme.addColor(RGBColor::GREEN, 0.5);
1036 80623 : scheme.addColor(RGBColor::YELLOW, 0.8);
1037 80623 : scheme.addColor(RGBColor::ORANGE, 1);
1038 80623 : scheme.addColor(RGBColor::RED, 1.3);
1039 80623 : scheme.addColor(RGBColor::MAGENTA, 1.6);
1040 161246 : laneColorer.addScheme(scheme);
1041 161246 : scheme = GUIColorScheme("by NOx emissions", TL("by NOx emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1042 80623 : scheme.addColor(RGBColor::CYAN, 6);
1043 80623 : scheme.addColor(RGBColor::GREEN, 12);
1044 80623 : scheme.addColor(RGBColor::YELLOW, 18);
1045 80623 : scheme.addColor(RGBColor::ORANGE, 24);
1046 80623 : scheme.addColor(RGBColor::RED, 30);
1047 80623 : scheme.addColor(RGBColor::MAGENTA, 40);
1048 161246 : laneColorer.addScheme(scheme);
1049 161246 : scheme = GUIColorScheme("by HC emissions", TL("by HC emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1050 80623 : scheme.addColor(RGBColor::CYAN, 8);
1051 80623 : scheme.addColor(RGBColor::GREEN, 16);
1052 80623 : scheme.addColor(RGBColor::YELLOW, 24);
1053 80623 : scheme.addColor(RGBColor::ORANGE, 32);
1054 80623 : scheme.addColor(RGBColor::RED, 40);
1055 80623 : scheme.addColor(RGBColor::MAGENTA, 50);
1056 161246 : laneColorer.addScheme(scheme);
1057 161246 : scheme = GUIColorScheme("by fuel consumption", TL("by fuel consumption"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1058 80623 : scheme.addColor(RGBColor::CYAN, 0.2);
1059 80623 : scheme.addColor(RGBColor::GREEN, 0.4);
1060 80623 : scheme.addColor(RGBColor::YELLOW, 0.6);
1061 80623 : scheme.addColor(RGBColor::ORANGE, 0.8);
1062 80623 : scheme.addColor(RGBColor::RED, 1);
1063 80623 : scheme.addColor(RGBColor::MAGENTA, 1.3);
1064 161246 : laneColorer.addScheme(scheme);
1065 161246 : scheme = GUIColorScheme("by noise emissions (Harmonoise)", TL("by noise emissions (Harmonoise)"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1066 80623 : scheme.addColor(RGBColor::CYAN, 1.3);
1067 80623 : scheme.addColor(RGBColor::GREEN, 1.4);
1068 80623 : scheme.addColor(RGBColor::YELLOW, 1.6);
1069 80623 : scheme.addColor(RGBColor::ORANGE, 1.7);
1070 80623 : scheme.addColor(RGBColor::RED, 1.9);
1071 80623 : scheme.addColor(RGBColor::MAGENTA, 2.4);
1072 161246 : laneColorer.addScheme(scheme);
1073 : // ... weights (experimental) ...
1074 161246 : scheme = GUIColorScheme("by global travel time", TL("by global travel time"), RGBColor::GREEN);
1075 161246 : scheme.addColor(RGBColor::RED, 100.);
1076 : scheme.setAllowsNegativeValues(true);
1077 161246 : laneColorer.addScheme(scheme);
1078 161246 : scheme = GUIColorScheme("by global speed percentage", TL("by global speed percentage"), RGBColor::RED);
1079 80623 : scheme.addColor(RGBColor::YELLOW, 50.);
1080 161246 : scheme.addColor(RGBColor::GREEN, 100.);
1081 : scheme.setAllowsNegativeValues(true);
1082 161246 : laneColorer.addScheme(scheme);
1083 161246 : scheme = GUIColorScheme("by given length/geometrical length", TL("by given length/geometrical length"), RGBColor::RED);
1084 80623 : scheme.addColor(RGBColor::ORANGE, 0.25);
1085 80623 : scheme.addColor(RGBColor::YELLOW, 0.5);
1086 80623 : scheme.addColor(RGBColor(179, 179, 179, 255), 1.);
1087 80623 : scheme.addColor(RGBColor::GREEN, 2.);
1088 80623 : scheme.addColor(RGBColor::CYAN, 4.);
1089 80623 : scheme.addColor(RGBColor::BLUE, 100.);
1090 161246 : laneColorer.addScheme(scheme);
1091 241869 : laneColorer.addScheme(GUIColorScheme("by angle", TL("by angle"), RGBColor::YELLOW, "", true));
1092 161246 : scheme = GUIColorScheme("by loaded weight", TL("by loaded weight"), RGBColor::GREEN);
1093 161246 : scheme.addColor(RGBColor::RED, 100.);
1094 : scheme.setAllowsNegativeValues(true);
1095 161246 : laneColorer.addScheme(scheme);
1096 161246 : scheme = GUIColorScheme("by priority", TL("by priority"), RGBColor::YELLOW);
1097 80623 : scheme.addColor(RGBColor::RED, -20.);
1098 161246 : scheme.addColor(RGBColor::GREEN, 20.);
1099 : scheme.setAllowsNegativeValues(true);
1100 161246 : laneColorer.addScheme(scheme);
1101 161246 : scheme = GUIColorScheme("by height at start", TL("by height at start"), RGBColor::GREY);
1102 80623 : scheme.addColor(RGBColor::BLUE, -10.);
1103 80623 : scheme.addColor(RGBColor::RED, 10.);
1104 80623 : scheme.addColor(RGBColor::YELLOW, 50.);
1105 80623 : scheme.addColor(RGBColor::GREEN, 100.);
1106 161246 : scheme.addColor(RGBColor::MAGENTA, 200.);
1107 : scheme.setAllowsNegativeValues(true);
1108 161246 : laneColorer.addScheme(scheme);
1109 161246 : scheme = GUIColorScheme("by height at geometry-segment start", TL("by height at geometry-segment start"), RGBColor::GREY);
1110 80623 : scheme.addColor(RGBColor::BLUE, -10.);
1111 80623 : scheme.addColor(RGBColor::RED, 10.);
1112 80623 : scheme.addColor(RGBColor::YELLOW, 50.);
1113 80623 : scheme.addColor(RGBColor::GREEN, 100.);
1114 161246 : scheme.addColor(RGBColor::MAGENTA, 200.);
1115 : scheme.setAllowsNegativeValues(true);
1116 161246 : laneColorer.addScheme(scheme);
1117 161246 : scheme = GUIColorScheme("by inclination", TL("by inclination"), RGBColor::GREY);
1118 80623 : scheme.addColor(RGBColor::YELLOW, 0.1);
1119 80623 : scheme.addColor(RGBColor::RED, 0.3);
1120 80623 : scheme.addColor(RGBColor::GREEN, -0.1);
1121 161246 : scheme.addColor(RGBColor::BLUE, -0.3);
1122 : scheme.setAllowsNegativeValues(true);
1123 161246 : laneColorer.addScheme(scheme);
1124 161246 : scheme = GUIColorScheme("by geometry-segment inclination", TL("by geometry-segment inclination"), RGBColor::GREY);
1125 80623 : scheme.addColor(RGBColor::YELLOW, 0.1);
1126 80623 : scheme.addColor(RGBColor::RED, 0.3);
1127 80623 : scheme.addColor(RGBColor::GREEN, -0.1);
1128 161246 : scheme.addColor(RGBColor::BLUE, -0.3);
1129 : scheme.setAllowsNegativeValues(true);
1130 161246 : laneColorer.addScheme(scheme);
1131 161246 : scheme = GUIColorScheme("by average speed", TL("by average speed"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1132 80623 : scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1133 80623 : scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1134 80623 : scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1135 80623 : scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1136 80623 : scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1137 161246 : laneColorer.addScheme(scheme);
1138 161246 : scheme = GUIColorScheme("by average relative speed ", TL("by average relative speed "), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1139 80623 : scheme.addColor(RGBColor::YELLOW, 0.25);
1140 80623 : scheme.addColor(RGBColor::GREEN, 0.5);
1141 80623 : scheme.addColor(RGBColor::CYAN, 0.75);
1142 80623 : scheme.addColor(RGBColor::BLUE, 1.);
1143 80623 : scheme.addColor(RGBColor::MAGENTA, 1.25);
1144 161246 : laneColorer.addScheme(scheme);
1145 161246 : scheme = GUIColorScheme("by routing device assumed speed ", TL("by routing device assumed speed "), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1146 80623 : scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1147 80623 : scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1148 80623 : scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1149 80623 : scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1150 80623 : scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1151 161246 : laneColorer.addScheme(scheme);
1152 161246 : scheme = GUIColorScheme("by electricity consumption", TL("by electricity consumption"), RGBColor::GREEN, "", false, 0, COL_SCHEME_EMISSION);
1153 80623 : scheme.addColor(RGBColor::CYAN, 0.2);
1154 80623 : scheme.addColor(RGBColor::GREEN, 0.4);
1155 80623 : scheme.addColor(RGBColor::YELLOW, 0.6);
1156 80623 : scheme.addColor(RGBColor::ORANGE, 0.8);
1157 80623 : scheme.addColor(RGBColor::RED, 1.0);
1158 80623 : scheme.addColor(RGBColor::MAGENTA, 2.0);
1159 161246 : laneColorer.addScheme(scheme);
1160 161246 : scheme = GUIColorScheme("by insertion-backlog (streetwise)", TL("by insertion-backlog (streetwise)"), RGBColor(204, 204, 204), "", false, 0, COL_SCHEME_DYNAMIC);
1161 80623 : scheme.addColor(RGBColor::GREEN, 1.);
1162 80623 : scheme.addColor(RGBColor::YELLOW, 10.);
1163 80623 : scheme.addColor(RGBColor::RED, 100.);
1164 161246 : laneColorer.addScheme(scheme);
1165 161246 : scheme = GUIColorScheme("by TAZ (streetwise)", TL("by TAZ (streetwise)"), RGBColor(204, 204, 204), "no TAZ", true);
1166 161246 : laneColorer.addScheme(scheme);
1167 161246 : scheme = GUIColorScheme(SCHEME_NAME_EDGE_PARAM_NUMERICAL, TL(SCHEME_NAME_EDGE_PARAM_NUMERICAL.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA);
1168 : scheme.setAllowsNegativeValues(true);
1169 161246 : laneColorer.addScheme(scheme);
1170 161246 : scheme = GUIColorScheme(SCHEME_NAME_LANE_PARAM_NUMERICAL, TL(SCHEME_NAME_LANE_PARAM_NUMERICAL.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA);
1171 : scheme.setAllowsNegativeValues(true);
1172 161246 : laneColorer.addScheme(scheme);
1173 161246 : scheme = GUIColorScheme(SCHEME_NAME_EDGEDATA_NUMERICAL, TL(SCHEME_NAME_EDGEDATA_NUMERICAL.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA);
1174 : scheme.setAllowsNegativeValues(true);
1175 161246 : laneColorer.addScheme(scheme);
1176 161246 : scheme = GUIColorScheme("by distance (kilometrage)", TL("by distance (kilometrage)"), RGBColor(204, 204, 204));
1177 80623 : scheme.addColor(RGBColor(255, 204, 204), 1.);
1178 80623 : scheme.addColor(RGBColor::RED, 10000.);
1179 80623 : scheme.addColor(RGBColor(204, 204, 255), -1.);
1180 161246 : scheme.addColor(RGBColor::BLUE, -10000.);
1181 : scheme.setAllowsNegativeValues(true);
1182 161246 : laneColorer.addScheme(scheme);
1183 161246 : scheme = GUIColorScheme("by abs distance (kilometrage)", TL("by abs distance (kilometrage)"), RGBColor(204, 204, 204));
1184 161246 : scheme.addColor(RGBColor::RED, 1.);
1185 : scheme.setAllowsNegativeValues(false);
1186 161246 : laneColorer.addScheme(scheme);
1187 161246 : scheme = GUIColorScheme("by reachability (traveltime)", TL("by reachability (traveltime)"), RGBColor::RED);
1188 161246 : scheme.addColor(RGBColor::GREY, INVALID_DOUBLE, "unreachable");
1189 : scheme.setAllowsNegativeValues(true);
1190 161246 : laneColorer.addScheme(scheme);
1191 161246 : scheme = GUIColorScheme("by thread index", TL("by thread index"), RGBColor(204, 204, 204));
1192 80623 : scheme.addColor(RGBColor::RED, 1.);
1193 161246 : laneColorer.addScheme(scheme);
1194 161246 : scheme = GUIColorScheme("free parking spaces", TL("free parking spaces"), RGBColor(204, 204, 204), "", false, 0, COL_SCHEME_DYNAMIC);
1195 80623 : scheme.addColor(RGBColor::RED, 1.);
1196 80623 : scheme.addColor(RGBColor::YELLOW, 10.);
1197 80623 : scheme.addColor(RGBColor::GREEN, 100.);
1198 80623 : scheme.addColor(RGBColor::BLUE, 1000.);
1199 161246 : laneColorer.addScheme(scheme);
1200 161246 : scheme = GUIColorScheme(SCHEME_NAME_EDGEDATA_LIVE, TL(SCHEME_NAME_EDGEDATA_LIVE.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA, COL_SCHEME_DYNAMIC);
1201 : scheme.setAllowsNegativeValues(true);
1202 161246 : laneColorer.addScheme(scheme);
1203 :
1204 : /// add vehicle coloring schemes
1205 241869 : vehicleColorer.addScheme(GUIColorScheme("given vehicle/type/route color", TL("given vehicle/type/route color"), RGBColor::YELLOW, "", true));
1206 241869 : vehicleColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::YELLOW, "", true));
1207 241869 : vehicleColorer.addScheme(GUIColorScheme("given/assigned vehicle color", TL("given/assigned vehicle color"), RGBColor::YELLOW, "", true));
1208 241869 : vehicleColorer.addScheme(GUIColorScheme("given/assigned type color", TL("given/assigned type color"), RGBColor::YELLOW, "", true));
1209 241869 : vehicleColorer.addScheme(GUIColorScheme("given/assigned route color", TL("given/assigned route color"), RGBColor::YELLOW, "", true));
1210 241869 : vehicleColorer.addScheme(GUIColorScheme("depart position as HSV", TL("depart position as HSV"), RGBColor::YELLOW, "", true));
1211 241869 : vehicleColorer.addScheme(GUIColorScheme("arrival position as HSV", TL("arrival position as HSV"), RGBColor::YELLOW, "", true));
1212 241869 : vehicleColorer.addScheme(GUIColorScheme("direction/distance as HSV", TL("direction/distance as HSV"), RGBColor::YELLOW, "", true));
1213 161246 : scheme = GUIColorScheme("by speed", TL("by speed"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1214 80623 : scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1215 80623 : scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1216 80623 : scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1217 80623 : scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1218 161246 : scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1219 : scheme.setAllowsNegativeValues(true); // negative speed indicates stopped
1220 80623 : scheme.addColor(RGBColor::RED, -1); // stopped on road
1221 80623 : scheme.addColor(RGBColor::GREY, -2); // stopped off-road (parking)
1222 161246 : vehicleColorer.addScheme(scheme);
1223 161246 : scheme = GUIColorScheme("by action step", TL("by action step"), RGBColor::GREY, TL("no action"), true, 0, COL_SCHEME_DYNAMIC);
1224 80623 : scheme.addColor(RGBColor(0, 255, 0, 255), 1., TL("action in next step"));
1225 80623 : scheme.addColor(RGBColor(80, 160, 80, 255), 2., TL("had action step"));
1226 161246 : vehicleColorer.addScheme(scheme);
1227 161246 : scheme = GUIColorScheme("by waiting time", TL("by waiting time"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1228 80623 : scheme.addColor(RGBColor::CYAN, 30.);
1229 80623 : scheme.addColor(RGBColor::GREEN, 100.);
1230 80623 : scheme.addColor(RGBColor::YELLOW, 200.);
1231 80623 : scheme.addColor(RGBColor::RED, 300.);
1232 161246 : vehicleColorer.addScheme(scheme);
1233 161246 : scheme = GUIColorScheme("by accumulated waiting time", TL("by accumulated waiting time"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1234 80623 : scheme.addColor(RGBColor::CYAN, 25.);
1235 80623 : scheme.addColor(RGBColor::GREEN, 50.);
1236 80623 : scheme.addColor(RGBColor::YELLOW, 75.);
1237 80623 : scheme.addColor(RGBColor::RED, 100.);
1238 161246 : vehicleColorer.addScheme(scheme);
1239 161246 : scheme = GUIColorScheme("by time since lane change", TL("by time since lane change"), RGBColor(179, 179, 179, 255), "0", false, 0, COL_SCHEME_DYNAMIC);
1240 80623 : scheme.addColor(RGBColor(189, 189, 179, 255), -180);
1241 80623 : scheme.addColor(RGBColor(255, 255, 0, 255), -20);
1242 80623 : scheme.addColor(RGBColor(255, 0, 0, 255), -0.01);
1243 80623 : scheme.addColor(RGBColor(0, 0, 255, 255), 0.01);
1244 80623 : scheme.addColor(RGBColor(0, 255, 255, 255), 20);
1245 80623 : scheme.addColor(RGBColor(179, 189, 189, 255), 180);
1246 : scheme.setAllowsNegativeValues(true);
1247 161246 : vehicleColorer.addScheme(scheme);
1248 161246 : scheme = GUIColorScheme("by max speed", TL("by max speed"), RGBColor::RED);
1249 80623 : scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1250 80623 : scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1251 80623 : scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1252 80623 : scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1253 80623 : scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1254 161246 : vehicleColorer.addScheme(scheme);
1255 : // ... emissions ...
1256 161246 : scheme = GUIColorScheme("by CO2 emissions", TL("by CO2 emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1257 80623 : scheme.addColor(RGBColor::CYAN, 23000);
1258 80623 : scheme.addColor(RGBColor::GREEN, 46000);
1259 80623 : scheme.addColor(RGBColor::YELLOW, 69000);
1260 80623 : scheme.addColor(RGBColor::ORANGE, 92000);
1261 80623 : scheme.addColor(RGBColor::RED, 115000);
1262 80623 : scheme.addColor(RGBColor::MAGENTA, 150000);
1263 161246 : vehicleColorer.addScheme(scheme);
1264 161246 : scheme = GUIColorScheme("by CO emissions", TL("by CO emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1265 80623 : scheme.addColor(RGBColor::CYAN, 1500);
1266 80623 : scheme.addColor(RGBColor::GREEN, 3000);
1267 80623 : scheme.addColor(RGBColor::YELLOW, 4500);
1268 80623 : scheme.addColor(RGBColor::ORANGE, 6000);
1269 80623 : scheme.addColor(RGBColor::RED, 7500);
1270 80623 : scheme.addColor(RGBColor::MAGENTA, 10000);
1271 161246 : vehicleColorer.addScheme(scheme);
1272 161246 : scheme = GUIColorScheme("by PMx emissions", TL("by PMx emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1273 80623 : scheme.addColor(RGBColor::CYAN, 12);
1274 80623 : scheme.addColor(RGBColor::GREEN, 24);
1275 80623 : scheme.addColor(RGBColor::YELLOW, 36);
1276 80623 : scheme.addColor(RGBColor::ORANGE, 48);
1277 80623 : scheme.addColor(RGBColor::RED, 60);
1278 80623 : scheme.addColor(RGBColor::MAGENTA, 80);
1279 161246 : vehicleColorer.addScheme(scheme);
1280 161246 : scheme = GUIColorScheme("by NOx emissions", TL("by NOx emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1281 80623 : scheme.addColor(RGBColor::CYAN, 300);
1282 80623 : scheme.addColor(RGBColor::GREEN, 600);
1283 80623 : scheme.addColor(RGBColor::YELLOW, 900);
1284 80623 : scheme.addColor(RGBColor::ORANGE, 1200);
1285 80623 : scheme.addColor(RGBColor::RED, 1500);
1286 80623 : scheme.addColor(RGBColor::MAGENTA, 2000);
1287 161246 : vehicleColorer.addScheme(scheme);
1288 161246 : scheme = GUIColorScheme("by HC emissions", TL("by HC emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1289 80623 : scheme.addColor(RGBColor::CYAN, 400);
1290 80623 : scheme.addColor(RGBColor::GREEN, 800);
1291 80623 : scheme.addColor(RGBColor::YELLOW, 1200);
1292 80623 : scheme.addColor(RGBColor::ORANGE, 1600);
1293 80623 : scheme.addColor(RGBColor::RED, 2000);
1294 80623 : scheme.addColor(RGBColor::MAGENTA, 2500);
1295 161246 : vehicleColorer.addScheme(scheme);
1296 161246 : scheme = GUIColorScheme("by fuel consumption", TL("by fuel consumption"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1297 80623 : scheme.addColor(RGBColor::CYAN, 10);
1298 80623 : scheme.addColor(RGBColor::GREEN, 20);
1299 80623 : scheme.addColor(RGBColor::YELLOW, 30);
1300 80623 : scheme.addColor(RGBColor::ORANGE, 40);
1301 80623 : scheme.addColor(RGBColor::RED, 50);
1302 80623 : scheme.addColor(RGBColor::MAGENTA, 60);
1303 161246 : vehicleColorer.addScheme(scheme);
1304 161246 : scheme = GUIColorScheme("by noise emissions (Harmonoise)", RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1305 80623 : scheme.addColor(RGBColor::CYAN, 60);
1306 80623 : scheme.addColor(RGBColor::GREEN, 70);
1307 80623 : scheme.addColor(RGBColor::YELLOW, 80);
1308 80623 : scheme.addColor(RGBColor::ORANGE, 90);
1309 80623 : scheme.addColor(RGBColor::RED, 100);
1310 80623 : scheme.addColor(RGBColor::MAGENTA, 120);
1311 161246 : vehicleColorer.addScheme(scheme);
1312 161246 : scheme = GUIColorScheme("by reroute number", TL("by reroute number"), RGBColor::GREY, "", false, 0, COL_SCHEME_DYNAMIC);
1313 80623 : scheme.addColor(RGBColor::YELLOW, 1.);
1314 80623 : scheme.addColor(RGBColor::RED, 10.);
1315 161246 : vehicleColorer.addScheme(scheme);
1316 161246 : scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(179, 179, 179, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1317 80623 : scheme.addColor(RGBColor(0, 102, 204, 255), 1, TL("selected"));
1318 161246 : vehicleColorer.addScheme(scheme);
1319 161246 : scheme = GUIColorScheme("by offset from best lane", TL("by offset from best lane"), RGBColor(179, 179, 179, 255), "0", false, 0, COL_SCHEME_DYNAMIC);
1320 80623 : scheme.addColor(RGBColor(255, 0, 255, 255), -100, TL("opposite lane"));
1321 80623 : scheme.addColor(RGBColor(255, 0, 0, 255), -3, "-3");
1322 80623 : scheme.addColor(RGBColor(255, 255, 0, 255), -1, "-1");
1323 80623 : scheme.addColor(RGBColor(0, 255, 255, 255), 1, "1");
1324 80623 : scheme.addColor(RGBColor(0, 0, 255, 255), 3, "3");
1325 : scheme.setAllowsNegativeValues(true);
1326 161246 : vehicleColorer.addScheme(scheme);
1327 161246 : scheme = GUIColorScheme("by acceleration", TL("by acceleration"), RGBColor(179, 179, 179, 255), "0", false, 0, COL_SCHEME_DYNAMIC);
1328 80623 : scheme.addColor(RGBColor(64, 0, 0, 255), -9.0);
1329 80623 : scheme.addColor(RGBColor(255, 0, 0, 255), -4.5 /* -SUMOVTypeParameter::getDefaultDecel() */);
1330 80623 : scheme.addColor(RGBColor(255, 255, 0, 255), -0.1);
1331 80623 : scheme.addColor(RGBColor(0, 255, 255, 255), 0.1);
1332 80623 : scheme.addColor(RGBColor(0, 0, 255, 255), 2.6 /* SUMOVTypeParameter::getDefaultAccel() */);
1333 80623 : scheme.addColor(RGBColor(255, 0, 255, 255), 5.2);
1334 : scheme.setAllowsNegativeValues(true);
1335 161246 : vehicleColorer.addScheme(scheme);
1336 161246 : scheme = GUIColorScheme("by time gap on lane", TL("by time gap on lane"), RGBColor(255, 255, 0, 255), "0", false, 0, COL_SCHEME_DYNAMIC);
1337 80623 : scheme.addColor(RGBColor(179, 179, 179, 255), -1);
1338 80623 : scheme.addColor(RGBColor(0, 255, 255, 255), 1);
1339 80623 : scheme.addColor(RGBColor(0, 0, 255, 255), 2);
1340 : scheme.setAllowsNegativeValues(true);
1341 161246 : vehicleColorer.addScheme(scheme);
1342 161246 : scheme = GUIColorScheme("by depart delay", TL("by depart delay"), RGBColor::BLUE);
1343 80623 : scheme.addColor(RGBColor::CYAN, 30.);
1344 80623 : scheme.addColor(RGBColor::GREEN, 100.);
1345 80623 : scheme.addColor(RGBColor::YELLOW, 200.);
1346 80623 : scheme.addColor(RGBColor::RED, 300.);
1347 161246 : vehicleColorer.addScheme(scheme);
1348 161246 : scheme = GUIColorScheme("by electricity consumption", TL("by electricity consumption"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1349 80623 : scheme.addColor(RGBColor::CYAN, 10);
1350 80623 : scheme.addColor(RGBColor::GREEN, 20);
1351 80623 : scheme.addColor(RGBColor::YELLOW, 30);
1352 80623 : scheme.addColor(RGBColor::ORANGE, 40);
1353 80623 : scheme.addColor(RGBColor::RED, 60);
1354 80623 : scheme.addColor(RGBColor::MAGENTA, 100);
1355 161246 : vehicleColorer.addScheme(scheme);
1356 161246 : scheme = GUIColorScheme("by relative battery charge", TL("by relative battery charge"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1357 : scheme.setAllowsNegativeValues(true);
1358 80623 : scheme.addColor(RGBColor::MAGENTA, 0.1);
1359 80623 : scheme.addColor(RGBColor::RED, 0.2);
1360 80623 : scheme.addColor(RGBColor::ORANGE, 0.3);
1361 80623 : scheme.addColor(RGBColor::YELLOW, 0.4);
1362 80623 : scheme.addColor(RGBColor::GREEN, 0.6);
1363 80623 : scheme.addColor(RGBColor::CYAN, 1.);
1364 161246 : vehicleColorer.addScheme(scheme);
1365 161246 : scheme = GUIColorScheme("by charged energy", TL("by charged energy"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1366 : scheme.setAllowsNegativeValues(true);
1367 80623 : scheme.addColor(RGBColor::MAGENTA, 10);
1368 80623 : scheme.addColor(RGBColor::RED, 20);
1369 80623 : scheme.addColor(RGBColor::ORANGE, 30);
1370 80623 : scheme.addColor(RGBColor::YELLOW, 100);
1371 80623 : scheme.addColor(RGBColor::GREEN, 200);
1372 80623 : scheme.addColor(RGBColor::CYAN, 500);
1373 161246 : vehicleColorer.addScheme(scheme);
1374 161246 : scheme = GUIColorScheme("by time loss", TL("by time loss"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1375 80623 : scheme.addColor(RGBColor::CYAN, 10.);
1376 80623 : scheme.addColor(RGBColor::GREEN, 60.);
1377 80623 : scheme.addColor(RGBColor::YELLOW, 180.);
1378 80623 : scheme.addColor(RGBColor::RED, 900.);
1379 161246 : vehicleColorer.addScheme(scheme);
1380 161246 : scheme = GUIColorScheme("by stop delay", TL("by stop delay"), RGBColor::GREY, "", false, -1, COL_SCHEME_DYNAMIC);
1381 80623 : scheme.addColor(RGBColor::BLUE, 0.);
1382 80623 : scheme.addColor(RGBColor::CYAN, 10.);
1383 80623 : scheme.addColor(RGBColor::GREEN, 60.);
1384 80623 : scheme.addColor(RGBColor::YELLOW, 120.);
1385 80623 : scheme.addColor(RGBColor::ORANGE, 300.);
1386 161246 : scheme.addColor(RGBColor::RED, 900.);
1387 : scheme.setAllowsNegativeValues(true);
1388 161246 : vehicleColorer.addScheme(scheme);
1389 161246 : scheme = GUIColorScheme("by stop arrival delay", TL("by stop arrival delay"), RGBColor::GREY, "", false, INVALID_DOUBLE, COL_SCHEME_DYNAMIC);
1390 80623 : scheme.addColor(RGBColor::MAGENTA, -10.);
1391 80623 : scheme.addColor(RGBColor::BLUE, 0.);
1392 80623 : scheme.addColor(RGBColor::CYAN, 10.);
1393 80623 : scheme.addColor(RGBColor::GREEN, 60.);
1394 80623 : scheme.addColor(RGBColor::YELLOW, 120.);
1395 80623 : scheme.addColor(RGBColor::ORANGE, 300.);
1396 161246 : scheme.addColor(RGBColor::RED, 900.);
1397 : scheme.setAllowsNegativeValues(true);
1398 161246 : vehicleColorer.addScheme(scheme);
1399 161246 : scheme = GUIColorScheme("by lateral speed", TL("by lateral speed"), RGBColor(179, 179, 179, 255), "0", false, 0, COL_SCHEME_DYNAMIC);
1400 80623 : scheme.addColor(RGBColor(255, 0, 0, 255), -3, "-1.5");
1401 80623 : scheme.addColor(RGBColor(255, 255, 0, 255), -1, "-0.5");
1402 80623 : scheme.addColor(RGBColor(0, 255, 255, 255), 1, "0.5");
1403 80623 : scheme.addColor(RGBColor(0, 0, 255, 255), 3, "1.5");
1404 : scheme.setAllowsNegativeValues(true);
1405 161246 : vehicleColorer.addScheme(scheme);
1406 161246 : scheme = GUIColorScheme(SCHEME_NAME_PARAM_NUMERICAL, TL(SCHEME_NAME_PARAM_NUMERICAL.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA);
1407 : scheme.setAllowsNegativeValues(true);
1408 161246 : vehicleColorer.addScheme(scheme);
1409 241869 : vehicleColorer.addScheme(GUIColorScheme("random", TL("random"), RGBColor::YELLOW, "", true));
1410 241869 : vehicleColorer.addScheme(GUIColorScheme("by angle", TL("by angle"), RGBColor::YELLOW, "", true));
1411 :
1412 : /// add person coloring schemes
1413 241869 : personColorer.addScheme(GUIColorScheme("given person/type color", TL("given person/type color"), RGBColor::BLUE, "", true));
1414 241869 : personColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::BLUE, "", true));
1415 241869 : personColorer.addScheme(GUIColorScheme("given/assigned person color", TL("given/assigned person color"), RGBColor::BLUE, "", true));
1416 241869 : personColorer.addScheme(GUIColorScheme("given/assigned type color", TL("given/assigned type color"), RGBColor::BLUE, "", true));
1417 161246 : scheme = GUIColorScheme("by speed", TL("by speed"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1418 80623 : scheme.addColor(RGBColor::YELLOW, 2.5 / 3.6);
1419 80623 : scheme.addColor(RGBColor::GREEN, 5. / 3.6);
1420 161246 : scheme.addColor(RGBColor::BLUE, 10. / 3.6);
1421 : scheme.setAllowsNegativeValues(true); // negative speed indicates stopped
1422 80623 : scheme.addColor(RGBColor::GREY, -1.); // stop stage
1423 80623 : scheme.addColor(RGBColor::GREY, -2.); // stop stage (departure)
1424 161246 : personColorer.addScheme(scheme);
1425 161246 : scheme = GUIColorScheme("by mode", TL("by mode"), RGBColor::GREY, TL("waiting for insertion"), true, 0, COL_SCHEME_DYNAMIC);
1426 80623 : scheme.addColor(RGBColor::RED, 1., TL("stopped"));
1427 80623 : scheme.addColor(RGBColor::GREEN, 2., TL("walking"));
1428 80623 : scheme.addColor(RGBColor::BLUE, 3., TL("riding"));
1429 80623 : scheme.addColor(RGBColor::CYAN, 4., TL("accessing trainStop"));
1430 80623 : scheme.addColor(RGBColor::YELLOW, 5., TL("waiting for ride"));
1431 161246 : personColorer.addScheme(scheme);
1432 161246 : scheme = GUIColorScheme("by waiting time", TL("by waiting time"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1433 80623 : scheme.addColor(RGBColor::CYAN, 30.);
1434 80623 : scheme.addColor(RGBColor::GREEN, 100.);
1435 80623 : scheme.addColor(RGBColor::YELLOW, 200.);
1436 80623 : scheme.addColor(RGBColor::RED, 300.);
1437 161246 : personColorer.addScheme(scheme);
1438 161246 : scheme = GUIColorScheme("by jammed state", TL("by jammed state"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1439 80623 : scheme.addColor(RGBColor::RED, 1.);
1440 161246 : personColorer.addScheme(scheme);
1441 161246 : scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(179, 179, 179, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1442 80623 : scheme.addColor(RGBColor(0, 102, 204, 255), 1, TL("selected"));
1443 161246 : personColorer.addScheme(scheme);
1444 241869 : personColorer.addScheme(GUIColorScheme("by angle", TL("by angle"), RGBColor::YELLOW, "", true));
1445 241869 : personColorer.addScheme(GUIColorScheme("random", TL("random"), RGBColor::YELLOW, "", true));
1446 :
1447 : /// add container coloring schemes
1448 241869 : containerColorer.addScheme(GUIColorScheme("given container/type color", TL("given container/type color"), RGBColor::YELLOW, "", true));
1449 241869 : containerColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::YELLOW, "", true));
1450 241869 : containerColorer.addScheme(GUIColorScheme("given/assigned container color", TL("given/assigned container color"), RGBColor::YELLOW, "", true));
1451 241869 : containerColorer.addScheme(GUIColorScheme("given/assigned type color", TL("given/assigned type color"), RGBColor::YELLOW, "", true));
1452 161246 : scheme = GUIColorScheme("by speed", TL("by speed"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1453 80623 : scheme.addColor(RGBColor::YELLOW, 2.5 / 3.6);
1454 80623 : scheme.addColor(RGBColor::GREEN, 5. / 3.6);
1455 80623 : scheme.addColor(RGBColor::BLUE, 10. / 3.6);
1456 161246 : containerColorer.addScheme(scheme);
1457 161246 : scheme = GUIColorScheme("by mode", TL("by mode"), RGBColor::GREY, TL("waiting for insertion"), true, 0, COL_SCHEME_DYNAMIC);
1458 80623 : scheme.addColor(RGBColor::RED, 1., TL("stopped"));
1459 80623 : scheme.addColor(RGBColor::BLUE, 3., TL("transport"));
1460 80623 : scheme.addColor(RGBColor::CYAN, 4., TL("accessing trainStop"));
1461 80623 : scheme.addColor(RGBColor::YELLOW, 5., TL("waiting for transport"));
1462 80623 : scheme.addColor(RGBColor::GREEN, 6., TL("tranship")); // (moving without vehicle)
1463 161246 : containerColorer.addScheme(scheme);
1464 161246 : scheme = GUIColorScheme("by waiting time", TL("by waiting time"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1465 80623 : scheme.addColor(RGBColor::CYAN, 30.);
1466 80623 : scheme.addColor(RGBColor::GREEN, 100.);
1467 80623 : scheme.addColor(RGBColor::YELLOW, 200.);
1468 80623 : scheme.addColor(RGBColor::RED, 300.);
1469 161246 : containerColorer.addScheme(scheme);
1470 161246 : scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(179, 179, 179, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1471 80623 : scheme.addColor(RGBColor(0, 102, 204, 255), 1, TL("selected"));
1472 161246 : containerColorer.addScheme(scheme);
1473 241869 : containerColorer.addScheme(GUIColorScheme("by angle", TL("by angle"), RGBColor::YELLOW, "", true));
1474 241869 : containerColorer.addScheme(GUIColorScheme("random", TL("random"), RGBColor::YELLOW, "", true));
1475 :
1476 : /// add junction coloring schemes
1477 161246 : scheme = GUIColorScheme("uniform", TL("uniform"), RGBColor::BLACK, "", true);
1478 80623 : scheme.addColor(RGBColor(150, 200, 200), 1, TL("waterway"));
1479 80623 : scheme.addColor(RGBColor(0, 0, 0, 0), 2, TL("railway"));
1480 80623 : scheme.addColor(RGBColor(200, 240, 240), 3, TL("airway"));
1481 161246 : junctionColorer.addScheme(scheme);
1482 161246 : scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(128, 128, 128, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1483 80623 : scheme.addColor(RGBColor(0, 80, 180, 255), 1, TL("selected"));
1484 161246 : junctionColorer.addScheme(scheme);
1485 161246 : scheme = GUIColorScheme(SCHEME_NAME_TYPE, TL(SCHEME_NAME_TYPE.c_str()), RGBColor::GREEN, "traffic_light", true);
1486 80623 : scheme.addColor(RGBColor(0, 128, 0), 1, "traffic_light_unregulated");
1487 80623 : scheme.addColor(RGBColor::YELLOW, 2, "priority");
1488 80623 : scheme.addColor(RGBColor::RED, 3, "priority_stop");
1489 80623 : scheme.addColor(RGBColor::BLUE, 4, "right_before_left");
1490 80623 : scheme.addColor(RGBColor::CYAN, 5, "allway_stop");
1491 80623 : scheme.addColor(RGBColor::GREY, 6, "district");
1492 80623 : scheme.addColor(RGBColor::MAGENTA, 7, "unregulated");
1493 80623 : scheme.addColor(RGBColor::BLACK, 8, "dead_end");
1494 80623 : scheme.addColor(RGBColor::ORANGE, 9, "rail_signal");
1495 80623 : scheme.addColor(RGBColor(172, 108, 44), 10, "zipper"); // brown, darker than the zipper link rule
1496 80623 : scheme.addColor(RGBColor(192, 255, 192), 11, "traffic_light_right_on_red"); // light green
1497 80623 : scheme.addColor(RGBColor(128, 0, 128), 12, "rail_crossing"); // dark purple
1498 80623 : scheme.addColor(RGBColor(0, 0, 128), 13, "left_before_right"); // dark blue
1499 161246 : junctionColorer.addScheme(scheme);
1500 161246 : scheme = GUIColorScheme("by height", TL("by height"), RGBColor::GREY);
1501 80623 : scheme.addColor(RGBColor::BLUE, -10.);
1502 80623 : scheme.addColor(RGBColor::RED, 10.);
1503 80623 : scheme.addColor(RGBColor::YELLOW, 50.);
1504 80623 : scheme.addColor(RGBColor::GREEN, 100.);
1505 161246 : scheme.addColor(RGBColor::MAGENTA, 200.);
1506 : scheme.setAllowsNegativeValues(true);
1507 161246 : junctionColorer.addScheme(scheme);
1508 :
1509 : /// add POI coloring schemes
1510 241869 : poiColorer.addScheme(GUIColorScheme("given POI color", TL("given POI color"), RGBColor::RED, "", true));
1511 161246 : scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(179, 179, 179, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1512 80623 : scheme.addColor(RGBColor(0, 102, 204, 255), 1, TL("selected"));
1513 161246 : poiColorer.addScheme(scheme);
1514 241869 : poiColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::RED, "", true));
1515 :
1516 : /// add polygon coloring schemes
1517 241869 : polyColorer.addScheme(GUIColorScheme("given polygon color", TL("given polygon color"), RGBColor::ORANGE, "", true));
1518 161246 : scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(179, 179, 179, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1519 80623 : scheme.addColor(RGBColor(0, 102, 204, 255), 1, TL("selected"));
1520 161246 : polyColorer.addScheme(scheme);
1521 241869 : polyColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::ORANGE, "", true));
1522 241869 : polyColorer.addScheme(GUIColorScheme("random", TL("random"), RGBColor::YELLOW, "", true));
1523 :
1524 : /// add lane scaling schemes
1525 : {
1526 161246 : GUIScaleScheme laneScheme = GUIScaleScheme(TL("default"), 1, TL("uniform"), true);
1527 161246 : laneScaler.addScheme(laneScheme);
1528 161246 : laneScheme = GUIScaleScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), 0.5, TL("unselected"), true, 0, COL_SCHEME_MISC);
1529 80623 : laneScheme.addColor(5, 1, TL("selected"));
1530 161246 : laneScaler.addScheme(laneScheme);
1531 : // ... traffic states ...
1532 161246 : laneScheme = GUIScaleScheme(TL("by allowed speed (lanewise)"), 0);
1533 80623 : laneScheme.addColor(10, 150. / 3.6);
1534 161246 : laneScaler.addScheme(laneScheme);
1535 161246 : laneScheme = GUIScaleScheme(TL("by current occupancy (lanewise, brutto)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1536 80623 : laneScheme.addColor(10, 0.95);
1537 161246 : laneScaler.addScheme(laneScheme);
1538 161246 : laneScheme = GUIScaleScheme(TL("by current occupancy (lanewise, netto)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1539 80623 : laneScheme.addColor(10, 0.95);
1540 161246 : laneScaler.addScheme(laneScheme);
1541 161246 : laneScheme = GUIScaleScheme(TL("by first vehicle waiting time (lanewise)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1542 80623 : laneScheme.addColor(10, 300.);
1543 161246 : laneScaler.addScheme(laneScheme);
1544 161246 : laneScheme = GUIScaleScheme(TL("by lane number (streetwise)"), 1);
1545 80623 : laneScheme.addColor(10, 5.);
1546 161246 : laneScaler.addScheme(laneScheme);
1547 : // ... emissions ...
1548 161246 : laneScheme = GUIScaleScheme(TL("by CO2 emissions"), 0, "", false, 0, COL_SCHEME_EMISSION);
1549 80623 : laneScheme.addColor(10, 10. / 7.5 / 5.);
1550 161246 : laneScaler.addScheme(laneScheme);
1551 161246 : laneScheme = GUIScaleScheme(TL("by CO emissions"), 0, "", false, 0, COL_SCHEME_EMISSION);
1552 80623 : laneScheme.addColor(10, 0.05 / 7.5 / 2.);
1553 161246 : laneScaler.addScheme(laneScheme);
1554 161246 : laneScheme = GUIScaleScheme(TL("by PMx emissions"), 0, "", false, 0, COL_SCHEME_EMISSION);
1555 80623 : laneScheme.addColor(10, .005 / 7.5 / 5.);
1556 161246 : laneScaler.addScheme(laneScheme);
1557 161246 : laneScheme = GUIScaleScheme(TL("by NOx emissions"), 0, "", false, 0, COL_SCHEME_EMISSION);
1558 80623 : laneScheme.addColor(10, .125 / 7.5 / 5.);
1559 161246 : laneScaler.addScheme(laneScheme);
1560 161246 : laneScheme = GUIScaleScheme(TL("by HC emissions"), 0, "", false, 0, COL_SCHEME_EMISSION);
1561 80623 : laneScheme.addColor(10, .02 / 7.5 / 4.);
1562 161246 : laneScaler.addScheme(laneScheme);
1563 161246 : laneScheme = GUIScaleScheme(TL("by fuel consumption"), 0, "", false, 0, COL_SCHEME_EMISSION);
1564 80623 : laneScheme.addColor(10, .005 / 7.5 * 100.);
1565 161246 : laneScaler.addScheme(laneScheme);
1566 161246 : laneScheme = GUIScaleScheme(TL("by noise emissions (Harmonoise)"), 0, "", false, 0, COL_SCHEME_EMISSION);
1567 80623 : laneScheme.addColor(10, 100.);
1568 161246 : laneScaler.addScheme(laneScheme);
1569 : // ... weights (experimental) ...
1570 161246 : laneScheme = GUIScaleScheme(TL("by global travel time"), 0);
1571 80623 : laneScheme.addColor(10, 100.);
1572 : laneScheme.setAllowsNegativeValues(true);
1573 161246 : laneScaler.addScheme(laneScheme);
1574 161246 : laneScheme = GUIScaleScheme(TL("by global speed percentage"), 0);
1575 80623 : laneScheme.addColor(10, 100.);
1576 : laneScheme.setAllowsNegativeValues(true);
1577 161246 : laneScaler.addScheme(laneScheme);
1578 161246 : laneScheme = GUIScaleScheme(TL("by given length/geometrical length"), 0);
1579 80623 : laneScheme.addColor(10, 10.);
1580 161246 : laneScaler.addScheme(laneScheme);
1581 161246 : laneScheme = GUIScaleScheme(TL("by loaded weight"), 0);
1582 80623 : laneScheme.addColor(-1000, -1000.);
1583 80623 : laneScheme.addColor(1000, 1000.);
1584 : laneScheme.setAllowsNegativeValues(true);
1585 161246 : laneScaler.addScheme(laneScheme);
1586 161246 : laneScheme = GUIScaleScheme(TL("by priority"), 1);
1587 80623 : laneScheme.addColor(0.5, -20.);
1588 80623 : laneScheme.addColor(5, 20.);
1589 : laneScheme.setAllowsNegativeValues(true);
1590 161246 : laneScaler.addScheme(laneScheme);
1591 161246 : laneScheme = GUIScaleScheme(TL("by average speed"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1592 80623 : laneScheme.addColor(10, 150. / 3.6);
1593 161246 : laneScaler.addScheme(laneScheme);
1594 161246 : laneScheme = GUIScaleScheme(TL("by average relative speed"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1595 80623 : laneScheme.addColor(0.5, 0.5);
1596 80623 : laneScheme.addColor(2, 1.);
1597 80623 : laneScheme.addColor(10, 2.);
1598 161246 : laneScaler.addScheme(laneScheme);
1599 161246 : laneScheme = GUIScaleScheme(TL("by electricity consumption"), 0, "", false, 0, COL_SCHEME_EMISSION);
1600 80623 : laneScheme.addColor(10, 1. / 7.5 / 5.);
1601 161246 : laneScaler.addScheme(laneScheme);
1602 161246 : laneScheme = GUIScaleScheme(TL("by insertion-backlog (streetwise)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1603 80623 : laneScheme.addColor(1, 1.);
1604 80623 : laneScheme.addColor(10, 10.);
1605 80623 : laneScheme.addColor(50, 100.);
1606 161246 : laneScaler.addScheme(laneScheme);
1607 161246 : laneScheme = GUIScaleScheme(SCHEME_NAME_EDGEDATA_NUMERICAL, TL(SCHEME_NAME_EDGEDATA_NUMERICAL.c_str()), 0.1, TL("missing data"), false, MISSING_DATA);
1608 80623 : laneScheme.addColor(1, 1.);
1609 80623 : laneScheme.addColor(2, 10.);
1610 80623 : laneScheme.addColor(5, 100.);
1611 80623 : laneScheme.addColor(10, 1000.);
1612 : laneScheme.setAllowsNegativeValues(true);
1613 161246 : laneScaler.addScheme(laneScheme);
1614 80623 : }
1615 :
1616 : /// add edge coloring schemes
1617 241869 : edgeColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor(0, 0, 0, 0), "", true));
1618 161246 : scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(128, 128, 128, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1619 80623 : scheme.addColor(RGBColor(0, 80, 180, 255), 1., TL("selected"));
1620 161246 : edgeColorer.addScheme(scheme);
1621 161246 : scheme = GUIColorScheme("by purpose (streetwise)", TL("by purpose (streetwise)"), RGBColor(), TL("normal"), true);
1622 80623 : scheme.addColor(RGBColor(128, 0, 128, 255), 1., TL("connector")); // see MSEdge::EdgeBasicFunction::EDGEFUNCTION_CONNECTOR
1623 80623 : scheme.addColor(RGBColor::BLUE, 2., TL("internal")); // see MSEdge::EdgeBasicFunction::EDGEFUNCTION_INTERNAL
1624 161246 : edgeColorer.addScheme(scheme);
1625 161246 : scheme = GUIColorScheme("by allowed speed (streetwise)", TL("by allowed speed (streetwise)"), RGBColor::RED);
1626 80623 : scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1627 80623 : scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1628 80623 : scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1629 80623 : scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1630 80623 : scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1631 161246 : edgeColorer.addScheme(scheme);
1632 161246 : scheme = GUIColorScheme("by current occupancy (streetwise, brutto)", TL("by current occupancy (streetwise, brutto)"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1633 80623 : scheme.addColor(RGBColor::RED, 0.95);
1634 161246 : edgeColorer.addScheme(scheme);
1635 161246 : scheme = GUIColorScheme("by current speed (streetwise)", TL("by current speed (streetwise)"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1636 80623 : scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1637 80623 : scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1638 80623 : scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1639 80623 : scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1640 80623 : scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1641 161246 : edgeColorer.addScheme(scheme);
1642 161246 : scheme = GUIColorScheme("by current flow (streetwise)", TL("by current flow (streetwise)"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1643 80623 : scheme.addColor(RGBColor::RED, 5000.);
1644 161246 : edgeColorer.addScheme(scheme);
1645 161246 : scheme = GUIColorScheme("by relative speed (streetwise)", TL("by relative speed (streetwise)"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1646 80623 : scheme.addColor(RGBColor::YELLOW, 0.25);
1647 80623 : scheme.addColor(RGBColor::GREEN, 0.5);
1648 80623 : scheme.addColor(RGBColor::CYAN, 0.75);
1649 80623 : scheme.addColor(RGBColor::BLUE, 1.);
1650 80623 : scheme.addColor(RGBColor::MAGENTA, 1.25);
1651 161246 : edgeColorer.addScheme(scheme);
1652 161246 : scheme = GUIColorScheme("by routing device assumed speed", TL("by routing device assumed speed"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1653 80623 : scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1654 80623 : scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1655 80623 : scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1656 80623 : scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1657 80623 : scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1658 161246 : edgeColorer.addScheme(scheme);
1659 241869 : edgeColorer.addScheme(GUIColorScheme("by angle", TL("by angle"), RGBColor::YELLOW, "", true));
1660 161246 : scheme = GUIColorScheme("by segments (alternating)", TL("by segments (alternating)"), RGBColor::BLUE, TL("odd"), true);
1661 80623 : scheme.addColor(RGBColor::RED, 1., TL("even"));
1662 161246 : edgeColorer.addScheme(scheme);
1663 161246 : scheme = GUIColorScheme("by jammed state (segmentwise)", TL("by jammed state (segmentwise)"), RGBColor::GREEN, TL("free"), true, 0, COL_SCHEME_DYNAMIC);
1664 80623 : scheme.addColor(RGBColor::YELLOW, 1., TL("limitedControl"));
1665 80623 : scheme.addColor(RGBColor::RED, 2., TL("jammed"));
1666 161246 : edgeColorer.addScheme(scheme);
1667 161246 : scheme = GUIColorScheme("by current occupancy (segmentwise, brutto)", TL("by current occupancy (segmentwise, brutto)"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1668 80623 : scheme.addColor(RGBColor::RED, 0.95);
1669 161246 : edgeColorer.addScheme(scheme);
1670 161246 : scheme = GUIColorScheme("by current speed (segmentwise)", TL("by current speed (segmentwise)"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1671 80623 : scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1672 80623 : scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1673 80623 : scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1674 80623 : scheme.addColor(RGBColor::BLUE, 120 / 3.6);
1675 80623 : scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1676 161246 : edgeColorer.addScheme(scheme);
1677 161246 : scheme = GUIColorScheme("by current flow (segmentwise)", TL("by current flow (segmentwise)"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1678 80623 : scheme.addColor(RGBColor::RED, 5000.);
1679 161246 : edgeColorer.addScheme(scheme);
1680 161246 : scheme = GUIColorScheme("by relative speed (segmentwise)", TL("by relative speed (segmentwise)"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1681 80623 : scheme.addColor(RGBColor::YELLOW, 0.25);
1682 80623 : scheme.addColor(RGBColor::GREEN, 0.5);
1683 80623 : scheme.addColor(RGBColor::CYAN, 0.75);
1684 80623 : scheme.addColor(RGBColor::BLUE, 1.);
1685 80623 : scheme.addColor(RGBColor::MAGENTA, 1.25);
1686 161246 : edgeColorer.addScheme(scheme);
1687 161246 : scheme = GUIColorScheme("by insertion-backlog (streetwise)", TL("by insertion-backlog (streetwise)"), RGBColor::GREY, "", false, 0, COL_SCHEME_DYNAMIC);
1688 80623 : scheme.addColor(RGBColor::GREEN, 1.);
1689 80623 : scheme.addColor(RGBColor::YELLOW, 10.);
1690 80623 : scheme.addColor(RGBColor::RED, 100.);
1691 161246 : edgeColorer.addScheme(scheme);
1692 161246 : scheme = GUIColorScheme("by TAZ (streetwise)", TL("by TAZ (streetwise)"), RGBColor(204, 204, 204), TL("no TAZ"), true);
1693 161246 : edgeColorer.addScheme(scheme);
1694 161246 : scheme = GUIColorScheme(SCHEME_NAME_EDGE_PARAM_NUMERICAL, TL(SCHEME_NAME_EDGE_PARAM_NUMERICAL.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA);
1695 : scheme.setAllowsNegativeValues(true);
1696 161246 : edgeColorer.addScheme(scheme);
1697 161246 : scheme = GUIColorScheme(SCHEME_NAME_EDGEDATA_NUMERICAL, TL(SCHEME_NAME_EDGEDATA_NUMERICAL.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA);
1698 : scheme.setAllowsNegativeValues(true);
1699 161246 : edgeColorer.addScheme(scheme);
1700 :
1701 : /// add edge scaling schemes
1702 : {
1703 241869 : edgeScaler.addScheme(GUIScaleScheme(TL("uniform"), 1, "", true));
1704 161246 : GUIScaleScheme edgeScheme = GUIScaleScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), 0.5, TL("unselected"), true, 0, COL_SCHEME_MISC);
1705 80623 : edgeScheme.addColor(5, 1., TL("selected"));
1706 161246 : edgeScaler.addScheme(edgeScheme);
1707 161246 : edgeScheme = GUIScaleScheme(TL("by allowed speed (streetwise)"), 0);
1708 80623 : edgeScheme.addColor(10, 150. / 3.6);
1709 161246 : edgeScaler.addScheme(edgeScheme);
1710 161246 : edgeScheme = GUIScaleScheme(TL("by current occupancy (streetwise, brutto)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1711 80623 : edgeScheme.addColor(10, 0.95);
1712 161246 : edgeScaler.addScheme(edgeScheme);
1713 161246 : edgeScheme = GUIScaleScheme(TL("by current speed (streetwise)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1714 80623 : edgeScheme.addColor(10, 150. / 3.6);
1715 161246 : edgeScaler.addScheme(edgeScheme);
1716 161246 : edgeScheme = GUIScaleScheme(TL("by current flow (streetwise)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1717 80623 : edgeScheme.addColor(20, 5000.);
1718 161246 : edgeScaler.addScheme(edgeScheme);
1719 161246 : edgeScheme = GUIScaleScheme(TL("by relative speed (streetwise)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1720 80623 : edgeScheme.addColor(20, 1.);
1721 161246 : edgeScaler.addScheme(edgeScheme);
1722 161246 : edgeScheme = GUIScaleScheme(TL("by insertion-backlog (streetwise)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1723 80623 : edgeScheme.addColor(1, 1.);
1724 80623 : edgeScheme.addColor(10, 10.);
1725 80623 : edgeScheme.addColor(50, 100.);
1726 161246 : edgeScaler.addScheme(edgeScheme);
1727 161246 : edgeScheme = GUIScaleScheme(SCHEME_NAME_EDGEDATA_NUMERICAL, TL(SCHEME_NAME_EDGEDATA_NUMERICAL.c_str()), 0.1, TL("missing data"), false, MISSING_DATA);
1728 80623 : edgeScheme.addColor(1, 1.);
1729 80623 : edgeScheme.addColor(2, 10.);
1730 80623 : edgeScheme.addColor(5, 100.);
1731 80623 : edgeScheme.addColor(10, 1000.);
1732 : edgeScheme.setAllowsNegativeValues(true);
1733 161246 : edgeScaler.addScheme(edgeScheme);
1734 80623 : }
1735 :
1736 : /// add vehicle scaling schemes
1737 : {
1738 241869 : vehicleScaler.addScheme(GUIScaleScheme(TL("uniform"), 1, "", true));
1739 161246 : GUIScaleScheme vehScheme = GUIScaleScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), 1, TL("unselected"), true, 0, COL_SCHEME_MISC);
1740 80623 : vehScheme.addColor(5, 1., TL("selected"));
1741 161246 : vehicleScaler.addScheme(vehScheme);
1742 161246 : vehScheme = GUIScaleScheme(TL("by speed"), 1, "", false, 1, COL_SCHEME_DYNAMIC);
1743 80623 : vehScheme.addColor(5, 150. / 3.6);
1744 : vehScheme.setAllowsNegativeValues(true); // negative speed indicates stopped
1745 80623 : vehScheme.addColor(1, -1.); // stopped on road
1746 80623 : vehScheme.addColor(0.5, -2.); // stopped off-road (parking)
1747 161246 : vehicleScaler.addScheme(vehScheme);
1748 161246 : vehScheme = GUIScaleScheme(TL("by waiting time"), 1, "", false, 1, COL_SCHEME_DYNAMIC);
1749 80623 : vehScheme.addColor(1, 30.);
1750 80623 : vehScheme.addColor(2, 100.);
1751 80623 : vehScheme.addColor(4, 200.);
1752 80623 : vehScheme.addColor(10, 300.);
1753 161246 : vehicleScaler.addScheme(vehScheme);
1754 161246 : vehScheme = GUIScaleScheme(TL("by accumulated waiting time"), 1, "", false, 1, COL_SCHEME_DYNAMIC);
1755 80623 : vehScheme.addColor(5, 100.);
1756 161246 : vehicleScaler.addScheme(vehScheme);
1757 161246 : vehScheme = GUIScaleScheme(TL("by max speed"), 1);
1758 80623 : vehScheme.addColor(1, 30. / 3.6);
1759 80623 : vehScheme.addColor(1, 55. / 3.6);
1760 80623 : vehScheme.addColor(1, 80. / 3.6);
1761 80623 : vehScheme.addColor(1, 120. / 3.6);
1762 80623 : vehScheme.addColor(1, 150. / 3.6);
1763 161246 : vehicleScaler.addScheme(vehScheme);
1764 161246 : vehScheme = GUIScaleScheme(TL("by reroute number"), 1, "", false, 0, COL_SCHEME_DYNAMIC);
1765 80623 : vehScheme.addColor(1, 1.);
1766 80623 : vehScheme.addColor(5, 10.);
1767 161246 : vehicleScaler.addScheme(vehScheme);
1768 161246 : vehScheme = GUIScaleScheme(TL("by offset from best lane"), 0.8, "0", false, 0, COL_SCHEME_DYNAMIC);
1769 80623 : vehScheme.addColor(5, -100, TL("opposite lane"));
1770 80623 : vehScheme.addColor(3, -3, "-3");
1771 80623 : vehScheme.addColor(1.5, -1, "-1");
1772 80623 : vehScheme.addColor(1.5, 1, "1");
1773 80623 : vehScheme.addColor(3, 3, "3");
1774 : vehScheme.setAllowsNegativeValues(true);
1775 161246 : vehicleScaler.addScheme(vehScheme);
1776 161246 : vehScheme = GUIScaleScheme(TL("by acceleration"), 0.8, "0", false, 0, COL_SCHEME_DYNAMIC);
1777 80623 : vehScheme.addColor(4, -9.0);
1778 80623 : vehScheme.addColor(2, -4.5 /* -SUMOVTypeParameter::getDefaultDecel() */);
1779 80623 : vehScheme.addColor(1, -0.1);
1780 80623 : vehScheme.addColor(1, 0.1);
1781 80623 : vehScheme.addColor(1, 2.6 /* SUMOVTypeParameter::getDefaultAccel() */);
1782 80623 : vehScheme.addColor(3, 5.2);
1783 : vehScheme.setAllowsNegativeValues(true);
1784 161246 : vehicleScaler.addScheme(vehScheme);
1785 161246 : vehScheme = GUIScaleScheme(TL("by time gap on lane"), 5, "0", false, 0, COL_SCHEME_DYNAMIC);
1786 80623 : vehScheme.addColor(1, -1);
1787 80623 : vehScheme.addColor(1, 1);
1788 80623 : vehScheme.addColor(0.5, 2);
1789 : vehScheme.setAllowsNegativeValues(true);
1790 161246 : vehicleScaler.addScheme(vehScheme);
1791 161246 : vehScheme = GUIScaleScheme(TL("by depart delay"), 0.8);
1792 80623 : vehScheme.addColor(1, 10.);
1793 80623 : vehScheme.addColor(2, 100.);
1794 80623 : vehScheme.addColor(3, 200.);
1795 80623 : vehScheme.addColor(5, 300.);
1796 161246 : vehicleScaler.addScheme(vehScheme);
1797 161246 : vehScheme = GUIScaleScheme(TL("by time loss"), 1, "", false, 0, COL_SCHEME_DYNAMIC);
1798 80623 : vehScheme.addColor(1, 10.);
1799 80623 : vehScheme.addColor(2, 60.);
1800 80623 : vehScheme.addColor(3, 180.);
1801 80623 : vehScheme.addColor(10, 900.);
1802 161246 : vehicleScaler.addScheme(vehScheme);
1803 161246 : vehScheme = GUIScaleScheme(TL("by stop delay"), 0.1, "", false, -1, COL_SCHEME_DYNAMIC);
1804 80623 : vehScheme.addColor(1, 0.);
1805 80623 : vehScheme.addColor(2, 10.);
1806 80623 : vehScheme.addColor(3, 60.);
1807 80623 : vehScheme.addColor(4, 120.);
1808 80623 : vehScheme.addColor(5, 300.);
1809 80623 : vehScheme.addColor(10, 900.);
1810 : vehScheme.setAllowsNegativeValues(true);
1811 161246 : vehicleScaler.addScheme(vehScheme);
1812 161246 : vehScheme = GUIScaleScheme(TL("by stop arrival delay"), 0.1, "", false, INVALID_DOUBLE, COL_SCHEME_DYNAMIC);
1813 80623 : vehScheme.addColor(0.5, -10.);
1814 80623 : vehScheme.addColor(1, 0.);
1815 80623 : vehScheme.addColor(2, 10.);
1816 80623 : vehScheme.addColor(3, 60.);
1817 80623 : vehScheme.addColor(4, 120.);
1818 80623 : vehScheme.addColor(5, 300.);
1819 80623 : vehScheme.addColor(10, 900.);
1820 : vehScheme.setAllowsNegativeValues(true);
1821 161246 : vehicleScaler.addScheme(vehScheme);
1822 161246 : vehScheme = GUIScaleScheme(SCHEME_NAME_PARAM_NUMERICAL, TL(SCHEME_NAME_PARAM_NUMERICAL.c_str()), 1, TL("missing data"), false, MISSING_DATA);
1823 : vehScheme.setAllowsNegativeValues(true);
1824 161246 : vehicleScaler.addScheme(vehScheme);
1825 80623 : }
1826 : // dummy schemes
1827 241869 : dataScaler.addScheme(GUIScaleScheme(TL("uniform"), 1, "", true));
1828 80623 : }
1829 :
1830 :
1831 : void
1832 0 : GUIVisualizationSettings::initNeteditDefaults() {
1833 : // init color schemes
1834 0 : GUIColorScheme scheme = GUIColorScheme("uniform", TL("uniform"), RGBColor::BLACK, TL("road"), true);
1835 0 : scheme.addColor(RGBColor::GREY, 1, TL("sidewalk"));
1836 0 : scheme.addColor(RGBColor(192, 66, 44), 2, TL("bike lane"));
1837 0 : scheme.addColor(RGBColor(200, 255, 200), 3, TL("green verge"));
1838 0 : scheme.addColor(RGBColor(150, 200, 200), 4, TL("waterway"));
1839 0 : scheme.addColor(RGBColor::BLACK, 5, TL("railway"));
1840 0 : scheme.addColor(RGBColor(64, 0, 64), 6, TL("rails on road"));
1841 0 : scheme.addColor(RGBColor(92, 92, 92), 7, TL("no passenger")); // paths, service roads etc
1842 0 : scheme.addColor(RGBColor::RED, 8, TL("closed")); // road closing
1843 0 : scheme.addColor(RGBColor::GREEN, 9, TL("connector")); // macro-connector
1844 0 : scheme.addColor(RGBColor::ORANGE, 10, TL("forbidden")); // forbidden road
1845 0 : scheme.addColor(RGBColor(145, 145, 145), 11, TL("data mode"));
1846 0 : scheme.addColor(RGBColor(200, 240, 240), 12, TL("airway"));
1847 0 : laneColorer.addScheme(scheme);
1848 0 : scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(128, 128, 128, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1849 0 : scheme.addColor(RGBColor(0, 80, 180, 255), 1., TL("selected"));
1850 0 : laneColorer.addScheme(scheme);
1851 0 : scheme = GUIColorScheme("by permission code", TL("by permission code"), RGBColor(240, 240, 240), "nobody");
1852 0 : scheme.addColor(RGBColor(10, 10, 10), (double)SVC_PASSENGER, "passenger");
1853 0 : scheme.addColor(RGBColor(128, 128, 128), (double)SVC_PEDESTRIAN, "pedestrian");
1854 0 : scheme.addColor(RGBColor(80, 80, 80), (double)(SVC_PEDESTRIAN | SVC_DELIVERY), "pedestrian_delivery");
1855 0 : scheme.addColor(RGBColor(192, 66, 44), (double)SVC_BICYCLE, "bicycle");
1856 0 : scheme.addColor(RGBColor(40, 100, 40), (double)SVC_BUS, "bus");
1857 0 : scheme.addColor(RGBColor(166, 147, 26), (double)SVC_TAXI, "taxi");
1858 0 : scheme.addColor(RGBColor::BLACK, (double)(SVCAll & ~SVC_NON_ROAD), "normal_road");
1859 0 : scheme.addColor(RGBColor::BLACK, (double)(SVCAll & ~(SVC_PEDESTRIAN | SVC_NON_ROAD)), "disallow_pedestrian");
1860 0 : scheme.addColor(RGBColor(255, 206, 0), (double)(SVCAll & ~(SVC_PEDESTRIAN | SVC_BICYCLE | SVC_MOPED | SVC_NON_ROAD)), "motorway");
1861 0 : scheme.addColor(RGBColor(150, 200, 200), (double)SVC_SHIP, "waterway");
1862 0 : scheme.addColor(RGBColor::GREEN, (double)SVCAll, "all");
1863 0 : laneColorer.addScheme(scheme);
1864 :
1865 0 : scheme = GUIColorScheme("by allowed speed (lanewise)", TL("by allowed speed (lanewise)"), RGBColor::RED);
1866 0 : scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1867 0 : scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1868 0 : scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1869 0 : scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1870 0 : scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1871 0 : laneColorer.addScheme(scheme);
1872 :
1873 0 : scheme = GUIColorScheme("by lane number (streetwise)", TL("by lane number (streetwise)"), RGBColor::RED);
1874 0 : scheme.addColor(RGBColor::BLUE, 5.);
1875 0 : laneColorer.addScheme(scheme);
1876 :
1877 0 : scheme = GUIColorScheme("by given length/geometrical length", TL("by given length/geometrical length"), RGBColor::RED);
1878 0 : scheme.addColor(RGBColor::ORANGE, 0.25);
1879 0 : scheme.addColor(RGBColor::YELLOW, 0.5);
1880 0 : scheme.addColor(RGBColor(179, 179, 179, 255), 1.);
1881 0 : scheme.addColor(RGBColor::GREEN, 2.);
1882 0 : scheme.addColor(RGBColor::CYAN, 4.);
1883 0 : scheme.addColor(RGBColor::BLUE, 100.);
1884 0 : laneColorer.addScheme(scheme);
1885 0 : laneColorer.addScheme(GUIColorScheme("by angle", TL("by angle"), RGBColor::YELLOW, "", true));
1886 :
1887 0 : scheme = GUIColorScheme("by priority", TL("by priority"), RGBColor::YELLOW);
1888 0 : scheme.addColor(RGBColor::RED, -20.);
1889 0 : scheme.addColor(RGBColor::GREEN, 20.);
1890 : scheme.setAllowsNegativeValues(true);
1891 0 : laneColorer.addScheme(scheme);
1892 0 : scheme = GUIColorScheme("by height at start", TL("by height at start"), RGBColor::RED);
1893 0 : scheme.addColor(RGBColor::BLUE, -10.);
1894 0 : scheme.addColor(RGBColor::YELLOW, 50.);
1895 0 : scheme.addColor(RGBColor::GREEN, 100.);
1896 0 : scheme.addColor(RGBColor::MAGENTA, 200.);
1897 : scheme.setAllowsNegativeValues(true);
1898 0 : laneColorer.addScheme(scheme);
1899 0 : scheme = GUIColorScheme("by height at segment start", TL("by height at segment start"), RGBColor::RED);
1900 0 : scheme.addColor(RGBColor::BLUE, -10.);
1901 0 : scheme.addColor(RGBColor::YELLOW, 50.);
1902 0 : scheme.addColor(RGBColor::GREEN, 100.);
1903 0 : scheme.addColor(RGBColor::MAGENTA, 200.);
1904 : scheme.setAllowsNegativeValues(true);
1905 0 : laneColorer.addScheme(scheme);
1906 0 : scheme = GUIColorScheme("by inclination", TL("by inclination"), RGBColor::GREY);
1907 0 : scheme.addColor(RGBColor::YELLOW, 0.1);
1908 0 : scheme.addColor(RGBColor::RED, 0.3);
1909 0 : scheme.addColor(RGBColor::GREEN, -0.1);
1910 0 : scheme.addColor(RGBColor::BLUE, -0.3);
1911 : scheme.setAllowsNegativeValues(true);
1912 0 : laneColorer.addScheme(scheme);
1913 0 : scheme = GUIColorScheme("by segment inclination", TL("by segment inclination"), RGBColor::GREY);
1914 0 : scheme.addColor(RGBColor::YELLOW, 0.1);
1915 0 : scheme.addColor(RGBColor::RED, 0.3);
1916 0 : scheme.addColor(RGBColor::GREEN, -0.1);
1917 0 : scheme.addColor(RGBColor::BLUE, -0.3);
1918 : scheme.setAllowsNegativeValues(true);
1919 0 : laneColorer.addScheme(scheme);
1920 0 : scheme = GUIColorScheme(SCHEME_NAME_EDGE_PARAM_NUMERICAL, TL(SCHEME_NAME_EDGE_PARAM_NUMERICAL.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA);
1921 : scheme.setAllowsNegativeValues(true);
1922 0 : laneColorer.addScheme(scheme);
1923 0 : scheme = GUIColorScheme(SCHEME_NAME_LANE_PARAM_NUMERICAL, TL(SCHEME_NAME_LANE_PARAM_NUMERICAL.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA);
1924 : scheme.setAllowsNegativeValues(true);
1925 0 : laneColorer.addScheme(scheme);
1926 0 : scheme = GUIColorScheme("by distance (kilometrage)", TL("by distance (kilometrage)"), RGBColor(204, 204, 204));
1927 0 : scheme.addColor(RGBColor::RED, 1.);
1928 0 : scheme.addColor(RGBColor::RED, -1.);
1929 : scheme.setAllowsNegativeValues(true);
1930 0 : laneColorer.addScheme(scheme);
1931 0 : scheme = GUIColorScheme("by abs distance (kilometrage)", TL("by abs distance (kilometrage)"), RGBColor(204, 204, 204));
1932 0 : scheme.addColor(RGBColor::RED, 1.);
1933 : scheme.setAllowsNegativeValues(false);
1934 0 : laneColorer.addScheme(scheme);
1935 0 : scheme = GUIColorScheme(SCHEME_NAME_EDGEDATA_NUMERICAL, TL(SCHEME_NAME_EDGEDATA_NUMERICAL.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA);
1936 : scheme.setAllowsNegativeValues(true);
1937 0 : laneColorer.addScheme(scheme);
1938 :
1939 : /// add junction coloring schemes
1940 0 : scheme = GUIColorScheme("uniform", TL("uniform"), RGBColor(102, 0, 0), "", true);
1941 0 : scheme.addColor(RGBColor(204, 0, 0), 1, TL("junction bubble"));
1942 0 : scheme.addColor(RGBColor(230, 100, 115), 2, TL("geometry points"));
1943 0 : scheme.addColor(GUIVisualizationColorSettings::SUMO_color_DEADEND_SHOW, 3, TL("connections missing"));
1944 0 : scheme.addColor(RGBColor::GREEN, 3, TL("custom shape"));
1945 0 : scheme.addColor(RGBColor(205, 180, 180), 4, TL("data mode"));
1946 0 : junctionColorer.addScheme(scheme);
1947 0 : scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(128, 128, 128, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1948 0 : scheme.addColor(RGBColor(0, 80, 180, 255), 1, TL("selected"));
1949 0 : junctionColorer.addScheme(scheme);
1950 0 : scheme = GUIColorScheme(SCHEME_NAME_TYPE, TL(SCHEME_NAME_TYPE.c_str()), RGBColor::GREEN, "traffic_light", true);
1951 0 : scheme.addColor(RGBColor(0, 128, 0), 1, "traffic_light_unregulated");
1952 0 : scheme.addColor(RGBColor::YELLOW, 2, "priority");
1953 0 : scheme.addColor(RGBColor::RED, 3, "priority_stop");
1954 0 : scheme.addColor(RGBColor::BLUE, 4, "right_before_left");
1955 0 : scheme.addColor(RGBColor::CYAN, 5, "allway_stop");
1956 0 : scheme.addColor(RGBColor::GREY, 6, "district");
1957 0 : scheme.addColor(RGBColor::MAGENTA, 7, "unregulated");
1958 0 : scheme.addColor(RGBColor::BLACK, 8, "dead_end");
1959 0 : scheme.addColor(RGBColor::ORANGE, 9, "rail_signal");
1960 0 : scheme.addColor(RGBColor(172, 108, 44), 10, "zipper"); // brown, darker than the zipper link rule
1961 0 : scheme.addColor(RGBColor(192, 255, 192), 11, "traffic_light_right_on_red");
1962 0 : scheme.addColor(RGBColor(128, 0, 128), 12, "rail_crossing"); // dark purple
1963 0 : scheme.addColor(RGBColor(0, 0, 128), 13, "left_before_right"); // dark blue
1964 0 : junctionColorer.addScheme(scheme);
1965 0 : scheme = GUIColorScheme("by height", TL("by height"), RGBColor::GREY);
1966 0 : scheme.addColor(RGBColor::BLUE, -10.);
1967 0 : scheme.addColor(RGBColor::RED, 10.);
1968 0 : scheme.addColor(RGBColor::YELLOW, 50.);
1969 0 : scheme.addColor(RGBColor::GREEN, 100.);
1970 0 : scheme.addColor(RGBColor::MAGENTA, 200.);
1971 : scheme.setAllowsNegativeValues(true);
1972 0 : junctionColorer.addScheme(scheme);
1973 :
1974 : /// add POI coloring schemes
1975 0 : poiColorer.addScheme(GUIColorScheme("given POI color", TL("given POI color"), RGBColor::RED, "", true));
1976 0 : scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(179, 179, 179, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1977 0 : scheme.addColor(RGBColor(0, 102, 204, 255), 1, TL("selected"));
1978 0 : poiColorer.addScheme(scheme);
1979 0 : poiColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::RED, "", true));
1980 :
1981 : /// add polygon coloring schemes
1982 0 : polyColorer.addScheme(GUIColorScheme("given polygon color", TL("given polygon color"), RGBColor::ORANGE, "", true));
1983 0 : scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(179, 179, 179, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1984 0 : scheme.addColor(RGBColor(0, 102, 204, 255), 1, TL("selected"));
1985 0 : polyColorer.addScheme(scheme);
1986 0 : polyColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::ORANGE, "", true));
1987 0 : polyColorer.addScheme(GUIColorScheme("random", TL("random"), RGBColor::YELLOW, "", true));
1988 :
1989 : /// add edge scaling schemes
1990 : {
1991 0 : GUIScaleScheme edgeScheme = GUIScaleScheme(TL("default"), 1, TL("uniform"), true);
1992 0 : laneScaler.addScheme(edgeScheme);
1993 0 : }
1994 :
1995 : /// add data coloring schemes
1996 0 : dataColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::ORANGE, "", true));
1997 0 : scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(128, 128, 128, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1998 0 : scheme.addColor(RGBColor(0, 80, 180, 255), 1, TL("selected"));
1999 0 : dataColorer.addScheme(scheme);
2000 0 : dataColorer.addScheme(GUIColorScheme("by origin taz", TL("by origin taz"), RGBColor::ORANGE, "", true));
2001 0 : dataColorer.addScheme(GUIColorScheme("by destination taz", TL("by destination taz"), RGBColor::ORANGE, "", true));
2002 0 : scheme = GUIColorScheme(SCHEME_NAME_DATA_ATTRIBUTE_NUMERICAL, TL(SCHEME_NAME_DATA_ATTRIBUTE_NUMERICAL.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA);
2003 : scheme.setAllowsNegativeValues(true);
2004 0 : dataColorer.addScheme(scheme);
2005 :
2006 : /// add data scaling schemes
2007 0 : dataScaler.addScheme(GUIScaleScheme(TL("uniform"), 1, "", true));
2008 0 : GUIScaleScheme dataScheme = GUIScaleScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), 1, TL("unselected"), true, 0, COL_SCHEME_MISC);
2009 0 : dataScheme.addColor(5, 1., TL("selected"));
2010 0 : dataScaler.addScheme(dataScheme);
2011 0 : dataScheme = GUIScaleScheme(SCHEME_NAME_DATA_ATTRIBUTE_NUMERICAL, TL(SCHEME_NAME_DATA_ATTRIBUTE_NUMERICAL.c_str()), 1, TL("missing data"), false, MISSING_DATA);
2012 : dataScheme.setAllowsNegativeValues(true);
2013 0 : dataScheme.addColor(1, 1);
2014 0 : dataScheme.addColor(5, 100);
2015 0 : dataScheme.addColor(10, 1000);
2016 0 : dataScheme.addColor(20, 10000);
2017 0 : dataScheme.addColor(30, 100000);
2018 0 : dataScaler.addScheme(dataScheme);
2019 :
2020 : // dummy schemes
2021 0 : vehicleColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::YELLOW, "", true));
2022 0 : personColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::YELLOW, "", true));
2023 0 : containerColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::YELLOW, "", true));
2024 0 : vehicleScaler.addScheme(GUIScaleScheme(TL("uniform"), 1, "", true));
2025 0 : }
2026 :
2027 :
2028 : int
2029 0 : GUIVisualizationSettings::getLaneEdgeMode() const {
2030 0 : if (UseMesoSim) {
2031 0 : return edgeColorer.getActive();
2032 : }
2033 0 : return laneColorer.getActive();
2034 : }
2035 :
2036 :
2037 : int
2038 0 : GUIVisualizationSettings::getLaneEdgeScaleMode() const {
2039 0 : if (UseMesoSim) {
2040 0 : return edgeScaler.getActive();
2041 : }
2042 0 : return laneScaler.getActive();
2043 : }
2044 :
2045 :
2046 : GUIColorScheme&
2047 0 : GUIVisualizationSettings::getLaneEdgeScheme() {
2048 0 : if (UseMesoSim) {
2049 0 : return edgeColorer.getScheme();
2050 : }
2051 0 : return laneColorer.getScheme();
2052 : }
2053 :
2054 :
2055 : GUIScaleScheme&
2056 0 : GUIVisualizationSettings::getLaneEdgeScaleScheme() {
2057 0 : if (UseMesoSim) {
2058 0 : return edgeScaler.getScheme();
2059 : }
2060 0 : return laneScaler.getScheme();
2061 : }
2062 :
2063 :
2064 : void
2065 0 : GUIVisualizationSettings::save(OutputDevice& dev) const {
2066 0 : dev.openTag(SUMO_TAG_VIEWSETTINGS_SCHEME);
2067 0 : dev.writeAttr(SUMO_ATTR_NAME, name);
2068 0 : dev.openTag(SUMO_TAG_VIEWSETTINGS_OPENGL);
2069 0 : dev.writeAttr("dither", dither);
2070 0 : dev.writeAttr("fps", fps);
2071 0 : dev.writeAttr("trueZ", trueZ);
2072 0 : dev.writeAttr("drawBoundaries", drawBoundaries);
2073 0 : dev.writeAttr("disableDottedContours", disableDottedContours);
2074 0 : dev.writeAttr("forceDrawRectangleSelection", forceDrawForRectangleSelection);
2075 0 : geometryIndices.print(dev, "geometryIndices");
2076 0 : dev.closeTag();
2077 0 : dev.openTag(SUMO_TAG_VIEWSETTINGS_BACKGROUND);
2078 0 : dev.writeAttr("backgroundColor", backgroundColor);
2079 0 : dev.writeAttr("showGrid", showGrid);
2080 0 : dev.writeAttr("gridXSize", gridXSize);
2081 0 : dev.writeAttr("gridYSize", gridYSize);
2082 0 : dev.closeTag();
2083 : // edges
2084 0 : dev.openTag(SUMO_TAG_VIEWSETTINGS_EDGES);
2085 0 : dev.writeAttr("laneEdgeMode", getLaneEdgeMode());
2086 0 : dev.writeAttr("scaleMode", getLaneEdgeScaleMode());
2087 0 : dev.writeAttr("laneShowBorders", laneShowBorders);
2088 0 : dev.writeAttr("showBikeMarkings", showBikeMarkings);
2089 0 : dev.writeAttr("showLinkDecals", showLinkDecals);
2090 0 : dev.writeAttr("realisticLinkRules", realisticLinkRules);
2091 0 : dev.writeAttr("showLinkRules", showLinkRules);
2092 0 : dev.writeAttr("showRails", showRails);
2093 0 : dev.writeAttr("secondaryShape", secondaryShape);
2094 0 : dev.writeAttr("hideConnectors", hideConnectors);
2095 0 : dev.writeAttr("widthExaggeration", laneWidthExaggeration);
2096 0 : dev.writeAttr("minSize", laneMinSize);
2097 0 : dev.writeAttr("showDirection", showLaneDirection);
2098 0 : dev.writeAttr("showSublanes", showSublanes);
2099 0 : dev.writeAttr("spreadSuperposed", spreadSuperposed);
2100 0 : dev.writeAttr("disableHideByZoom", disableHideByZoom);
2101 0 : dev.writeAttr("edgeParam", edgeParam);
2102 0 : dev.writeAttr("laneParam", laneParam);
2103 0 : dev.writeAttr("edgeData", edgeData);
2104 0 : dev.writeAttr("edgeDataID", edgeDataID);
2105 0 : dev.writeAttr("edgeDataScaling", edgeDataScaling);
2106 0 : edgeValueRainBow.print(dev, "edgeValue");
2107 0 : dev.lf();
2108 0 : dev << " ";
2109 0 : edgeName.print(dev, "edgeName");
2110 0 : dev.lf();
2111 0 : dev << " ";
2112 0 : internalEdgeName.print(dev, "internalEdgeName");
2113 0 : dev.lf();
2114 0 : dev << " ";
2115 0 : cwaEdgeName.print(dev, "cwaEdgeName");
2116 0 : dev.lf();
2117 0 : dev << " ";
2118 0 : streetName.print(dev, "streetName");
2119 0 : dev.lf();
2120 0 : dev << " ";
2121 0 : edgeValue.print(dev, "edgeValue");
2122 0 : edgeScaleValue.print(dev, "edgeScaleValue");
2123 0 : laneColorer.save(dev);
2124 0 : laneScaler.save(dev);
2125 0 : edgeColorer.save(dev, "meso:");
2126 0 : edgeScaler.save(dev, "meso:");
2127 0 : dev.closeTag();
2128 : // vehicles
2129 0 : dev.openTag(SUMO_TAG_VIEWSETTINGS_VEHICLES);
2130 0 : dev.writeAttr("vehicleMode", vehicleColorer.getActive());
2131 0 : dev.writeAttr("vehicleScaleMode", vehicleScaler.getActive());
2132 0 : dev.writeAttr("vehicleQuality", vehicleQuality);
2133 0 : vehicleSize.print(dev, "vehicle");
2134 0 : vehicleValueRainBow.print(dev, "vehicleValueRainbow");
2135 0 : dev.writeAttr("showBlinker", showBlinker);
2136 0 : dev.writeAttr("drawMinGap", drawMinGap);
2137 0 : dev.writeAttr("drawBrakeGap", drawBrakeGap);
2138 0 : dev.writeAttr("showBTRange", showBTRange);
2139 0 : dev.writeAttr("showRouteIndex", showRouteIndex);
2140 0 : dev.writeAttr("scaleLength", scaleLength);
2141 0 : dev.writeAttr("drawReversed", drawReversed);
2142 0 : dev.writeAttr("showParkingInfo", showParkingInfo);
2143 0 : dev.writeAttr("showChargingInfo", showChargingInfo);
2144 0 : dev.writeAttr("vehicleParam", vehicleParam);
2145 0 : dev.writeAttr("vehicleScaleParam", vehicleScaleParam);
2146 0 : dev.writeAttr("vehicleTextParam", vehicleTextParam);
2147 0 : dev.lf();
2148 0 : dev << " ";
2149 0 : vehicleName.print(dev, "vehicleName");
2150 0 : dev.lf();
2151 0 : dev << " ";
2152 0 : vehicleValue.print(dev, "vehicleValue");
2153 0 : dev.lf();
2154 0 : dev << " ";
2155 0 : vehicleScaleValue.print(dev, "vehicleScaleValue");
2156 0 : dev.lf();
2157 0 : dev << " ";
2158 0 : vehicleText.print(dev, "vehicleText");
2159 0 : vehicleColorer.save(dev);
2160 0 : vehicleScaler.save(dev);
2161 0 : dev.closeTag();
2162 : // persons
2163 0 : dev.openTag(SUMO_TAG_VIEWSETTINGS_PERSONS);
2164 0 : dev.writeAttr("personMode", personColorer.getActive());
2165 0 : dev.writeAttr("personQuality", personQuality);
2166 0 : dev.writeAttr("showPedestrianNetwork", showPedestrianNetwork);
2167 0 : dev.writeAttr("pedestrianNetworkColor", pedestrianNetworkColor);
2168 0 : personSize.print(dev, "person");
2169 0 : dev.lf();
2170 0 : dev << " ";
2171 0 : personName.print(dev, "personName");
2172 0 : dev.lf();
2173 0 : dev << " ";
2174 0 : personValue.print(dev, "personValue");
2175 0 : personColorer.save(dev);
2176 0 : dev.closeTag();
2177 : // containers
2178 0 : dev.openTag(SUMO_TAG_VIEWSETTINGS_CONTAINERS);
2179 0 : dev.writeAttr("containerMode", containerColorer.getActive());
2180 0 : dev.writeAttr("containerQuality", containerQuality);
2181 0 : containerSize.print(dev, "container");
2182 0 : dev.lf();
2183 0 : dev << " ";
2184 0 : containerName.print(dev, "containerName");
2185 0 : containerColorer.save(dev);
2186 0 : dev.closeTag();
2187 : // junctions
2188 0 : dev.openTag(SUMO_TAG_VIEWSETTINGS_JUNCTIONS);
2189 0 : dev.writeAttr("junctionMode", junctionColorer.getActive());
2190 0 : dev.lf();
2191 0 : dev << " ";
2192 0 : drawLinkTLIndex.print(dev, "drawLinkTLIndex");
2193 0 : dev.lf();
2194 0 : dev << " ";
2195 0 : drawLinkJunctionIndex.print(dev, "drawLinkJunctionIndex");
2196 0 : dev.lf();
2197 0 : dev << " ";
2198 0 : junctionID.print(dev, "junctionID");
2199 0 : dev.lf();
2200 0 : dev << " ";
2201 0 : junctionName.print(dev, "junctionName");
2202 0 : dev.lf();
2203 0 : dev << " ";
2204 0 : internalJunctionName.print(dev, "internalJunctionName");
2205 0 : dev.lf();
2206 0 : dev << " ";
2207 0 : tlsPhaseIndex.print(dev, "tlsPhaseIndex");
2208 0 : tlsPhaseName.print(dev, "tlsPhaseName");
2209 0 : dev.lf();
2210 0 : dev << " ";
2211 0 : dev.writeAttr("showLane2Lane", showLane2Lane);
2212 0 : dev.writeAttr("drawShape", drawJunctionShape);
2213 0 : dev.writeAttr("drawCrossingsAndWalkingareas", drawCrossingsAndWalkingareas);
2214 0 : junctionSize.print(dev, "junction");
2215 0 : junctionValueRainBow.print(dev, "junctionValue");
2216 0 : junctionColorer.save(dev);
2217 0 : dev.closeTag();
2218 : // additionals
2219 0 : dev.openTag(SUMO_TAG_VIEWSETTINGS_ADDITIONALS);
2220 0 : dev.writeAttr("addMode", addMode);
2221 0 : addSize.print(dev, "add");
2222 0 : addName.print(dev, "addName");
2223 0 : addFullName.print(dev, "addFullName");
2224 : // temporal (will be integrated in a schema)
2225 0 : dev.writeAttr("busStopColor", colorSettings.busStopColor);
2226 0 : dev.writeAttr("busStopColorSign", colorSettings.busStopColorSign);
2227 0 : dev.writeAttr("chargingStationColor", colorSettings.chargingStationColor);
2228 0 : dev.writeAttr("chargingStationColorCharge", colorSettings.chargingStationColorCharge);
2229 0 : dev.writeAttr("chargingStationColorSign", colorSettings.chargingStationColorSign);
2230 0 : dev.writeAttr("containerStopColor", colorSettings.containerStopColor);
2231 0 : dev.writeAttr("containerStopColorSign", colorSettings.containerStopColorSign);
2232 0 : dev.writeAttr("parkingAreaColor", colorSettings.parkingAreaColor);
2233 0 : dev.writeAttr("parkingAreaColorSign", colorSettings.parkingAreaColorSign);
2234 0 : dev.writeAttr("parkingSpaceColor", colorSettings.parkingSpaceColor);
2235 0 : dev.writeAttr("parkingSpaceColorContour", colorSettings.parkingSpaceColorContour);
2236 0 : dev.writeAttr("personTripColor", colorSettings.personTripColor);
2237 0 : dev.writeAttr("personTripWidth", widthSettings.personTripWidth);
2238 0 : dev.writeAttr("rideColor", colorSettings.rideColor);
2239 0 : dev.writeAttr("rideWidth", widthSettings.rideWidth);
2240 0 : dev.writeAttr("selectedAdditionalColor", colorSettings.selectedAdditionalColor);
2241 0 : dev.writeAttr("selectedConnectionColor", colorSettings.selectedConnectionColor);
2242 0 : dev.writeAttr("selectedContainerColor", colorSettings.selectedContainerColor);
2243 0 : dev.writeAttr("selectedContainerPlanColor", colorSettings.selectedContainerPlanColor);
2244 0 : dev.writeAttr("selectedCrossingColor", colorSettings.selectedCrossingColor);
2245 0 : dev.writeAttr("selectedEdgeColor", colorSettings.selectedEdgeColor);
2246 0 : dev.writeAttr("selectedEdgeDataColor", colorSettings.selectedEdgeDataColor);
2247 0 : dev.writeAttr("selectedLaneColor", colorSettings.selectedLaneColor);
2248 0 : dev.writeAttr("selectedPersonColor", colorSettings.selectedPersonColor);
2249 0 : dev.writeAttr("selectedPersonPlanColor", colorSettings.selectedPersonPlanColor);
2250 0 : dev.writeAttr("selectedProhibitionColor", colorSettings.selectedProhibitionColor);
2251 0 : dev.writeAttr("selectedRouteColor", colorSettings.selectedRouteColor);
2252 0 : dev.writeAttr("selectedVehicleColor", colorSettings.selectedVehicleColor);
2253 0 : dev.writeAttr("selectionColor", colorSettings.selectionColor);
2254 0 : dev.writeAttr("stopColor", colorSettings.stopColor);
2255 0 : dev.writeAttr("waypointColor", colorSettings.waypointColor);
2256 0 : dev.writeAttr("stopContainerColor", colorSettings.stopContainerColor);
2257 0 : dev.writeAttr("stopPersonColor", colorSettings.stopPersonColor);
2258 0 : dev.writeAttr("trainStopColor", colorSettings.trainStopColor);
2259 0 : dev.writeAttr("trainStopColorSign", colorSettings.trainStopColorSign);
2260 0 : dev.writeAttr("transhipColor", colorSettings.transhipColor);
2261 0 : dev.writeAttr("transhipWidth", widthSettings.transhipWidth);
2262 0 : dev.writeAttr("transportColor", colorSettings.transportColor);
2263 0 : dev.writeAttr("transportWidth", widthSettings.transportWidth);
2264 0 : dev.writeAttr("tripWidth", widthSettings.tripWidth);
2265 0 : dev.writeAttr("vehicleTripColor", colorSettings.personTripColor);
2266 0 : dev.writeAttr("walkColor", colorSettings.walkColor);
2267 0 : dev.writeAttr("walkWidth", widthSettings.walkWidth);
2268 0 : dev.closeTag();
2269 : // pois
2270 0 : dev.openTag(SUMO_TAG_VIEWSETTINGS_POIS);
2271 0 : dev.writeAttr("poiTextParam", poiTextParam);
2272 0 : poiSize.print(dev, "poi");
2273 0 : dev.writeAttr("poiDetail", poiDetail);
2274 0 : poiName.print(dev, "poiName");
2275 0 : poiType.print(dev, "poiType");
2276 0 : poiText.print(dev, "poiText");
2277 0 : dev.writeAttr("poiUseCustomLayer", poiUseCustomLayer);
2278 0 : dev.writeAttr("poiCustomLayer", poiCustomLayer);
2279 0 : poiColorer.save(dev);
2280 0 : dev.closeTag();
2281 : // polys
2282 0 : dev.openTag(SUMO_TAG_VIEWSETTINGS_POLYS);
2283 0 : polySize.print(dev, "poly");
2284 0 : polyName.print(dev, "polyName");
2285 0 : polyType.print(dev, "polyType");
2286 0 : dev.writeAttr("polyUseCustomLayer", polyUseCustomLayer);
2287 0 : dev.writeAttr("polyCustomLayer", polyCustomLayer);
2288 0 : polyColorer.save(dev);
2289 0 : dev.closeTag();
2290 : // data
2291 0 : if (netedit) {
2292 0 : dev.openTag(SUMO_TAG_VIEWSETTINGS_DATA);
2293 0 : dev.writeAttr("dataMode", dataColorer.getActive());
2294 0 : dev.lf();
2295 0 : dev << " ";
2296 0 : dev.writeAttr("dataScaleMode", dataScaler.getActive());
2297 0 : dev.lf();
2298 0 : dev << " ";
2299 0 : dataValueRainBow.print(dev, "dataValueRainbow");
2300 0 : dataValue.print(dev, "dataValue");
2301 0 : dev.writeAttr("tazRelExaggeration", tazRelWidthExaggeration);
2302 0 : dev.writeAttr("edgeRelExaggeration", edgeRelWidthExaggeration);
2303 0 : dev.writeAttr("relDataAttr", relDataAttr);
2304 0 : dev.writeAttr("relDataScaleAttr", relDataScaleAttr);
2305 0 : dataColorer.save(dev);
2306 0 : dataScaler.save(dev);
2307 0 : dev.closeTag();
2308 : }
2309 : // 3D
2310 0 : dev.openTag(SUMO_TAG_VIEWSETTINGS_3D);
2311 0 : dev.writeAttr("ignoreColorSchemeFor3DVehicles", ignoreColorSchemeFor3DVehicles);
2312 0 : dev.writeAttr("show3DTLSLinkMarkers", show3DTLSLinkMarkers);
2313 0 : dev.writeAttr("show3DTLSDomes", show3DTLSDomes);
2314 0 : dev.writeAttr("show3DHeadUpDisplay", show3DHeadUpDisplay);
2315 0 : dev.writeAttr("generate3DTLSModels", generate3DTLSModels);
2316 0 : dev.writeAttr("ambient3DLight", ambient3DLight);
2317 0 : dev.writeAttr("diffuse3DLight", diffuse3DLight);
2318 0 : dev.closeTag();
2319 : // legend
2320 0 : dev.openTag(SUMO_TAG_VIEWSETTINGS_LEGEND);
2321 0 : dev.writeAttr("showSizeLegend", showSizeLegend);
2322 0 : dev.writeAttr("showColorLegend", showColorLegend);
2323 0 : dev.writeAttr("showVehicleColorLegend", showVehicleColorLegend);
2324 0 : dev.closeTag();
2325 :
2326 0 : dev.closeTag();
2327 0 : }
2328 :
2329 :
2330 : bool
2331 0 : GUIVisualizationSettings::operator==(const GUIVisualizationSettings& v2) {
2332 0 : if (ignoreColorSchemeFor3DVehicles != v2.ignoreColorSchemeFor3DVehicles) {
2333 : return false;
2334 : }
2335 0 : if (show3DTLSDomes != v2.show3DTLSDomes) {
2336 : return false;
2337 : }
2338 0 : if (show3DTLSLinkMarkers != v2.show3DTLSLinkMarkers) {
2339 : return false;
2340 : }
2341 0 : if (show3DHeadUpDisplay != v2.show3DHeadUpDisplay) {
2342 : return false;
2343 : }
2344 0 : if (generate3DTLSModels != v2.generate3DTLSModels) {
2345 : return false;
2346 : }
2347 0 : if (ambient3DLight != v2.ambient3DLight) {
2348 : return false;
2349 : }
2350 0 : if (diffuse3DLight != v2.diffuse3DLight) {
2351 : return false;
2352 : }
2353 0 : if (skyColor != v2.skyColor) {
2354 : return false;
2355 : }
2356 0 : if (dither != v2.dither) {
2357 : return false;
2358 : }
2359 0 : if (fps != v2.fps) {
2360 : return false;
2361 : }
2362 0 : if (trueZ != v2.trueZ) {
2363 : return false;
2364 : }
2365 0 : if (drawBoundaries != v2.drawBoundaries) {
2366 : return false;
2367 : }
2368 0 : if (disableDottedContours != v2.disableDottedContours) {
2369 : return false;
2370 : }
2371 0 : if (forceDrawForRectangleSelection != v2.forceDrawForRectangleSelection) {
2372 : return false;
2373 : }
2374 0 : if (geometryIndices != v2.geometryIndices) {
2375 : return false;
2376 : }
2377 0 : if (backgroundColor != v2.backgroundColor) {
2378 : return false;
2379 : }
2380 0 : if (colorSettings != v2.colorSettings) {
2381 : return false;
2382 : }
2383 0 : if (showGrid != v2.showGrid) {
2384 : return false;
2385 : }
2386 0 : if (gridXSize != v2.gridXSize) {
2387 : return false;
2388 : }
2389 0 : if (gridYSize != v2.gridYSize) {
2390 : return false;
2391 : }
2392 :
2393 : if (!(edgeColorer == v2.edgeColorer)) {
2394 0 : return false;
2395 : }
2396 0 : if (!(edgeScaler == v2.edgeScaler)) {
2397 : return false;
2398 : }
2399 : if (!(laneColorer == v2.laneColorer)) {
2400 0 : return false;
2401 : }
2402 0 : if (!(laneScaler == v2.laneScaler)) {
2403 : return false;
2404 : }
2405 0 : if (laneShowBorders != v2.laneShowBorders) {
2406 : return false;
2407 : }
2408 0 : if (showBikeMarkings != v2.showBikeMarkings) {
2409 : return false;
2410 : }
2411 0 : if (showLinkDecals != v2.showLinkDecals) {
2412 : return false;
2413 : }
2414 0 : if (realisticLinkRules != v2.realisticLinkRules) {
2415 : return false;
2416 : }
2417 0 : if (showLinkRules != v2.showLinkRules) {
2418 : return false;
2419 : }
2420 0 : if (showRails != v2.showRails) {
2421 : return false;
2422 : }
2423 0 : if (secondaryShape != v2.secondaryShape) {
2424 : return false;
2425 : }
2426 0 : if (edgeName != v2.edgeName) {
2427 : return false;
2428 : }
2429 0 : if (internalEdgeName != v2.internalEdgeName) {
2430 : return false;
2431 : }
2432 0 : if (cwaEdgeName != v2.cwaEdgeName) {
2433 : return false;
2434 : }
2435 0 : if (streetName != v2.streetName) {
2436 : return false;
2437 : }
2438 0 : if (edgeValue != v2.edgeValue) {
2439 : return false;
2440 : }
2441 0 : if (edgeScaleValue != v2.edgeScaleValue) {
2442 : return false;
2443 : }
2444 0 : if (hideConnectors != v2.hideConnectors) {
2445 : return false;
2446 : }
2447 0 : if (laneWidthExaggeration != v2.laneWidthExaggeration) {
2448 : return false;
2449 : }
2450 0 : if (laneMinSize != v2.laneMinSize) {
2451 : return false;
2452 : }
2453 0 : if (showLaneDirection != v2.showLaneDirection) {
2454 : return false;
2455 : }
2456 0 : if (showSublanes != v2.showSublanes) {
2457 : return false;
2458 : }
2459 0 : if (spreadSuperposed != v2.spreadSuperposed) {
2460 : return false;
2461 : }
2462 0 : if (disableHideByZoom != v2.disableHideByZoom) {
2463 : return false;
2464 : }
2465 0 : if (edgeParam != v2.edgeParam) {
2466 : return false;
2467 : }
2468 0 : if (laneParam != v2.laneParam) {
2469 : return false;
2470 : }
2471 0 : if (vehicleParam != v2.vehicleParam) {
2472 : return false;
2473 : }
2474 0 : if (vehicleScaleParam != v2.vehicleScaleParam) {
2475 : return false;
2476 : }
2477 0 : if (vehicleTextParam != v2.vehicleTextParam) {
2478 : return false;
2479 : }
2480 0 : if (edgeData != v2.edgeData) {
2481 : return false;
2482 : }
2483 0 : if (edgeDataID != v2.edgeDataID) {
2484 : return false;
2485 : }
2486 0 : if (edgeDataScaling != v2.edgeDataScaling) {
2487 : return false;
2488 : }
2489 0 : if (edgeValueRainBow != v2.edgeValueRainBow) {
2490 : return false;
2491 : }
2492 : if (!(vehicleColorer == v2.vehicleColorer)) {
2493 0 : return false;
2494 : }
2495 0 : if (!(vehicleScaler == v2.vehicleScaler)) {
2496 : return false;
2497 : }
2498 0 : if (vehicleQuality != v2.vehicleQuality) {
2499 : return false;
2500 : }
2501 0 : if (vehicleSize != v2.vehicleSize) {
2502 : return false;
2503 : }
2504 0 : if (vehicleValueRainBow != v2.vehicleValueRainBow) {
2505 : return false;
2506 : }
2507 0 : if (showBlinker != v2.showBlinker) {
2508 : return false;
2509 : }
2510 0 : if (drawLaneChangePreference != v2.drawLaneChangePreference) {
2511 : return false;
2512 : }
2513 0 : if (drawMinGap != v2.drawMinGap) {
2514 : return false;
2515 : }
2516 0 : if (drawBrakeGap != v2.drawBrakeGap) {
2517 : return false;
2518 : }
2519 0 : if (showBTRange != v2.showBTRange) {
2520 : return false;
2521 : }
2522 0 : if (showRouteIndex != v2.showRouteIndex) {
2523 : return false;
2524 : }
2525 0 : if (scaleLength != v2.scaleLength) {
2526 : return false;
2527 : }
2528 0 : if (drawReversed != v2.drawReversed) {
2529 : return false;
2530 : }
2531 0 : if (showParkingInfo != v2.showParkingInfo) {
2532 : return false;
2533 : }
2534 0 : if (showChargingInfo != v2.showChargingInfo) {
2535 : return false;
2536 : }
2537 0 : if (vehicleName != v2.vehicleName) {
2538 : return false;
2539 : }
2540 0 : if (vehicleValue != v2.vehicleValue) {
2541 : return false;
2542 : }
2543 0 : if (vehicleScaleValue != v2.vehicleScaleValue) {
2544 : return false;
2545 : }
2546 0 : if (vehicleText != v2.vehicleText) {
2547 : return false;
2548 : }
2549 : if (!(personColorer == v2.personColorer)) {
2550 0 : return false;
2551 : }
2552 0 : if (personQuality != v2.personQuality) {
2553 : return false;
2554 : }
2555 0 : if (personSize != v2.personSize) {
2556 : return false;
2557 : }
2558 0 : if (personName != v2.personName) {
2559 : return false;
2560 : }
2561 0 : if (personValue != v2.personValue) {
2562 : return false;
2563 : }
2564 0 : if (showPedestrianNetwork != v2.showPedestrianNetwork) {
2565 : return false;
2566 : }
2567 0 : if (pedestrianNetworkColor != v2.pedestrianNetworkColor) {
2568 : return false;
2569 : }
2570 : if (!(containerColorer == v2.containerColorer)) {
2571 0 : return false;
2572 : }
2573 0 : if (containerQuality != v2.containerQuality) {
2574 : return false;
2575 : }
2576 0 : if (containerSize != v2.containerSize) {
2577 : return false;
2578 : }
2579 0 : if (containerName != v2.containerName) {
2580 : return false;
2581 : }
2582 : if (!(junctionColorer == v2.junctionColorer)) {
2583 0 : return false;
2584 : }
2585 : if (!(poiColorer == v2.poiColorer)) {
2586 0 : return false;
2587 : }
2588 : if (!(polyColorer == v2.polyColorer)) {
2589 0 : return false;
2590 : }
2591 0 : if (drawLinkTLIndex != v2.drawLinkTLIndex) {
2592 : return false;
2593 : }
2594 0 : if (drawLinkJunctionIndex != v2.drawLinkJunctionIndex) {
2595 : return false;
2596 : }
2597 0 : if (junctionID != v2.junctionID) {
2598 : return false;
2599 : }
2600 0 : if (junctionName != v2.junctionName) {
2601 : return false;
2602 : }
2603 0 : if (internalJunctionName != v2.internalJunctionName) {
2604 : return false;
2605 : }
2606 0 : if (tlsPhaseIndex != v2.tlsPhaseIndex) {
2607 : return false;
2608 : }
2609 0 : if (tlsPhaseName != v2.tlsPhaseName) {
2610 : return false;
2611 : }
2612 :
2613 0 : if (showLane2Lane != v2.showLane2Lane) {
2614 : return false;
2615 : }
2616 :
2617 0 : if (drawJunctionShape != v2.drawJunctionShape) {
2618 : return false;
2619 : }
2620 :
2621 0 : if (drawCrossingsAndWalkingareas != v2.drawCrossingsAndWalkingareas) {
2622 : return false;
2623 : }
2624 0 : if (junctionSize != v2.junctionSize) {
2625 : return false;
2626 : }
2627 0 : if (junctionValueRainBow != v2.junctionValueRainBow) {
2628 : return false;
2629 : }
2630 :
2631 0 : if (addMode != v2.addMode) {
2632 : return false;
2633 : }
2634 0 : if (addSize != v2.addSize) {
2635 : return false;
2636 : }
2637 0 : if (addName != v2.addName) {
2638 : return false;
2639 : }
2640 0 : if (addFullName != v2.addFullName) {
2641 : return false;
2642 : }
2643 0 : if (poiSize != v2.poiSize) {
2644 : return false;
2645 : }
2646 0 : if (poiDetail != v2.poiDetail) {
2647 : return false;
2648 : }
2649 0 : if (poiName != v2.poiName) {
2650 : return false;
2651 : }
2652 0 : if (poiType != v2.poiType) {
2653 : return false;
2654 : }
2655 0 : if (poiText != v2.poiText) {
2656 : return false;
2657 : }
2658 0 : if (poiTextParam != v2.poiTextParam) {
2659 : return false;
2660 : }
2661 0 : if (poiUseCustomLayer != v2.poiUseCustomLayer) {
2662 : return false;
2663 : }
2664 0 : if (poiCustomLayer != v2.poiCustomLayer) {
2665 : return false;
2666 : }
2667 0 : if (polySize != v2.polySize) {
2668 : return false;
2669 : }
2670 0 : if (polyName != v2.polyName) {
2671 : return false;
2672 : }
2673 0 : if (polyType != v2.polyType) {
2674 : return false;
2675 : }
2676 0 : if (polyUseCustomLayer != v2.polyUseCustomLayer) {
2677 : return false;
2678 : }
2679 0 : if (polyCustomLayer != v2.polyCustomLayer) {
2680 : return false;
2681 : }
2682 :
2683 0 : if (showSizeLegend != v2.showSizeLegend) {
2684 : return false;
2685 : }
2686 0 : if (showColorLegend != v2.showColorLegend) {
2687 : return false;
2688 : }
2689 0 : if (showVehicleColorLegend != v2.showVehicleColorLegend) {
2690 : return false;
2691 : }
2692 : if (!(dataColorer == v2.dataColorer)) {
2693 0 : return false;
2694 : }
2695 0 : if (!(dataScaler == v2.dataScaler)) {
2696 : return false;
2697 : }
2698 0 : if (!(dataValue == v2.dataValue)) {
2699 : return false;
2700 : }
2701 0 : if (!(tazRelWidthExaggeration == v2.tazRelWidthExaggeration)) {
2702 : return false;
2703 : }
2704 0 : if (!(edgeRelWidthExaggeration == v2.edgeRelWidthExaggeration)) {
2705 : return false;
2706 : }
2707 0 : if (!(relDataAttr == v2.relDataAttr)) {
2708 : return false;
2709 : }
2710 0 : if (!(relDataScaleAttr == v2.relDataScaleAttr)) {
2711 : return false;
2712 : }
2713 0 : if (!(dataValueRainBow == v2.dataValueRainBow)) {
2714 : return false;
2715 : }
2716 :
2717 : return true;
2718 : }
2719 :
2720 :
2721 : const RGBColor&
2722 491505 : GUIVisualizationSettings::getLinkColor(const LinkState& ls, bool realistic) {
2723 491505 : switch (ls) {
2724 : case LINKSTATE_TL_GREEN_MAJOR:
2725 : return SUMO_color_TL_GREEN_MAJOR;
2726 13022 : case LINKSTATE_TL_GREEN_MINOR:
2727 13022 : return SUMO_color_TL_GREEN_MINOR;
2728 37952 : case LINKSTATE_TL_RED:
2729 37952 : return SUMO_color_TL_RED;
2730 26 : case LINKSTATE_TL_REDYELLOW:
2731 26 : return SUMO_color_TL_REDYELLOW;
2732 0 : case LINKSTATE_TL_YELLOW_MAJOR:
2733 0 : return SUMO_color_TL_YELLOW_MAJOR;
2734 2623 : case LINKSTATE_TL_YELLOW_MINOR:
2735 2623 : return SUMO_color_TL_YELLOW_MINOR;
2736 0 : case LINKSTATE_TL_OFF_BLINKING:
2737 0 : return SUMO_color_TL_OFF_BLINKING;
2738 18 : case LINKSTATE_TL_OFF_NOSIGNAL:
2739 18 : return SUMO_color_TL_OFF_NOSIGNAL;
2740 203072 : case LINKSTATE_MAJOR:
2741 203072 : return realistic ? RGBColor::INVISIBLE : SUMO_color_MAJOR;
2742 40516 : case LINKSTATE_MINOR:
2743 40516 : return realistic ? SUMO_color_MAJOR : SUMO_color_MINOR;
2744 465 : case LINKSTATE_EQUAL:
2745 465 : return SUMO_color_EQUAL;
2746 18 : case LINKSTATE_STOP:
2747 18 : return realistic ? SUMO_color_MAJOR : SUMO_color_STOP;
2748 0 : case LINKSTATE_ALLWAY_STOP:
2749 0 : return realistic ? SUMO_color_MAJOR : SUMO_color_ALLWAY_STOP;
2750 7785 : case LINKSTATE_ZIPPER:
2751 7785 : return realistic ? RGBColor::INVISIBLE : SUMO_color_ZIPPER;
2752 162378 : case LINKSTATE_DEADEND:
2753 162378 : return SUMO_color_DEADEND;
2754 0 : default:
2755 0 : throw ProcessError(TLF("No color defined for LinkState '%'", std::string(ls, 1)));
2756 : }
2757 : }
2758 :
2759 :
2760 : double
2761 13 : GUIVisualizationSettings::getTextAngle(double objectAngle) const {
2762 13 : double viewAngle = objectAngle - angle;
2763 26 : while (viewAngle < 0) {
2764 13 : viewAngle += 360;
2765 : }
2766 : // fmod round towards zero which is not want we want for negative numbers
2767 : viewAngle = fmod(viewAngle, 360);
2768 13 : if (viewAngle > 90 && viewAngle < 270) {
2769 : // avoid reading text on its head
2770 13 : objectAngle -= 180;
2771 : }
2772 13 : return objectAngle;
2773 : }
2774 :
2775 :
2776 : bool
2777 26 : GUIVisualizationSettings::flippedTextAngle(double objectAngle) const {
2778 26 : double viewAngle = objectAngle - angle;
2779 26 : while (viewAngle < 0) {
2780 0 : viewAngle += 360;
2781 : }
2782 : // fmod round towards zero which is not want we want for negative numbers
2783 : viewAngle = fmod(viewAngle, 360);
2784 26 : return (viewAngle > 90 && viewAngle < 270);
2785 : }
2786 :
2787 :
2788 : GUIVisualizationSettings::Detail
2789 0 : GUIVisualizationSettings::getDetailLevel(const double exaggeration) const {
2790 : // calculate factor
2791 0 : const auto factor = (scale * exaggeration);
2792 0 : if (factor >= 10) {
2793 : return GUIVisualizationSettings::Detail::Level0;
2794 0 : } else if (factor >= 5) {
2795 : return GUIVisualizationSettings::Detail::Level1;
2796 0 : } else if (factor >= 2.5) {
2797 : return GUIVisualizationSettings::Detail::Level2;
2798 0 : } else if (factor >= 1.25) {
2799 : return GUIVisualizationSettings::Detail::Level3;
2800 : } else {
2801 0 : return GUIVisualizationSettings::Detail::Level4;
2802 : }
2803 : }
2804 :
2805 :
2806 : bool
2807 103719 : GUIVisualizationSettings::drawDetail(const double detail, const double exaggeration) const {
2808 103719 : if (detail <= 0) {
2809 : return true;
2810 : } else {
2811 103719 : return ((scale * exaggeration) >= detail);
2812 : }
2813 : }
2814 :
2815 :
2816 : bool
2817 0 : GUIVisualizationSettings::drawMovingGeometryPoint(const double exaggeration, const double radius) const {
2818 0 : return (scale * radius * exaggeration > 10);
2819 : }
2820 :
2821 : /****************************************************************************/
|
