CoCalc -- GUIVisualizationSettings.cpp

GitHub Repository: eclipse/sumo
Path: blob/main/src/utils/gui/settings/GUIVisualizationSettings.cpp
¹⁶⁹⁶⁸⁴ views
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
GUIVisualizationTextSettings::GUIVisualizationTextSettings(bool _showText, double _size, RGBColor _color, RGBColor _bgColor, bool _constSize, bool _onlySelected) :
233
    showText(_showText),
234
    size(_size),
235
    color(_color),
236
    bgColor(_bgColor),
237
    constSize(_constSize),
238
    onlySelected(_onlySelected) {
239
}
240

241

242
bool
243
GUIVisualizationTextSettings::operator==(const GUIVisualizationTextSettings& other) {
244
    return (showText == other.showText) &&
245
           (size == other.size) &&
246
           (color == other.color) &&
247
           (bgColor == other.bgColor) &&
248
           (constSize == other.constSize) &&
249
           (onlySelected == other.onlySelected);
250
}
251

252

253
bool
254
GUIVisualizationTextSettings::operator!=(const GUIVisualizationTextSettings& other) {
255
    return (showText != other.showText) ||
256
           (size != other.size) ||
257
           (color != other.color) ||
258
           (bgColor != other.bgColor) ||
259
           (constSize != other.constSize) ||
260
           (onlySelected != other.onlySelected);
261
}
262

263

264
void
265
GUIVisualizationTextSettings::print(OutputDevice& dev, const std::string& name) const {
266
    dev.writeAttr(name + "_show", showText);
267
    dev.writeAttr(name + "_size", size);
268
    dev.writeAttr(name + "_color", color);
269
    dev.writeAttr(name + "_bgColor", bgColor);
270
    dev.writeAttr(name + "_constantSize", constSize);
271
    dev.writeAttr(name + "_onlySelected", onlySelected);
272
}
273

274

275
double
276
GUIVisualizationTextSettings::scaledSize(double scale, double constFactor) const {
277
    return constSize ? (size / scale) : (size * constFactor);
278
}
279

280

281
bool
282
GUIVisualizationTextSettings::show(const GUIGlObject* o) const {
283
    return showText && (!onlySelected || o == nullptr || gSelected.isSelected(o));
284
}
285

286
// ---------------------------------------------------------------------------
287
// GUIVisualizationRainbowSettings - methods
288
// ---------------------------------------------------------------------------
289

290
GUIVisualizationRainbowSettings::GUIVisualizationRainbowSettings(bool _hideMin, double _minThreshold, bool _hideMax, double _maxThreshold, bool _setNeutral,
291
        double _neutralThreshold, bool _fixRange, int _rainbowScheme) :
292
    hideMin(_hideMin),
293
    minThreshold(_minThreshold),
294
    hideMax(_hideMax),
295
    maxThreshold(_maxThreshold),
296
    setNeutral(_setNeutral),
297
    neutralThreshold(_neutralThreshold),
298
    fixRange(_fixRange),
299
    rainbowScheme(_rainbowScheme),
300
    colors(GUIVisualizationSettings::RAINBOW_SCHEMES["classic"])
301
{ }
302

303

304
bool
305
GUIVisualizationRainbowSettings::operator==(const GUIVisualizationRainbowSettings& other) {
306
    return (hideMin == other.hideMin) &&
307
           (minThreshold == other.minThreshold) &&
308
           (hideMin == other.hideMin) &&
309
           (maxThreshold == other.maxThreshold) &&
310
           (setNeutral == other.setNeutral) &&
311
           (neutralThreshold == other.neutralThreshold) &&
312
           (fixRange == other.fixRange) &&
313
           (rainbowScheme == other.rainbowScheme);
314
}
315

316

317
bool
318
GUIVisualizationRainbowSettings::operator!=(const GUIVisualizationRainbowSettings& other) {
319
    return !((*this) == other);
320
}
321

322

323
void
324
GUIVisualizationRainbowSettings::print(OutputDevice& dev, const std::string& name) const {
325
    dev.writeAttr(name + "HideCheck", hideMin);
326
    dev.writeAttr(name + "HideThreshold", minThreshold);
327
    dev.writeAttr(name + "HideCheck2", hideMax);
328
    dev.writeAttr(name + "HideThreshold2", maxThreshold);
329
    dev.writeAttr(name + "SetNeutral", setNeutral);
330
    dev.writeAttr(name + "NeutralThreshold", neutralThreshold);
331
    dev.writeAttr(name + "FixRange", fixRange);
332
    dev.writeAttr(name + "RainbowScheme", rainbowScheme);
333
}
334

335

336
// ---------------------------------------------------------------------------
337
// GUIVisualizationSizeSettings - methods
338
// ---------------------------------------------------------------------------
339

340
GUIVisualizationSizeSettings::GUIVisualizationSizeSettings(double _minSize, double _exaggeration, bool _constantSize, bool _constantSizeSelected) :
341
    minSize(_minSize),
342
    exaggeration(_exaggeration),
343
    constantSize(_constantSize),
344
    constantSizeSelected(_constantSizeSelected) {
345
}
346

347

348
double
349
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
    if (constantSize && (!constantSizeSelected || (o == nullptr) || gSelected.isSelected(o))) {
354
        exaggerationFinal = MAX2(exaggeration, exaggeration * factor / s.scale);
355
    } else if (!constantSizeSelected || (o == nullptr) || gSelected.isSelected(o)) {
356
        exaggerationFinal = exaggeration;
357
    } else {
358
        exaggerationFinal = 1;
359
    }
360
    if (o != nullptr) {
361
        exaggerationFinal *= o->getScaleVisual();
362
    }
363
    // add selectorFrameScale
364
    if ((o != nullptr) && gSelected.isSelected(o)) {
365
        return (exaggerationFinal * s.selectorFrameScale);
366
    } else {
367
        return exaggerationFinal;
368
    }
369
}
370

371

372
bool
373
GUIVisualizationSizeSettings::operator==(const GUIVisualizationSizeSettings& other) {
374
    return (constantSize == other.constantSize) &&
375
           (constantSizeSelected == other.constantSizeSelected) &&
376
           (minSize == other.minSize) &&
377
           (exaggeration == other.exaggeration);
378
}
379

380

381
bool
382
GUIVisualizationSizeSettings::operator!=(const GUIVisualizationSizeSettings& other) {
383
    return (constantSize != other.constantSize) ||
384
           (constantSizeSelected != other.constantSizeSelected) ||
385
           (minSize != other.minSize) ||
386
           (exaggeration != other.exaggeration);
387
}
388

389

390
void
391
GUIVisualizationSizeSettings::print(OutputDevice& dev, const std::string& name) const {
392
    dev.writeAttr(name + "_minSize", minSize);
393
    dev.writeAttr(name + "_exaggeration", exaggeration);
394
    dev.writeAttr(name + "_constantSize", constantSize);
395
    dev.writeAttr(name + "_constantSizeSelected", constantSizeSelected);
396
}
397

398
// ---------------------------------------------------------------------------
399
// GUIVisualizationColorSettings - methods
400
// ---------------------------------------------------------------------------
401

402
GUIVisualizationColorSettings::GUIVisualizationColorSettings() :
403
    selectionColor(0, 0, 204, 255),
404
    selectedEdgeColor(0, 0, 204, 255),
405
    selectedLaneColor(0, 0, 128, 255),
406
    selectedConnectionColor(0, 0, 100, 255),
407
    selectedProhibitionColor(0, 0, 120, 255),
408
    selectedCrossingColor(0, 100, 196, 255),
409
    selectedAdditionalColor(0, 0, 150, 255),
410
    selectedRouteColor(0, 0, 150, 255),
411
    selectedVehicleColor(0, 0, 100, 255),
412
    selectedPersonColor(0, 0, 120, 255),
413
    selectedPersonPlanColor(0, 0, 130, 255),
414
    selectedContainerColor(0, 0, 120, 255),
415
    selectedContainerPlanColor(0, 0, 130, 255),
416
    selectedEdgeDataColor(0, 0, 150, 255),
417
    busStopColor(76, 170, 50),
418
    busStopColorSign(255, 235, 0),
419
    trainStopColor(76, 170, 50),
420
    trainStopColorSign(255, 235, 0),
421
    containerStopColor(83, 89, 172),
422
    containerStopColorSign(177, 184, 186, 171),
423
    chargingStationColor(114, 210, 252),
424
    chargingStationColorSign(255, 235, 0),
425
    chargingStationColorCharge(255, 180, 0),
426
    parkingAreaColor(83, 89, 172),
427
    parkingAreaColorSign(177, 184, 186),
428
    parkingSpaceColorContour(0, 255, 0),
429
    parkingSpaceColor(255, 200, 200),
430
    stopColor(220, 20, 30),
431
    waypointColor(0, 127, 14),
432
    vehicleTripColor(255, 128, 0),
433
    stopPersonColor(255, 0, 0),
434
    personTripColor(200, 0, 255),
435
    walkColor(0, 255, 0),
436
    rideColor(0, 0, 255),
437
    stopContainerColor(255, 0, 0),
438
    transportColor(100, 200, 0),
439
    transhipColor(100, 0, 200) {
440
}
441

442

443
bool
444
GUIVisualizationColorSettings::operator==(const GUIVisualizationColorSettings& v2) {
445
    return (selectionColor == v2.selectionColor) &&
446
           (selectedEdgeColor == v2.selectedEdgeColor) &&
447
           (selectedLaneColor == v2.selectedLaneColor) &&
448
           (selectedConnectionColor == v2.selectedConnectionColor) &&
449
           (selectedProhibitionColor == v2.selectedProhibitionColor) &&
450
           (selectedCrossingColor == v2.selectedCrossingColor) &&
451
           (selectedAdditionalColor == v2.selectedAdditionalColor) &&
452
           (selectedRouteColor == v2.selectedRouteColor) &&
453
           (selectedVehicleColor == v2.selectedVehicleColor) &&
454
           (selectedPersonColor == v2.selectedPersonColor) &&
455
           (selectedContainerColor == v2.selectedContainerColor) &&
456
           (selectedPersonPlanColor == v2.selectedPersonPlanColor) &&
457
           (selectedEdgeDataColor == v2.selectedEdgeDataColor) &&
458
           (busStopColor == v2.busStopColor) &&
459
           (busStopColorSign == v2.busStopColorSign) &&
460
           (trainStopColor == v2.trainStopColor) &&
461
           (trainStopColorSign == v2.trainStopColorSign) &&
462
           (containerStopColor == v2.containerStopColor) &&
463
           (containerStopColorSign == v2.containerStopColorSign) &&
464
           (chargingStationColor == v2.chargingStationColor) &&
465
           (chargingStationColorSign == v2.chargingStationColorSign) &&
466
           (chargingStationColorCharge == v2.chargingStationColorCharge) &&
467
           (parkingAreaColor == v2.parkingAreaColor) &&
468
           (parkingAreaColorSign == v2.parkingAreaColorSign) &&
469
           (parkingSpaceColorContour == v2.parkingSpaceColorContour) &&
470
           (parkingSpaceColor == v2.parkingSpaceColor) &&
471
           (stopColor == v2.stopColor) &&
472
           (waypointColor == v2.waypointColor) &&
473
           (vehicleTripColor == v2.vehicleTripColor) &&
474
           (stopPersonColor == v2.stopPersonColor) &&
475
           (personTripColor == v2.personTripColor) &&
476
           (walkColor == v2.walkColor) &&
477
           (rideColor == v2.rideColor) &&
478
           (stopContainerColor == v2.stopContainerColor) &&
479
           (transportColor == v2.transportColor) &&
480
           (transhipColor == v2.transhipColor);
481
}
482

483

484
bool
485
GUIVisualizationColorSettings::operator!=(const GUIVisualizationColorSettings& v2) {
486
    return (selectionColor != v2.selectionColor) ||
487
           (selectedEdgeColor != v2.selectedEdgeColor) ||
488
           (selectedLaneColor != v2.selectedLaneColor) ||
489
           (selectedConnectionColor != v2.selectedConnectionColor) ||
490
           (selectedProhibitionColor != v2.selectedProhibitionColor) ||
491
           (selectedCrossingColor != v2.selectedCrossingColor) ||
492
           (selectedAdditionalColor != v2.selectedAdditionalColor) ||
493
           (selectedRouteColor != v2.selectedRouteColor) ||
494
           (selectedVehicleColor != v2.selectedVehicleColor) ||
495
           (selectedPersonColor != v2.selectedPersonColor) ||
496
           (selectedContainerColor != v2.selectedContainerColor) ||
497
           (selectedPersonPlanColor != v2.selectedPersonPlanColor) ||
498
           (selectedEdgeDataColor != v2.selectedEdgeDataColor) ||
499
           (busStopColor != v2.busStopColor) ||
500
           (busStopColorSign != v2.busStopColorSign) ||
501
           (trainStopColor != v2.trainStopColor) ||
502
           (trainStopColorSign != v2.trainStopColorSign) ||
503
           (containerStopColor != v2.containerStopColor) ||
504
           (containerStopColorSign != v2.containerStopColorSign) ||
505
           (chargingStationColor != v2.chargingStationColor) ||
506
           (chargingStationColorSign != v2.chargingStationColorSign) ||
507
           (chargingStationColorCharge != v2.chargingStationColorCharge) ||
508
           (parkingAreaColor != v2.parkingAreaColor) ||
509
           (parkingAreaColorSign != v2.parkingAreaColorSign) ||
510
           (parkingSpaceColorContour != v2.parkingSpaceColorContour) ||
511
           (parkingSpaceColor != v2.parkingSpaceColor) ||
512
           (stopColor != v2.stopColor) ||
513
           (waypointColor != v2.waypointColor) ||
514
           (vehicleTripColor != v2.vehicleTripColor) ||
515
           (stopPersonColor != v2.stopPersonColor) ||
516
           (personTripColor != v2.personTripColor) ||
517
           (walkColor != v2.walkColor) ||
518
           (rideColor != v2.rideColor) ||
519
           (stopContainerColor != v2.stopContainerColor) ||
520
           (transportColor != v2.transportColor) ||
521
           (transhipColor != v2.transhipColor);
522
}
523

524
// ---------------------------------------------------------------------------
525
// GUIVisualizationWidthSettings - methods
526
// ---------------------------------------------------------------------------
527

528
GUIVisualizationWidthSettings::GUIVisualizationWidthSettings() :
529
    tripWidth(0.2),
530
    personTripWidth(0.25),
531
    walkWidth(0.25),
532
    rideWidth(0.25),
533
    transportWidth(0.25),
534
    transhipWidth(0.25) {
535
}
536

537

538
bool
539
GUIVisualizationWidthSettings::operator==(const GUIVisualizationWidthSettings& v2) {
540
    return (tripWidth == v2.tripWidth) &&
541
           (personTripWidth == v2.personTripWidth) &&
542
           (walkWidth == v2.walkWidth) &&
543
           (rideWidth == v2.rideWidth) &&
544
           (transportWidth == v2.transportWidth) &&
545
           (transhipWidth == v2.transhipWidth);
546
}
547

548

549
bool
550
GUIVisualizationWidthSettings::operator!=(const GUIVisualizationWidthSettings& v2) {
551
    return (tripWidth != v2.tripWidth) ||
552
           (personTripWidth != v2.personTripWidth) ||
553
           (walkWidth != v2.walkWidth) ||
554
           (rideWidth != v2.rideWidth) ||
555
           (transportWidth != v2.transportWidth) ||
556
           (transhipWidth != v2.transhipWidth);
557
}
558

559
// ---------------------------------------------------------------------------
560
// GUIVisualizationWidthSettings - methods
561
// ---------------------------------------------------------------------------
562

563
GUIVisualizationSettings::GUIVisualizationSettings(const std::string& _name, bool _netedit) :
564
    name(_name),
565
    netedit(_netedit),
566
    angle(0),
567
    dither(false),
568
    fps(false),
569
    trueZ(false),
570
    backgroundColor(RGBColor::WHITE),
571
    showGrid(false), gridXSize(100), gridYSize(100),
572
    laneShowBorders(false), showBikeMarkings(true), showLinkDecals(true),
573
    realisticLinkRules(false),
574
    showLinkRules(true),
575
    showRails(true),
576
    edgeName(false, 60, RGBColor::ORANGE),
577
    internalEdgeName(false, 45, RGBColor(128, 64, 0, 255)),
578
    cwaEdgeName(false, 60, RGBColor::MAGENTA),
579
    streetName(false, 60, RGBColor::YELLOW),
580
    edgeValue(false, 100, RGBColor::CYAN),
581
    edgeScaleValue(false, 100, RGBColor::BLUE),
582
    hideConnectors(false),
583
    laneWidthExaggeration(1),
584
    laneMinSize(0),
585
    showLaneDirection(false),
586
    showSublanes(true),
587
    spreadSuperposed(false),
588
    disableHideByZoom(true),
589
    edgeParam("EDGE_KEY"),
590
    laneParam("LANE_KEY"),
591
    vehicleParam("PARAM_NUMERICAL"),
592
    vehicleScaleParam("PARAM_NUMERICAL"),
593
    vehicleTextParam("PARAM_TEXT"),
594
    edgeData("speed"),
595
    edgeDataID(""),
596
    edgeDataScaling(""),
597
    edgeValueRainBow(false, 0, false, 200, false, 0, false, 1),
598
    vehicleQuality(0), showBlinker(true),
599
    drawLaneChangePreference(false),
600
    drawMinGap(false),
601
    drawBrakeGap(false),
602
    showBTRange(false),
603
    showRouteIndex(false),
604
    scaleLength(true),
605
    drawReversed(false),
606
    showParkingInfo(false),
607
    showChargingInfo(false),
608
    vehicleSize(1),
609
    vehicleName(false, 60, RGBColor(204, 153, 0, 255)),
610
    vehicleValue(false, 80, RGBColor::CYAN),
611
    vehicleScaleValue(false, 80, RGBColor::GREY),
612
    vehicleText(false, 80, RGBColor::RED),
613
    vehicleValueRainBow(false, 0, false, 100, false, 0, false, 1),
614
    personQuality(netedit ? 2 : 0),
615
    personSize(1),
616
    personName(false, 60, RGBColor(0, 153, 204, 255)),
617
    personValue(false, 80, RGBColor::CYAN),
618
    showPedestrianNetwork(true),
619
    pedestrianNetworkColor(RGBColor(179, 217, 255)),
620
    containerQuality(0),
621
    containerSize(1),
622
    containerName(false, 60, RGBColor(0, 153, 204, 255)),
623
    drawLinkTLIndex(false, 65, RGBColor(128, 128, 255, 255), RGBColor::INVISIBLE, false),
624
    drawLinkJunctionIndex(false, 65, RGBColor(128, 128, 255, 255), RGBColor::INVISIBLE, false),
625
    junctionID(false, 60, RGBColor(0, 255, 128, 255)),
626
    junctionName(false, 60, RGBColor(192, 255, 128, 255)),
627
    internalJunctionName(false, 50, RGBColor(0, 204, 128, 255)),
628
    tlsPhaseIndex(false, 150, RGBColor::YELLOW),
629
    tlsPhaseName(false, 150, RGBColor::ORANGE),
630
    showLane2Lane(false),
631
    drawJunctionShape(true),
632
    drawCrossingsAndWalkingareas(true),
633
    junctionSize(1),
634
    junctionValueRainBow(false, 0, false, 100, false, 0, false, 1),
635
    addMode(0),
636
    addSize(1),
637
    addName(false, 60, RGBColor(255, 0, 128, 255)),
638
    addFullName(false, 60, RGBColor(255, 0, 128, 255)),
639
    poiSize(0),
640
    poiDetail(16),
641
    poiName(false, 50, RGBColor(0, 127, 70, 255)),
642
    poiType(false, 60, RGBColor(0, 127, 70, 255)),
643
    poiText(false, 80, RGBColor(140, 0, 255, 255)),
644
    poiTextParam("PARAM_TEXT"),
645
    poiUseCustomLayer(false),
646
    poiCustomLayer(0),
647
    polySize(0), polyName(false, 50, RGBColor(255, 0, 128, 255)),
648
    polyType(false, 60, RGBColor(255, 0, 128, 255)),
649
    polyUseCustomLayer(false),
650
    polyCustomLayer(0),
651
    dataValue(false, 100, RGBColor::CYAN),
652
    tazRelWidthExaggeration(1),
653
    edgeRelWidthExaggeration(1),
654
    relDataAttr("count"),
655
    dataValueRainBow(false, -100, false, 100, false, 0, false, 1),
656
    ignoreColorSchemeFor3DVehicles(false),
657
    show3DTLSLinkMarkers(true),
658
    show3DTLSDomes(true),
659
    generate3DTLSModels(false),
660
    show3DHeadUpDisplay(true),
661
    ambient3DLight(OSG_color_AMBIENT),
662
    diffuse3DLight(OSG_color_DIFFUSE),
663
    skyColor(OSG_color_SKY),
664
    showSizeLegend(true),
665
    showColorLegend(false),
666
    showVehicleColorLegend(false),
667
    gaming(false),
668
    drawBoundaries(false),
669
    selectorFrameScale(1.),
670
    drawForViewObjectsHandler(false),
671
    drawForRectangleSelection(false),
672
    forceDrawForRectangleSelection(false),
673
    disableDottedContours(false),
674
    geometryIndices(false, 50, RGBColor(255, 0, 128, 255)),
675
    secondaryShape(false),
676
    lefthand(false),
677
    disableLaneIcons(false),
678
    myIgnoreHideByZoom(false) {
679
    // init defaults depending of netedit or SUMO-GUI
680
    if (netedit) {
681
        initNeteditDefaults();
682
    } else {
683
        initSumoGuiDefaults();
684
    }
685
}
686

687

688
bool
689
GUIVisualizationSettings::checkDrawJunction(const Boundary& b, const bool selected) const {
690
    if (drawForViewObjectsHandler) {
691
        return false;
692
    } else if (junctionSize.constantSize) {
693
        return true;
694
    } else if (junctionSize.constantSizeSelected && selected) {
695
        return true;
696
    } else if (drawLinkTLIndex.showText && drawLinkTLIndex.constSize) {
697
        return true;
698
    } else if (drawLinkJunctionIndex.showText && drawLinkJunctionIndex.constSize) {
699
        return true;
700
    } else if (junctionID.showText && junctionID.constSize) {
701
        return true;
702
    } else if (junctionName.showText && junctionName.constSize) {
703
        return true;
704
    } else if (internalJunctionName.showText && internalJunctionName.constSize) {
705
        return true;
706
    } else if (tlsPhaseIndex.showText && tlsPhaseIndex.constSize) {
707
        return true;
708
    } else if (tlsPhaseName.showText && tlsPhaseName.constSize) {
709
        return true;
710
    } else {
711
        return (scale * MAX2(b.getWidth(), b.getHeight())) > BoundarySizeDrawing;
712
    }
713
}
714

715

716
bool
717
GUIVisualizationSettings::checkDrawEdge(const Boundary& b) const {
718
    if (drawForViewObjectsHandler) {
719
        // needed if we're selecting using a rectangle
720
        return true;
721
    } else if (disableHideByZoom) {
722
        return true;
723
    } else if (myIgnoreHideByZoom) {
724
        return true;
725
    } else {
726
        return (scale * MAX2(b.getWidth(), b.getHeight())) > BoundarySizeDrawing;
727
    }
728
}
729

730

731
void
732
GUIVisualizationSettings::updateIgnoreHideByZoom() {
733
    // general
734
    if (disableHideByZoom) {
735
        myIgnoreHideByZoom = true;
736
        // junctions
737
    } else if (junctionSize.constantSize && junctionSize.constantSizeSelected) {
738
        myIgnoreHideByZoom = true;
739
    } else if (drawLinkTLIndex.showText && drawLinkTLIndex.constSize) {
740
        myIgnoreHideByZoom = true;
741
    } else if (drawLinkJunctionIndex.showText && drawLinkJunctionIndex.constSize) {
742
        myIgnoreHideByZoom = true;
743
    } else if (junctionID.showText && junctionID.constSize) {
744
        myIgnoreHideByZoom = true;
745
    } else if (junctionName.showText && junctionName.constSize) {
746
        myIgnoreHideByZoom = true;
747
    } else if (internalJunctionName.showText && internalJunctionName.constSize) {
748
        myIgnoreHideByZoom = true;
749
    } else if (tlsPhaseIndex.showText && tlsPhaseIndex.constSize) {
750
        myIgnoreHideByZoom = true;
751
    } else if (tlsPhaseName.showText && tlsPhaseName.constSize) {
752
        myIgnoreHideByZoom = true;
753
        // edges
754
    } else if (edgeName.showText) {
755
        myIgnoreHideByZoom = true;
756
    } else if (internalEdgeName.showText && internalEdgeName.constSize) {
757
        myIgnoreHideByZoom = true;
758
    } else if (cwaEdgeName.showText && cwaEdgeName.constSize) {
759
        myIgnoreHideByZoom = true;
760
    } else if (streetName.showText && streetName.constSize) {
761
        myIgnoreHideByZoom = true;
762
    } else if (edgeValue.showText && edgeValue.constSize) {
763
        myIgnoreHideByZoom = true;
764
    } else if (edgeScaleValue.showText && edgeScaleValue.constSize) {
765
        myIgnoreHideByZoom = true;
766
        // additionals
767
    } else if (addSize.constantSize) {
768
        myIgnoreHideByZoom = true;
769
    } else if (addSize.constantSizeSelected) {
770
        myIgnoreHideByZoom = true;
771
    } else if (addName.showText && addName.constSize) {
772
        myIgnoreHideByZoom = true;
773
    } else if (addFullName.showText && addFullName.constSize) {
774
        myIgnoreHideByZoom = true;
775
        // POIs
776
    } else if (poiSize.constantSize) {
777
        myIgnoreHideByZoom = true;
778
    } else if (poiSize.constantSizeSelected) {
779
        myIgnoreHideByZoom = true;
780
    } else if (poiName.showText && poiName.constSize) {
781
        myIgnoreHideByZoom = true;
782
    } else if (poiType.showText && poiType.constSize) {
783
        myIgnoreHideByZoom = true;
784
    } else if (poiText.showText && poiText.constSize) {
785
        myIgnoreHideByZoom = true;
786
        // vehicles
787
    } else if (vehicleSize.constantSize) {
788
        myIgnoreHideByZoom = true;
789
    } else if (vehicleSize.constantSizeSelected) {
790
        myIgnoreHideByZoom = true;
791
    } else if (vehicleName.showText && vehicleName.constSize) {
792
        myIgnoreHideByZoom = true;
793
    } else if (vehicleValue.showText && vehicleValue.constSize) {
794
        myIgnoreHideByZoom = true;
795
    } else if (vehicleScaleValue.showText && vehicleScaleValue.constSize) {
796
        myIgnoreHideByZoom = true;
797
    } else if (vehicleText.showText && vehicleText.constSize) {
798
        myIgnoreHideByZoom = true;
799
        // persons
800
    } else if (personSize.constantSize) {
801
        myIgnoreHideByZoom = true;
802
    } else if (personSize.constantSizeSelected) {
803
        myIgnoreHideByZoom = true;
804
    } else if (personName.showText && personName.constSize) {
805
        myIgnoreHideByZoom = true;
806
    } else if (personValue.showText && personValue.constSize) {
807
        myIgnoreHideByZoom = true;
808
        // containers
809
    } else if (containerSize.constantSize) {
810
        myIgnoreHideByZoom = true;
811
    } else if (containerSize.constantSizeSelected) {
812
        myIgnoreHideByZoom = true;
813
    } else if (containerName.showText && containerName.constSize) {
814
        myIgnoreHideByZoom = true;
815
    } else {
816
        myIgnoreHideByZoom = false;
817
    }
818
}
819

820

821
bool
822
GUIVisualizationSettings::checkDrawAdditional(const Detail d, const bool selected) const {
823
    if (drawForViewObjectsHandler) {
824
        return false;
825
    } else if (myIgnoreHideByZoom) {
826
        return true;
827
    } else if (addSize.constantSize) {
828
        return true;
829
    } else if (addSize.constantSizeSelected && selected) {
830
        return true;
831
    } else if (addName.showText && addName.constSize) {
832
        return true;
833
    } else if (addFullName.showText && addFullName.constSize) {
834
        return true;
835
    } else {
836
        return d <= GUIVisualizationSettings::Detail::Additionals;
837
    }
838
}
839

840

841
bool
842
GUIVisualizationSettings::checkDrawPoly(const Boundary& b, const bool selected) const {
843
    if (drawForViewObjectsHandler) {
844
        return false;
845
    } else if (myIgnoreHideByZoom) {
846
        return true;
847
    } else if (polySize.constantSize) {
848
        return true;
849
    } else if (polySize.constantSizeSelected && selected) {
850
        return true;
851
    } else if (polyName.showText && polyName.constSize) {
852
        return true;
853
    } else if (polyType.showText && polyType.constSize) {
854
        return true;
855
    } else {
856
        return (scale * MAX2(b.getWidth(), b.getHeight())) > BoundarySizeDrawing;
857
    }
858
}
859

860

861
bool
862
GUIVisualizationSettings::checkDrawPOI(const double w, const double h, const Detail d, const bool selected) const {
863
    if (drawForViewObjectsHandler) {
864
        return false;
865
    } else if (myIgnoreHideByZoom) {
866
        return true;
867
    } else if (poiSize.constantSize) {
868
        return true;
869
    } else if (poiSize.constantSizeSelected && selected) {
870
        return true;
871
    } else if (poiName.showText && poiName.constSize) {
872
        return true;
873
    } else if (poiType.showText && poiType.constSize) {
874
        return true;
875
    } else if (poiText.showText && poiText.constSize) {
876
        return true;
877
    } else if ((w > 0) && (h > 0)) {
878
        return (scale * MAX2(w, h)) > BoundarySizeDrawing;
879
    } else {
880
        return d <= GUIVisualizationSettings::Detail::Additionals;
881
    }
882
}
883

884

885
bool
886
GUIVisualizationSettings::checkDrawVehicle(const Detail d, const bool selected) const {
887
    if (drawForViewObjectsHandler) {
888
        return false;
889
    } else if (myIgnoreHideByZoom) {
890
        return true;
891
    } else if (vehicleSize.constantSize) {
892
        return true;
893
    } else if (vehicleSize.constantSizeSelected && selected) {
894
        return true;
895
    } else if (vehicleName.showText && vehicleName.constSize) {
896
        return true;
897
    } else if (vehicleValue.showText && vehicleValue.constSize) {
898
        return true;
899
    } else if (vehicleScaleValue.showText && vehicleScaleValue.constSize) {
900
        return true;
901
    } else if (vehicleText.showText && vehicleText.constSize) {
902
        return true;
903
    } else {
904
        return d <= GUIVisualizationSettings::Detail::Additionals;
905
    }
906
}
907

908

909
bool
910
GUIVisualizationSettings::checkDrawPerson(const Detail d, const bool selected) const {
911
    if (drawForViewObjectsHandler) {
912
        return false;
913
    } else if (myIgnoreHideByZoom) {
914
        return true;
915
    } else if (personSize.constantSize) {
916
        return true;
917
    } else if (personSize.constantSizeSelected && selected) {
918
        return true;
919
    } else if (personName.showText && personName.constSize) {
920
        return true;
921
    } else if (personValue.showText && personValue.constSize) {
922
        return true;
923
    } else {
924
        return d <= GUIVisualizationSettings::Detail::Additionals;
925
    }
926
}
927

928

929
bool
930
GUIVisualizationSettings::checkDrawContainer(const Detail d, const bool selected) const {
931
    if (drawForViewObjectsHandler) {
932
        return false;
933
    } else if (myIgnoreHideByZoom) {
934
        return true;
935
    } else if (containerSize.constantSize) {
936
        return true;
937
    } else if (containerSize.constantSizeSelected && selected) {
938
        return true;
939
    } else if (containerName.showText && containerName.constSize) {
940
        return true;
941
    } else {
942
        return d <= GUIVisualizationSettings::Detail::Additionals;
943
    }
944
}
945

946

947
void
948
GUIVisualizationSettings::copy(const GUIVisualizationSettings& s) {
949
    // just copy. Note: By default = operator is disabled to avoid accidental copies)
950
    *this = s;
951
}
952

953

954
void
955
GUIVisualizationSettings::initSumoGuiDefaults() {
956
    /// add lane coloring schemes
957
    GUIColorScheme scheme = GUIColorScheme("uniform", TL("uniform"), RGBColor::BLACK, TL("road"), true, 0);
958
    scheme.addColor(RGBColor::GREY, 1, TL("sidewalk"));
959
    scheme.addColor(RGBColor(192, 66, 44), 2, TL("bike lane"));
960
    scheme.addColor(RGBColor(0, 0, 0, 0), 3, TL("green verge"));
961
    scheme.addColor(RGBColor(150, 200, 200), 4, TL("waterway"));
962
    scheme.addColor(RGBColor::BLACK, 5, TL("railway"));
963
    scheme.addColor(RGBColor(64, 0, 64), 6, TL("rails on road"));
964
    scheme.addColor(RGBColor(92, 92, 92), 7, TL("no passenger")); // paths, service roads etc
965
    scheme.addColor(RGBColor::RED, 8, TL("closed")); // road closing
966
    scheme.addColor(RGBColor::GREEN, 9, TL("connector")); // macro-connector
967
    scheme.addColor(RGBColor::ORANGE, 10, TL("forbidden")); // forbidden road
968
    scheme.addColor(RGBColor(200, 240, 240), 11, TL("airway"));
969
    laneColorer.addScheme(scheme);
970
    scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(128, 128, 128, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
971
    scheme.addColor(RGBColor(0, 80, 180, 255), 1, TL("selected"));
972
    laneColorer.addScheme(scheme);
973
    scheme = GUIColorScheme(SCHEME_NAME_PERMISSION_CODE, TL(SCHEME_NAME_PERMISSION_CODE.c_str()), RGBColor(240, 240, 240), "nobody");
974
    scheme.addColor(RGBColor(10, 10, 10), (double)SVC_PASSENGER, "passenger");
975
    scheme.addColor(RGBColor(128, 128, 128), (double)SVC_PEDESTRIAN, "pedestrian");
976
    scheme.addColor(RGBColor(80, 80, 80), (double)(SVC_PEDESTRIAN | SVC_DELIVERY), "pedestrian_delivery");
977
    scheme.addColor(RGBColor(192, 66, 44), (double)SVC_BICYCLE, "bicycle");
978
    scheme.addColor(RGBColor(40, 100, 40), (double)SVC_BUS, "bus");
979
    scheme.addColor(RGBColor(166, 147, 26), (double)SVC_TAXI, "taxi");
980
    scheme.addColor(RGBColor::BLACK, (double)(SVCAll & ~SVC_NON_ROAD), "normal_road");
981
    scheme.addColor(RGBColor::BLACK, (double)(SVCAll & ~(SVC_PEDESTRIAN | SVC_NON_ROAD)), "disallow_pedestrian");
982
    scheme.addColor(RGBColor(255, 206, 0), (double)(SVCAll & ~(SVC_PEDESTRIAN | SVC_BICYCLE | SVC_MOPED | SVC_NON_ROAD)), "motorway");
983
    scheme.addColor(RGBColor(150, 200, 200), (double)SVC_SHIP, "waterway");
984
    scheme.addColor(RGBColor::GREEN, (double)SVCAll, "all");
985
    laneColorer.addScheme(scheme);
986
    // ... traffic states ...
987
    scheme = GUIColorScheme("by allowed speed (lanewise)", TL("by allowed speed (lanewise)"), RGBColor::RED);
988
    scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
989
    scheme.addColor(RGBColor::GREEN, 55. / 3.6);
990
    scheme.addColor(RGBColor::CYAN, 80. / 3.6);
991
    scheme.addColor(RGBColor::BLUE, 120. / 3.6);
992
    scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
993
    laneColorer.addScheme(scheme);
994
    scheme = GUIColorScheme("by current occupancy (lanewise, brutto)", TL("by current occupancy (lanewise, brutto)"), RGBColor(235, 235, 235), "", false, 0, COL_SCHEME_DYNAMIC);
995
    scheme.addColor(RGBColor::GREEN, 0.25);
996
    scheme.addColor(RGBColor::YELLOW, 0.5);
997
    scheme.addColor(RGBColor::ORANGE, 0.75);
998
    scheme.addColor(RGBColor::RED, 1.0);
999
    laneColorer.addScheme(scheme);
1000
    scheme = GUIColorScheme("by current occupancy (lanewise, netto)", TL("by current occupancy (lanewise, netto)"), RGBColor(235, 235, 235), "", false, 0, COL_SCHEME_DYNAMIC);
1001
    scheme.addColor(RGBColor::GREEN, 0.25);
1002
    scheme.addColor(RGBColor::YELLOW, 0.5);
1003
    scheme.addColor(RGBColor::ORANGE, 0.75);
1004
    scheme.addColor(RGBColor::RED, 1.0);
1005
    laneColorer.addScheme(scheme);
1006
    scheme = GUIColorScheme("by first vehicle waiting time (lanewise)", TL("by first vehicle waiting time (lanewise)"), RGBColor(235, 235, 235), "", false, 0, COL_SCHEME_DYNAMIC);
1007
    scheme.addColor(RGBColor::CYAN, 30.);
1008
    scheme.addColor(RGBColor::GREEN, 100.);
1009
    scheme.addColor(RGBColor::YELLOW, 200.);
1010
    scheme.addColor(RGBColor::RED, 300.);
1011
    laneColorer.addScheme(scheme);
1012
    scheme = GUIColorScheme("by lane number (streetwise)", TL("by lane number (streetwise)"), RGBColor::RED);
1013
    scheme.addColor(RGBColor::BLUE, 5.);
1014
    laneColorer.addScheme(scheme);
1015
    // ... emissions ...
1016
    scheme = GUIColorScheme("by CO2 emissions", TL("by CO2 emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1017
    scheme.addColor(RGBColor::CYAN, 450);
1018
    scheme.addColor(RGBColor::GREEN, 900);
1019
    scheme.addColor(RGBColor::YELLOW, 1350);
1020
    scheme.addColor(RGBColor::ORANGE, 1800);
1021
    scheme.addColor(RGBColor::RED, 2250);
1022
    scheme.addColor(RGBColor::MAGENTA, 3000);
1023
    laneColorer.addScheme(scheme);
1024
    scheme = GUIColorScheme("by CO emissions", TL("by CO emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1025
    scheme.addColor(RGBColor::CYAN, 30);
1026
    scheme.addColor(RGBColor::GREEN, 60);
1027
    scheme.addColor(RGBColor::YELLOW, 90);
1028
    scheme.addColor(RGBColor::ORANGE, 120);
1029
    scheme.addColor(RGBColor::RED, 150);
1030
    scheme.addColor(RGBColor::MAGENTA, 200);
1031
    laneColorer.addScheme(scheme);
1032
    scheme = GUIColorScheme("by PMx emissions", TL("by PMx emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1033
    scheme.addColor(RGBColor::CYAN, 0.3);
1034
    scheme.addColor(RGBColor::GREEN, 0.5);
1035
    scheme.addColor(RGBColor::YELLOW, 0.8);
1036
    scheme.addColor(RGBColor::ORANGE, 1);
1037
    scheme.addColor(RGBColor::RED, 1.3);
1038
    scheme.addColor(RGBColor::MAGENTA, 1.6);
1039
    laneColorer.addScheme(scheme);
1040
    scheme = GUIColorScheme("by NOx emissions", TL("by NOx emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1041
    scheme.addColor(RGBColor::CYAN, 6);
1042
    scheme.addColor(RGBColor::GREEN, 12);
1043
    scheme.addColor(RGBColor::YELLOW, 18);
1044
    scheme.addColor(RGBColor::ORANGE, 24);
1045
    scheme.addColor(RGBColor::RED, 30);
1046
    scheme.addColor(RGBColor::MAGENTA, 40);
1047
    laneColorer.addScheme(scheme);
1048
    scheme = GUIColorScheme("by HC emissions", TL("by HC emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1049
    scheme.addColor(RGBColor::CYAN, 8);
1050
    scheme.addColor(RGBColor::GREEN, 16);
1051
    scheme.addColor(RGBColor::YELLOW, 24);
1052
    scheme.addColor(RGBColor::ORANGE, 32);
1053
    scheme.addColor(RGBColor::RED, 40);
1054
    scheme.addColor(RGBColor::MAGENTA, 50);
1055
    laneColorer.addScheme(scheme);
1056
    scheme = GUIColorScheme("by fuel consumption", TL("by fuel consumption"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1057
    scheme.addColor(RGBColor::CYAN, 0.2);
1058
    scheme.addColor(RGBColor::GREEN, 0.4);
1059
    scheme.addColor(RGBColor::YELLOW, 0.6);
1060
    scheme.addColor(RGBColor::ORANGE, 0.8);
1061
    scheme.addColor(RGBColor::RED, 1);
1062
    scheme.addColor(RGBColor::MAGENTA, 1.3);
1063
    laneColorer.addScheme(scheme);
1064
    scheme = GUIColorScheme("by noise emissions (Harmonoise)", TL("by noise emissions (Harmonoise)"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1065
    scheme.addColor(RGBColor::CYAN, 1.3);
1066
    scheme.addColor(RGBColor::GREEN, 1.4);
1067
    scheme.addColor(RGBColor::YELLOW, 1.6);
1068
    scheme.addColor(RGBColor::ORANGE, 1.7);
1069
    scheme.addColor(RGBColor::RED, 1.9);
1070
    scheme.addColor(RGBColor::MAGENTA, 2.4);
1071
    laneColorer.addScheme(scheme);
1072
    // ... weights (experimental) ...
1073
    scheme = GUIColorScheme("by global travel time", TL("by global travel time"), RGBColor::GREEN);
1074
    scheme.addColor(RGBColor::RED, 100.);
1075
    scheme.setAllowsNegativeValues(true);
1076
    laneColorer.addScheme(scheme);
1077
    scheme = GUIColorScheme("by global speed percentage", TL("by global speed percentage"), RGBColor::RED);
1078
    scheme.addColor(RGBColor::YELLOW, 50.);
1079
    scheme.addColor(RGBColor::GREEN, 100.);
1080
    scheme.setAllowsNegativeValues(true);
1081
    laneColorer.addScheme(scheme);
1082
    scheme = GUIColorScheme("by given length/geometrical length", TL("by given length/geometrical length"), RGBColor::RED);
1083
    scheme.addColor(RGBColor::ORANGE, 0.25);
1084
    scheme.addColor(RGBColor::YELLOW, 0.5);
1085
    scheme.addColor(RGBColor(179, 179, 179, 255), 1.);
1086
    scheme.addColor(RGBColor::GREEN, 2.);
1087
    scheme.addColor(RGBColor::CYAN, 4.);
1088
    scheme.addColor(RGBColor::BLUE, 100.);
1089
    laneColorer.addScheme(scheme);
1090
    laneColorer.addScheme(GUIColorScheme("by angle", TL("by angle"), RGBColor::YELLOW, "", true));
1091
    scheme = GUIColorScheme("by loaded weight", TL("by loaded weight"), RGBColor::GREEN);
1092
    scheme.addColor(RGBColor::RED, 100.);
1093
    scheme.setAllowsNegativeValues(true);
1094
    laneColorer.addScheme(scheme);
1095
    scheme = GUIColorScheme("by priority", TL("by priority"), RGBColor::YELLOW);
1096
    scheme.addColor(RGBColor::RED, -20.);
1097
    scheme.addColor(RGBColor::GREEN, 20.);
1098
    scheme.setAllowsNegativeValues(true);
1099
    laneColorer.addScheme(scheme);
1100
    scheme = GUIColorScheme("by height at start", TL("by height at start"), RGBColor::GREY);
1101
    scheme.addColor(RGBColor::BLUE, -10.);
1102
    scheme.addColor(RGBColor::RED, 10.);
1103
    scheme.addColor(RGBColor::YELLOW, 50.);
1104
    scheme.addColor(RGBColor::GREEN, 100.);
1105
    scheme.addColor(RGBColor::MAGENTA, 200.);
1106
    scheme.setAllowsNegativeValues(true);
1107
    laneColorer.addScheme(scheme);
1108
    scheme = GUIColorScheme("by height at geometry-segment start", TL("by height at geometry-segment start"), RGBColor::GREY);
1109
    scheme.addColor(RGBColor::BLUE, -10.);
1110
    scheme.addColor(RGBColor::RED, 10.);
1111
    scheme.addColor(RGBColor::YELLOW, 50.);
1112
    scheme.addColor(RGBColor::GREEN, 100.);
1113
    scheme.addColor(RGBColor::MAGENTA, 200.);
1114
    scheme.setAllowsNegativeValues(true);
1115
    laneColorer.addScheme(scheme);
1116
    scheme = GUIColorScheme("by inclination", TL("by inclination"), RGBColor::GREY);
1117
    scheme.addColor(RGBColor::YELLOW, 0.1);
1118
    scheme.addColor(RGBColor::RED, 0.3);
1119
    scheme.addColor(RGBColor::GREEN, -0.1);
1120
    scheme.addColor(RGBColor::BLUE, -0.3);
1121
    scheme.setAllowsNegativeValues(true);
1122
    laneColorer.addScheme(scheme);
1123
    scheme = GUIColorScheme("by geometry-segment inclination", TL("by geometry-segment inclination"), RGBColor::GREY);
1124
    scheme.addColor(RGBColor::YELLOW, 0.1);
1125
    scheme.addColor(RGBColor::RED, 0.3);
1126
    scheme.addColor(RGBColor::GREEN, -0.1);
1127
    scheme.addColor(RGBColor::BLUE, -0.3);
1128
    scheme.setAllowsNegativeValues(true);
1129
    laneColorer.addScheme(scheme);
1130
    scheme = GUIColorScheme("by average speed", TL("by average speed"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1131
    scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1132
    scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1133
    scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1134
    scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1135
    scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1136
    laneColorer.addScheme(scheme);
1137
    scheme = GUIColorScheme("by average relative speed ", TL("by average relative speed "), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1138
    scheme.addColor(RGBColor::YELLOW, 0.25);
1139
    scheme.addColor(RGBColor::GREEN, 0.5);
1140
    scheme.addColor(RGBColor::CYAN, 0.75);
1141
    scheme.addColor(RGBColor::BLUE, 1.);
1142
    scheme.addColor(RGBColor::MAGENTA, 1.25);
1143
    laneColorer.addScheme(scheme);
1144
    scheme = GUIColorScheme("by routing device assumed speed ", TL("by routing device assumed speed "), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1145
    scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1146
    scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1147
    scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1148
    scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1149
    scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1150
    laneColorer.addScheme(scheme);
1151
    scheme = GUIColorScheme("by electricity consumption", TL("by electricity consumption"), RGBColor::GREEN, "", false, 0, COL_SCHEME_EMISSION);
1152
    scheme.addColor(RGBColor::CYAN, 0.2);
1153
    scheme.addColor(RGBColor::GREEN, 0.4);
1154
    scheme.addColor(RGBColor::YELLOW, 0.6);
1155
    scheme.addColor(RGBColor::ORANGE, 0.8);
1156
    scheme.addColor(RGBColor::RED, 1.0);
1157
    scheme.addColor(RGBColor::MAGENTA, 2.0);
1158
    laneColorer.addScheme(scheme);
1159
    scheme = GUIColorScheme("by insertion-backlog (streetwise)", TL("by insertion-backlog (streetwise)"), RGBColor(204, 204, 204), "", false, 0, COL_SCHEME_DYNAMIC);
1160
    scheme.addColor(RGBColor::GREEN, 1.);
1161
    scheme.addColor(RGBColor::YELLOW, 10.);
1162
    scheme.addColor(RGBColor::RED, 100.);
1163
    laneColorer.addScheme(scheme);
1164
    scheme = GUIColorScheme("by TAZ (streetwise)", TL("by TAZ (streetwise)"), RGBColor(204, 204, 204), "no TAZ", true);
1165
    laneColorer.addScheme(scheme);
1166
    scheme = GUIColorScheme(SCHEME_NAME_EDGE_PARAM_NUMERICAL, TL(SCHEME_NAME_EDGE_PARAM_NUMERICAL.c_str()), RGBColor(204, 204, 204));
1167
    scheme.setAllowsNegativeValues(true);
1168
    laneColorer.addScheme(scheme);
1169
    scheme = GUIColorScheme(SCHEME_NAME_LANE_PARAM_NUMERICAL, TL(SCHEME_NAME_LANE_PARAM_NUMERICAL.c_str()), RGBColor(204, 204, 204));
1170
    scheme.setAllowsNegativeValues(true);
1171
    laneColorer.addScheme(scheme);
1172
    scheme = GUIColorScheme(SCHEME_NAME_EDGEDATA_NUMERICAL, TL(SCHEME_NAME_EDGEDATA_NUMERICAL.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA);
1173
    scheme.setAllowsNegativeValues(true);
1174
    laneColorer.addScheme(scheme);
1175
    scheme = GUIColorScheme("by distance (kilometrage)", TL("by distance (kilometrage)"), RGBColor(204, 204, 204));
1176
    scheme.addColor(RGBColor(255, 204, 204), 1.);
1177
    scheme.addColor(RGBColor::RED, 10000.);
1178
    scheme.addColor(RGBColor(204, 204, 255), -1.);
1179
    scheme.addColor(RGBColor::BLUE, -10000.);
1180
    scheme.setAllowsNegativeValues(true);
1181
    laneColorer.addScheme(scheme);
1182
    scheme = GUIColorScheme("by abs distance (kilometrage)", TL("by abs distance (kilometrage)"), RGBColor(204, 204, 204));
1183
    scheme.addColor(RGBColor::RED, 1.);
1184
    scheme.setAllowsNegativeValues(false);
1185
    laneColorer.addScheme(scheme);
1186
    scheme = GUIColorScheme("by reachability (traveltime)", TL("by reachability (traveltime)"), RGBColor::RED);
1187
    scheme.addColor(RGBColor::GREY, INVALID_DOUBLE, "unreachable");
1188
    scheme.setAllowsNegativeValues(true);
1189
    laneColorer.addScheme(scheme);
1190
    scheme = GUIColorScheme("by thread index", TL("by thread index"), RGBColor(204, 204, 204));
1191
    scheme.addColor(RGBColor::RED, 1.);
1192
    laneColorer.addScheme(scheme);
1193
    scheme = GUIColorScheme("free parking spaces", TL("free parking spaces"), RGBColor(204, 204, 204), "", false, 0, COL_SCHEME_DYNAMIC);
1194
    scheme.addColor(RGBColor::RED, 1.);
1195
    scheme.addColor(RGBColor::YELLOW, 10.);
1196
    scheme.addColor(RGBColor::GREEN, 100.);
1197
    scheme.addColor(RGBColor::BLUE, 1000.);
1198
    laneColorer.addScheme(scheme);
1199
    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);
1200
    scheme.setAllowsNegativeValues(true);
1201
    laneColorer.addScheme(scheme);
1202

1203
    /// add vehicle coloring schemes
1204
    vehicleColorer.addScheme(GUIColorScheme("given vehicle/type/route color", TL("given vehicle/type/route color"), RGBColor::YELLOW, "", true));
1205
    vehicleColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::YELLOW, "", true));
1206
    vehicleColorer.addScheme(GUIColorScheme("given/assigned vehicle color", TL("given/assigned vehicle color"), RGBColor::YELLOW, "", true));
1207
    vehicleColorer.addScheme(GUIColorScheme("given/assigned type color", TL("given/assigned type color"), RGBColor::YELLOW, "", true));
1208
    vehicleColorer.addScheme(GUIColorScheme("given/assigned route color", TL("given/assigned route color"), RGBColor::YELLOW, "", true));
1209
    vehicleColorer.addScheme(GUIColorScheme("depart position as HSV", TL("depart position as HSV"), RGBColor::YELLOW, "", true));
1210
    vehicleColorer.addScheme(GUIColorScheme("arrival position as HSV", TL("arrival position as HSV"), RGBColor::YELLOW, "", true));
1211
    vehicleColorer.addScheme(GUIColorScheme("direction/distance as HSV", TL("direction/distance as HSV"), RGBColor::YELLOW, "", true));
1212
    scheme = GUIColorScheme("by speed", TL("by speed"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1213
    scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1214
    scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1215
    scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1216
    scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1217
    scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1218
    scheme.setAllowsNegativeValues(true); // negative speed indicates stopped
1219
    scheme.addColor(RGBColor::RED, -1); // stopped on road
1220
    scheme.addColor(RGBColor::GREY, -2); // stopped off-road (parking)
1221
    vehicleColorer.addScheme(scheme);
1222
    scheme = GUIColorScheme("by action step", TL("by action step"), RGBColor::GREY, TL("no action"), true, 0, COL_SCHEME_DYNAMIC);
1223
    scheme.addColor(RGBColor(0, 255, 0, 255), 1., TL("action in next step"));
1224
    scheme.addColor(RGBColor(80, 160, 80, 255), 2., TL("had action step"));
1225
    vehicleColorer.addScheme(scheme);
1226
    scheme = GUIColorScheme("by waiting time", TL("by waiting time"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1227
    scheme.addColor(RGBColor::CYAN, 30.);
1228
    scheme.addColor(RGBColor::GREEN, 100.);
1229
    scheme.addColor(RGBColor::YELLOW, 200.);
1230
    scheme.addColor(RGBColor::RED, 300.);
1231
    vehicleColorer.addScheme(scheme);
1232
    scheme = GUIColorScheme("by accumulated waiting time", TL("by accumulated waiting time"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1233
    scheme.addColor(RGBColor::CYAN, 25.);
1234
    scheme.addColor(RGBColor::GREEN, 50.);
1235
    scheme.addColor(RGBColor::YELLOW, 75.);
1236
    scheme.addColor(RGBColor::RED, 100.);
1237
    vehicleColorer.addScheme(scheme);
1238
    scheme = GUIColorScheme("by time since lane change", TL("by time since lane change"), RGBColor(179, 179, 179, 255), "0", false, 0, COL_SCHEME_DYNAMIC);
1239
    scheme.addColor(RGBColor(189, 189, 179, 255), -180);
1240
    scheme.addColor(RGBColor(255, 255, 0, 255), -20);
1241
    scheme.addColor(RGBColor(255,   0, 0, 255), -0.01);
1242
    scheme.addColor(RGBColor(0,   0, 255, 255),  0.01);
1243
    scheme.addColor(RGBColor(0, 255, 255, 255),  20);
1244
    scheme.addColor(RGBColor(179, 189, 189, 255),  180);
1245
    scheme.setAllowsNegativeValues(true);
1246
    vehicleColorer.addScheme(scheme);
1247
    scheme = GUIColorScheme("by max speed", TL("by max speed"), RGBColor::RED);
1248
    scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1249
    scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1250
    scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1251
    scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1252
    scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1253
    vehicleColorer.addScheme(scheme);
1254
    // ... emissions ...
1255
    scheme = GUIColorScheme("by CO2 emissions", TL("by CO2 emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1256
    scheme.addColor(RGBColor::CYAN, 23000);
1257
    scheme.addColor(RGBColor::GREEN, 46000);
1258
    scheme.addColor(RGBColor::YELLOW, 69000);
1259
    scheme.addColor(RGBColor::ORANGE, 92000);
1260
    scheme.addColor(RGBColor::RED, 115000);
1261
    scheme.addColor(RGBColor::MAGENTA, 150000);
1262
    vehicleColorer.addScheme(scheme);
1263
    scheme = GUIColorScheme("by CO emissions", TL("by CO emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1264
    scheme.addColor(RGBColor::CYAN, 1500);
1265
    scheme.addColor(RGBColor::GREEN, 3000);
1266
    scheme.addColor(RGBColor::YELLOW, 4500);
1267
    scheme.addColor(RGBColor::ORANGE, 6000);
1268
    scheme.addColor(RGBColor::RED, 7500);
1269
    scheme.addColor(RGBColor::MAGENTA, 10000);
1270
    vehicleColorer.addScheme(scheme);
1271
    scheme = GUIColorScheme("by PMx emissions", TL("by PMx emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1272
    scheme.addColor(RGBColor::CYAN, 12);
1273
    scheme.addColor(RGBColor::GREEN, 24);
1274
    scheme.addColor(RGBColor::YELLOW, 36);
1275
    scheme.addColor(RGBColor::ORANGE, 48);
1276
    scheme.addColor(RGBColor::RED, 60);
1277
    scheme.addColor(RGBColor::MAGENTA, 80);
1278
    vehicleColorer.addScheme(scheme);
1279
    scheme = GUIColorScheme("by NOx emissions", TL("by NOx emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1280
    scheme.addColor(RGBColor::CYAN, 300);
1281
    scheme.addColor(RGBColor::GREEN, 600);
1282
    scheme.addColor(RGBColor::YELLOW, 900);
1283
    scheme.addColor(RGBColor::ORANGE, 1200);
1284
    scheme.addColor(RGBColor::RED, 1500);
1285
    scheme.addColor(RGBColor::MAGENTA, 2000);
1286
    vehicleColorer.addScheme(scheme);
1287
    scheme = GUIColorScheme("by HC emissions", TL("by HC emissions"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1288
    scheme.addColor(RGBColor::CYAN, 400);
1289
    scheme.addColor(RGBColor::GREEN, 800);
1290
    scheme.addColor(RGBColor::YELLOW, 1200);
1291
    scheme.addColor(RGBColor::ORANGE, 1600);
1292
    scheme.addColor(RGBColor::RED, 2000);
1293
    scheme.addColor(RGBColor::MAGENTA, 2500);
1294
    vehicleColorer.addScheme(scheme);
1295
    scheme = GUIColorScheme("by fuel consumption", TL("by fuel consumption"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1296
    scheme.addColor(RGBColor::CYAN, 10);
1297
    scheme.addColor(RGBColor::GREEN, 20);
1298
    scheme.addColor(RGBColor::YELLOW, 30);
1299
    scheme.addColor(RGBColor::ORANGE, 40);
1300
    scheme.addColor(RGBColor::RED, 50);
1301
    scheme.addColor(RGBColor::MAGENTA, 60);
1302
    vehicleColorer.addScheme(scheme);
1303
    scheme = GUIColorScheme("by noise emissions (Harmonoise)", RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1304
    scheme.addColor(RGBColor::CYAN, 60);
1305
    scheme.addColor(RGBColor::GREEN, 70);
1306
    scheme.addColor(RGBColor::YELLOW, 80);
1307
    scheme.addColor(RGBColor::ORANGE, 90);
1308
    scheme.addColor(RGBColor::RED, 100);
1309
    scheme.addColor(RGBColor::MAGENTA, 120);
1310
    vehicleColorer.addScheme(scheme);
1311
    scheme = GUIColorScheme("by reroute number", TL("by reroute number"), RGBColor::GREY, "", false, 0, COL_SCHEME_DYNAMIC);
1312
    scheme.addColor(RGBColor::YELLOW, 1.);
1313
    scheme.addColor(RGBColor::RED, 10.);
1314
    vehicleColorer.addScheme(scheme);
1315
    scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(179, 179, 179, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1316
    scheme.addColor(RGBColor(0, 102, 204, 255), 1, TL("selected"));
1317
    vehicleColorer.addScheme(scheme);
1318
    scheme = GUIColorScheme("by offset from best lane", TL("by offset from best lane"), RGBColor(179, 179, 179, 255), "0", false, 0, COL_SCHEME_DYNAMIC);
1319
    scheme.addColor(RGBColor(255, 0, 255, 255), -100, TL("opposite lane"));
1320
    scheme.addColor(RGBColor(255,   0, 0, 255), -3, "-3");
1321
    scheme.addColor(RGBColor(255, 255, 0, 255), -1, "-1");
1322
    scheme.addColor(RGBColor(0, 255, 255, 255),  1,  "1");
1323
    scheme.addColor(RGBColor(0,   0, 255, 255),  3,  "3");
1324
    scheme.setAllowsNegativeValues(true);
1325
    vehicleColorer.addScheme(scheme);
1326
    scheme = GUIColorScheme("by acceleration", TL("by acceleration"), RGBColor(179, 179, 179, 255), "0", false, 0, COL_SCHEME_DYNAMIC);
1327
    scheme.addColor(RGBColor(64,    0, 0, 255), -9.0);
1328
    scheme.addColor(RGBColor(255,   0, 0, 255), -4.5 /* -SUMOVTypeParameter::getDefaultDecel() */);
1329
    scheme.addColor(RGBColor(255, 255, 0, 255), -0.1);
1330
    scheme.addColor(RGBColor(0, 255, 255, 255),  0.1);
1331
    scheme.addColor(RGBColor(0,   0, 255, 255),  2.6 /* SUMOVTypeParameter::getDefaultAccel() */);
1332
    scheme.addColor(RGBColor(255, 0, 255, 255),  5.2);
1333
    scheme.setAllowsNegativeValues(true);
1334
    vehicleColorer.addScheme(scheme);
1335
    scheme = GUIColorScheme("by time gap on lane", TL("by time gap on lane"), RGBColor(255, 255, 0, 255), "0", false, 0, COL_SCHEME_DYNAMIC);
1336
    scheme.addColor(RGBColor(179, 179, 179, 255), -1);
1337
    scheme.addColor(RGBColor(0, 255, 255, 255), 1);
1338
    scheme.addColor(RGBColor(0,   0, 255, 255), 2);
1339
    scheme.setAllowsNegativeValues(true);
1340
    vehicleColorer.addScheme(scheme);
1341
    scheme = GUIColorScheme("by depart delay", TL("by depart delay"), RGBColor::BLUE);
1342
    scheme.addColor(RGBColor::CYAN, 30.);
1343
    scheme.addColor(RGBColor::GREEN, 100.);
1344
    scheme.addColor(RGBColor::YELLOW, 200.);
1345
    scheme.addColor(RGBColor::RED, 300.);
1346
    vehicleColorer.addScheme(scheme);
1347
    scheme = GUIColorScheme("by electricity consumption", TL("by electricity consumption"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1348
    scheme.addColor(RGBColor::CYAN, 10);
1349
    scheme.addColor(RGBColor::GREEN, 20);
1350
    scheme.addColor(RGBColor::YELLOW, 30);
1351
    scheme.addColor(RGBColor::ORANGE, 40);
1352
    scheme.addColor(RGBColor::RED, 60);
1353
    scheme.addColor(RGBColor::MAGENTA, 100);
1354
    vehicleColorer.addScheme(scheme);
1355
    scheme = GUIColorScheme("by relative battery charge", TL("by relative battery charge"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1356
    scheme.setAllowsNegativeValues(true);
1357
    scheme.addColor(RGBColor::MAGENTA, 0.1);
1358
    scheme.addColor(RGBColor::RED, 0.2);
1359
    scheme.addColor(RGBColor::ORANGE, 0.3);
1360
    scheme.addColor(RGBColor::YELLOW, 0.4);
1361
    scheme.addColor(RGBColor::GREEN, 0.6);
1362
    scheme.addColor(RGBColor::CYAN, 1.);
1363
    vehicleColorer.addScheme(scheme);
1364
    scheme = GUIColorScheme("by charged energy", TL("by charged energy"), RGBColor::GREY, "", false, 0, COL_SCHEME_EMISSION);
1365
    scheme.setAllowsNegativeValues(true);
1366
    scheme.addColor(RGBColor::MAGENTA, 10);
1367
    scheme.addColor(RGBColor::RED, 20);
1368
    scheme.addColor(RGBColor::ORANGE, 30);
1369
    scheme.addColor(RGBColor::YELLOW, 100);
1370
    scheme.addColor(RGBColor::GREEN, 200);
1371
    scheme.addColor(RGBColor::CYAN, 500);
1372
    vehicleColorer.addScheme(scheme);
1373
    scheme = GUIColorScheme("by time loss", TL("by time loss"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1374
    scheme.addColor(RGBColor::CYAN, 10.);
1375
    scheme.addColor(RGBColor::GREEN, 60.);
1376
    scheme.addColor(RGBColor::YELLOW, 180.);
1377
    scheme.addColor(RGBColor::RED, 900.);
1378
    vehicleColorer.addScheme(scheme);
1379
    scheme = GUIColorScheme("by stop delay", TL("by stop delay"), RGBColor::GREY, "", false, -1, COL_SCHEME_DYNAMIC);
1380
    scheme.addColor(RGBColor::BLUE, 0.);
1381
    scheme.addColor(RGBColor::CYAN, 10.);
1382
    scheme.addColor(RGBColor::GREEN, 60.);
1383
    scheme.addColor(RGBColor::YELLOW, 120.);
1384
    scheme.addColor(RGBColor::ORANGE, 300.);
1385
    scheme.addColor(RGBColor::RED, 900.);
1386
    scheme.setAllowsNegativeValues(true);
1387
    vehicleColorer.addScheme(scheme);
1388
    scheme = GUIColorScheme("by stop arrival delay", TL("by stop arrival delay"), RGBColor::GREY, "", false, INVALID_DOUBLE, COL_SCHEME_DYNAMIC);
1389
    scheme.addColor(RGBColor::MAGENTA, -10.);
1390
    scheme.addColor(RGBColor::BLUE, 0.);
1391
    scheme.addColor(RGBColor::CYAN, 10.);
1392
    scheme.addColor(RGBColor::GREEN, 60.);
1393
    scheme.addColor(RGBColor::YELLOW, 120.);
1394
    scheme.addColor(RGBColor::ORANGE, 300.);
1395
    scheme.addColor(RGBColor::RED, 900.);
1396
    scheme.setAllowsNegativeValues(true);
1397
    vehicleColorer.addScheme(scheme);
1398
    scheme = GUIColorScheme("by lateral speed", TL("by lateral speed"), RGBColor(179, 179, 179, 255), "0", false, 0, COL_SCHEME_DYNAMIC);
1399
    scheme.addColor(RGBColor(255,   0, 0, 255), -3, "-1.5");
1400
    scheme.addColor(RGBColor(255, 255, 0, 255), -1, "-0.5");
1401
    scheme.addColor(RGBColor(0, 255, 255, 255),  1,  "0.5");
1402
    scheme.addColor(RGBColor(0,   0, 255, 255),  3,  "1.5");
1403
    scheme.setAllowsNegativeValues(true);
1404
    vehicleColorer.addScheme(scheme);
1405
    scheme = GUIColorScheme(SCHEME_NAME_PARAM_NUMERICAL, TL(SCHEME_NAME_PARAM_NUMERICAL.c_str()), RGBColor(204, 204, 204));
1406
    scheme.setAllowsNegativeValues(true);
1407
    vehicleColorer.addScheme(scheme);
1408
    vehicleColorer.addScheme(GUIColorScheme("random", TL("random"), RGBColor::YELLOW, "", true));
1409
    vehicleColorer.addScheme(GUIColorScheme("by angle", TL("by angle"), RGBColor::YELLOW, "", true));
1410

1411
    /// add person coloring schemes
1412
    personColorer.addScheme(GUIColorScheme("given person/type color", TL("given person/type color"), RGBColor::BLUE, "", true));
1413
    personColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::BLUE, "", true));
1414
    personColorer.addScheme(GUIColorScheme("given/assigned person color", TL("given/assigned person color"), RGBColor::BLUE, "", true));
1415
    personColorer.addScheme(GUIColorScheme("given/assigned type color", TL("given/assigned type color"), RGBColor::BLUE, "", true));
1416
    scheme = GUIColorScheme("by speed", TL("by speed"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1417
    scheme.addColor(RGBColor::YELLOW, 2.5 / 3.6);
1418
    scheme.addColor(RGBColor::GREEN, 5. / 3.6);
1419
    scheme.addColor(RGBColor::BLUE, 10. / 3.6);
1420
    scheme.setAllowsNegativeValues(true); // negative speed indicates stopped
1421
    scheme.addColor(RGBColor::GREY, -1.); // stop stage
1422
    scheme.addColor(RGBColor::GREY, -2.); // stop stage (departure)
1423
    personColorer.addScheme(scheme);
1424
    scheme = GUIColorScheme("by mode", TL("by mode"), RGBColor::GREY, TL("waiting for insertion"), true, 0, COL_SCHEME_DYNAMIC);
1425
    scheme.addColor(RGBColor::RED, 1., TL("stopped"));
1426
    scheme.addColor(RGBColor::GREEN, 2., TL("walking"));
1427
    scheme.addColor(RGBColor::BLUE, 3., TL("riding"));
1428
    scheme.addColor(RGBColor::CYAN, 4., TL("accessing trainStop"));
1429
    scheme.addColor(RGBColor::YELLOW, 5., TL("waiting for ride"));
1430
    personColorer.addScheme(scheme);
1431
    scheme = GUIColorScheme("by waiting time", TL("by waiting time"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1432
    scheme.addColor(RGBColor::CYAN, 30.);
1433
    scheme.addColor(RGBColor::GREEN, 100.);
1434
    scheme.addColor(RGBColor::YELLOW, 200.);
1435
    scheme.addColor(RGBColor::RED, 300.);
1436
    personColorer.addScheme(scheme);
1437
    scheme = GUIColorScheme("by jammed state", TL("by jammed state"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1438
    scheme.addColor(RGBColor::RED, 1.);
1439
    personColorer.addScheme(scheme);
1440
    scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(179, 179, 179, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1441
    scheme.addColor(RGBColor(0, 102, 204, 255), 1, TL("selected"));
1442
    personColorer.addScheme(scheme);
1443
    personColorer.addScheme(GUIColorScheme("by angle", TL("by angle"), RGBColor::YELLOW, "", true));
1444
    personColorer.addScheme(GUIColorScheme("random", TL("random"), RGBColor::YELLOW, "", true));
1445

1446
    /// add container coloring schemes
1447
    containerColorer.addScheme(GUIColorScheme("given container/type color", TL("given container/type color"), RGBColor::YELLOW, "", true));
1448
    containerColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::YELLOW, "", true));
1449
    containerColorer.addScheme(GUIColorScheme("given/assigned container color", TL("given/assigned container color"), RGBColor::YELLOW, "", true));
1450
    containerColorer.addScheme(GUIColorScheme("given/assigned type color", TL("given/assigned type color"), RGBColor::YELLOW, "", true));
1451
    scheme = GUIColorScheme("by speed", TL("by speed"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1452
    scheme.addColor(RGBColor::YELLOW, 2.5 / 3.6);
1453
    scheme.addColor(RGBColor::GREEN, 5. / 3.6);
1454
    scheme.addColor(RGBColor::BLUE, 10. / 3.6);
1455
    containerColorer.addScheme(scheme);
1456
    scheme = GUIColorScheme("by mode", TL("by mode"), RGBColor::GREY, TL("waiting for insertion"), true, 0, COL_SCHEME_DYNAMIC);
1457
    scheme.addColor(RGBColor::RED, 1., TL("stopped"));
1458
    scheme.addColor(RGBColor::BLUE, 3., TL("transport"));
1459
    scheme.addColor(RGBColor::CYAN, 4., TL("accessing trainStop"));
1460
    scheme.addColor(RGBColor::YELLOW, 5., TL("waiting for transport"));
1461
    scheme.addColor(RGBColor::GREEN, 6., TL("tranship")); // (moving without vehicle)
1462
    containerColorer.addScheme(scheme);
1463
    scheme = GUIColorScheme("by waiting time", TL("by waiting time"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1464
    scheme.addColor(RGBColor::CYAN, 30.);
1465
    scheme.addColor(RGBColor::GREEN, 100.);
1466
    scheme.addColor(RGBColor::YELLOW, 200.);
1467
    scheme.addColor(RGBColor::RED, 300.);
1468
    containerColorer.addScheme(scheme);
1469
    scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(179, 179, 179, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1470
    scheme.addColor(RGBColor(0, 102, 204, 255), 1, TL("selected"));
1471
    containerColorer.addScheme(scheme);
1472
    containerColorer.addScheme(GUIColorScheme("by angle", TL("by angle"), RGBColor::YELLOW, "", true));
1473
    containerColorer.addScheme(GUIColorScheme("random", TL("random"), RGBColor::YELLOW, "", true));
1474

1475
    /// add junction coloring schemes
1476
    scheme = GUIColorScheme("uniform", TL("uniform"), RGBColor::BLACK, "", true);
1477
    scheme.addColor(RGBColor(150, 200, 200), 1, TL("waterway"));
1478
    scheme.addColor(RGBColor(0, 0, 0, 0), 2, TL("railway"));
1479
    scheme.addColor(RGBColor(200, 240, 240), 3, TL("airway"));
1480
    junctionColorer.addScheme(scheme);
1481
    scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(128, 128, 128, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1482
    scheme.addColor(RGBColor(0, 80, 180, 255), 1, TL("selected"));
1483
    junctionColorer.addScheme(scheme);
1484
    scheme = GUIColorScheme(SCHEME_NAME_TYPE, TL(SCHEME_NAME_TYPE.c_str()), RGBColor::GREEN, "traffic_light", true);
1485
    scheme.addColor(RGBColor(0, 128, 0), 1, "traffic_light_unregulated");
1486
    scheme.addColor(RGBColor::YELLOW, 2, "priority");
1487
    scheme.addColor(RGBColor::RED, 3, "priority_stop");
1488
    scheme.addColor(RGBColor::BLUE, 4, "right_before_left");
1489
    scheme.addColor(RGBColor::CYAN, 5, "allway_stop");
1490
    scheme.addColor(RGBColor::GREY, 6, "district");
1491
    scheme.addColor(RGBColor::MAGENTA, 7, "unregulated");
1492
    scheme.addColor(RGBColor::BLACK, 8, "dead_end");
1493
    scheme.addColor(RGBColor::ORANGE, 9, "rail_signal");
1494
    scheme.addColor(RGBColor(172, 108, 44), 10, "zipper"); // brown, darker than the zipper link rule
1495
    scheme.addColor(RGBColor(192, 255, 192), 11, "traffic_light_right_on_red"); // light green
1496
    scheme.addColor(RGBColor(128, 0, 128), 12, "rail_crossing"); // dark purple
1497
    scheme.addColor(RGBColor(0, 0, 128), 13, "left_before_right"); // dark blue
1498
    junctionColorer.addScheme(scheme);
1499
    scheme = GUIColorScheme("by height", TL("by height"), RGBColor::GREY);
1500
    scheme.addColor(RGBColor::BLUE, -10.);
1501
    scheme.addColor(RGBColor::RED, 10.);
1502
    scheme.addColor(RGBColor::YELLOW, 50.);
1503
    scheme.addColor(RGBColor::GREEN, 100.);
1504
    scheme.addColor(RGBColor::MAGENTA, 200.);
1505
    scheme.setAllowsNegativeValues(true);
1506
    junctionColorer.addScheme(scheme);
1507

1508
    /// add POI coloring schemes
1509
    poiColorer.addScheme(GUIColorScheme("given POI color", TL("given POI color"), RGBColor::RED, "", true));
1510
    scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(179, 179, 179, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1511
    scheme.addColor(RGBColor(0, 102, 204, 255), 1, TL("selected"));
1512
    poiColorer.addScheme(scheme);
1513
    poiColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::RED, "", true));
1514

1515
    /// add polygon coloring schemes
1516
    polyColorer.addScheme(GUIColorScheme("given polygon color", TL("given polygon color"), RGBColor::ORANGE, "", true));
1517
    scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(179, 179, 179, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1518
    scheme.addColor(RGBColor(0, 102, 204, 255), 1, TL("selected"));
1519
    polyColorer.addScheme(scheme);
1520
    polyColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::ORANGE, "", true));
1521
    polyColorer.addScheme(GUIColorScheme("random", TL("random"), RGBColor::YELLOW, "", true));
1522

1523
    /// add lane scaling schemes
1524
    {
1525
        GUIScaleScheme laneScheme = GUIScaleScheme(TL("default"), 1, TL("uniform"), true);
1526
        laneScaler.addScheme(laneScheme);
1527
        laneScheme = GUIScaleScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), 0.5, TL("unselected"), true, 0, COL_SCHEME_MISC);
1528
        laneScheme.addColor(5, 1, TL("selected"));
1529
        laneScaler.addScheme(laneScheme);
1530
        // ... traffic states ...
1531
        laneScheme = GUIScaleScheme(TL("by allowed speed (lanewise)"), 0);
1532
        laneScheme.addColor(10, 150. / 3.6);
1533
        laneScaler.addScheme(laneScheme);
1534
        laneScheme = GUIScaleScheme(TL("by current occupancy (lanewise, brutto)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1535
        laneScheme.addColor(10, 0.95);
1536
        laneScaler.addScheme(laneScheme);
1537
        laneScheme = GUIScaleScheme(TL("by current occupancy (lanewise, netto)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1538
        laneScheme.addColor(10, 0.95);
1539
        laneScaler.addScheme(laneScheme);
1540
        laneScheme = GUIScaleScheme(TL("by first vehicle waiting time (lanewise)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1541
        laneScheme.addColor(10, 300.);
1542
        laneScaler.addScheme(laneScheme);
1543
        laneScheme = GUIScaleScheme(TL("by lane number (streetwise)"), 1);
1544
        laneScheme.addColor(10, 5.);
1545
        laneScaler.addScheme(laneScheme);
1546
        // ... emissions ...
1547
        laneScheme = GUIScaleScheme(TL("by CO2 emissions"), 0, "", false, 0, COL_SCHEME_EMISSION);
1548
        laneScheme.addColor(10, 10. / 7.5 / 5.);
1549
        laneScaler.addScheme(laneScheme);
1550
        laneScheme = GUIScaleScheme(TL("by CO emissions"), 0, "", false, 0, COL_SCHEME_EMISSION);
1551
        laneScheme.addColor(10, 0.05 / 7.5 / 2.);
1552
        laneScaler.addScheme(laneScheme);
1553
        laneScheme = GUIScaleScheme(TL("by PMx emissions"), 0, "", false, 0, COL_SCHEME_EMISSION);
1554
        laneScheme.addColor(10, .005 / 7.5 / 5.);
1555
        laneScaler.addScheme(laneScheme);
1556
        laneScheme = GUIScaleScheme(TL("by NOx emissions"), 0, "", false, 0, COL_SCHEME_EMISSION);
1557
        laneScheme.addColor(10, .125 / 7.5 / 5.);
1558
        laneScaler.addScheme(laneScheme);
1559
        laneScheme = GUIScaleScheme(TL("by HC emissions"), 0, "", false, 0, COL_SCHEME_EMISSION);
1560
        laneScheme.addColor(10, .02 / 7.5 / 4.);
1561
        laneScaler.addScheme(laneScheme);
1562
        laneScheme = GUIScaleScheme(TL("by fuel consumption"), 0, "", false, 0, COL_SCHEME_EMISSION);
1563
        laneScheme.addColor(10, .005 / 7.5 * 100.);
1564
        laneScaler.addScheme(laneScheme);
1565
        laneScheme = GUIScaleScheme(TL("by noise emissions (Harmonoise)"), 0, "", false, 0, COL_SCHEME_EMISSION);
1566
        laneScheme.addColor(10, 100.);
1567
        laneScaler.addScheme(laneScheme);
1568
        // ... weights (experimental) ...
1569
        laneScheme = GUIScaleScheme(TL("by global travel time"), 0);
1570
        laneScheme.addColor(10, 100.);
1571
        laneScheme.setAllowsNegativeValues(true);
1572
        laneScaler.addScheme(laneScheme);
1573
        laneScheme = GUIScaleScheme(TL("by global speed percentage"), 0);
1574
        laneScheme.addColor(10, 100.);
1575
        laneScheme.setAllowsNegativeValues(true);
1576
        laneScaler.addScheme(laneScheme);
1577
        laneScheme = GUIScaleScheme(TL("by given length/geometrical length"), 0);
1578
        laneScheme.addColor(10, 10.);
1579
        laneScaler.addScheme(laneScheme);
1580
        laneScheme = GUIScaleScheme(TL("by loaded weight"), 0);
1581
        laneScheme.addColor(-1000, -1000.);
1582
        laneScheme.addColor(1000, 1000.);
1583
        laneScheme.setAllowsNegativeValues(true);
1584
        laneScaler.addScheme(laneScheme);
1585
        laneScheme = GUIScaleScheme(TL("by priority"), 1);
1586
        laneScheme.addColor(0.5, -20.);
1587
        laneScheme.addColor(5, 20.);
1588
        laneScheme.setAllowsNegativeValues(true);
1589
        laneScaler.addScheme(laneScheme);
1590
        laneScheme = GUIScaleScheme(TL("by average speed"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1591
        laneScheme.addColor(10, 150. / 3.6);
1592
        laneScaler.addScheme(laneScheme);
1593
        laneScheme = GUIScaleScheme(TL("by average relative speed"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1594
        laneScheme.addColor(0.5, 0.5);
1595
        laneScheme.addColor(2, 1.);
1596
        laneScheme.addColor(10, 2.);
1597
        laneScaler.addScheme(laneScheme);
1598
        laneScheme = GUIScaleScheme(TL("by electricity consumption"), 0, "", false, 0, COL_SCHEME_EMISSION);
1599
        laneScheme.addColor(10, 1. / 7.5 / 5.);
1600
        laneScaler.addScheme(laneScheme);
1601
        laneScheme = GUIScaleScheme(TL("by insertion-backlog (streetwise)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1602
        laneScheme.addColor(1, 1.);
1603
        laneScheme.addColor(10, 10.);
1604
        laneScheme.addColor(50, 100.);
1605
        laneScaler.addScheme(laneScheme);
1606
        laneScheme = GUIScaleScheme(SCHEME_NAME_EDGEDATA_NUMERICAL, TL(SCHEME_NAME_EDGEDATA_NUMERICAL.c_str()), 0.1, TL("missing data"), false, MISSING_DATA);
1607
        laneScheme.addColor(1, 1.);
1608
        laneScheme.addColor(2, 10.);
1609
        laneScheme.addColor(5, 100.);
1610
        laneScheme.addColor(10, 1000.);
1611
        laneScheme.setAllowsNegativeValues(true);
1612
        laneScaler.addScheme(laneScheme);
1613
    }
1614

1615
    /// add edge coloring schemes
1616
    edgeColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor(0, 0, 0, 0), "", true));
1617
    scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(128, 128, 128, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1618
    scheme.addColor(RGBColor(0, 80, 180, 255), 1., TL("selected"));
1619
    edgeColorer.addScheme(scheme);
1620
    scheme = GUIColorScheme("by purpose (streetwise)", TL("by purpose (streetwise)"), RGBColor(), TL("normal"), true);
1621
    scheme.addColor(RGBColor(128, 0, 128, 255), 1., TL("connector")); // see MSEdge::EdgeBasicFunction::EDGEFUNCTION_CONNECTOR
1622
    scheme.addColor(RGBColor::BLUE, 2., TL("internal")); // see MSEdge::EdgeBasicFunction::EDGEFUNCTION_INTERNAL
1623
    edgeColorer.addScheme(scheme);
1624
    scheme = GUIColorScheme("by allowed speed (streetwise)", TL("by allowed speed (streetwise)"), RGBColor::RED);
1625
    scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1626
    scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1627
    scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1628
    scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1629
    scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1630
    edgeColorer.addScheme(scheme);
1631
    scheme = GUIColorScheme("by current occupancy (streetwise, brutto)", TL("by current occupancy (streetwise, brutto)"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1632
    scheme.addColor(RGBColor::RED, 0.95);
1633
    edgeColorer.addScheme(scheme);
1634
    scheme = GUIColorScheme("by current speed (streetwise)", TL("by current speed (streetwise)"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1635
    scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1636
    scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1637
    scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1638
    scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1639
    scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1640
    edgeColorer.addScheme(scheme);
1641
    scheme = GUIColorScheme("by current flow (streetwise)", TL("by current flow (streetwise)"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1642
    scheme.addColor(RGBColor::RED, 5000.);
1643
    edgeColorer.addScheme(scheme);
1644
    scheme = GUIColorScheme("by relative speed (streetwise)", TL("by relative speed (streetwise)"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1645
    scheme.addColor(RGBColor::YELLOW, 0.25);
1646
    scheme.addColor(RGBColor::GREEN, 0.5);
1647
    scheme.addColor(RGBColor::CYAN, 0.75);
1648
    scheme.addColor(RGBColor::BLUE, 1.);
1649
    scheme.addColor(RGBColor::MAGENTA, 1.25);
1650
    edgeColorer.addScheme(scheme);
1651
    scheme = GUIColorScheme("by routing device assumed speed", TL("by routing device assumed speed"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1652
    scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1653
    scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1654
    scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1655
    scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1656
    scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1657
    edgeColorer.addScheme(scheme);
1658
    edgeColorer.addScheme(GUIColorScheme("by angle", TL("by angle"), RGBColor::YELLOW, "", true));
1659
    scheme = GUIColorScheme("by segments (alternating)", TL("by segments (alternating)"), RGBColor::BLUE, TL("odd"), true);
1660
    scheme.addColor(RGBColor::RED, 1., TL("even"));
1661
    edgeColorer.addScheme(scheme);
1662
    scheme = GUIColorScheme("by jammed state (segmentwise)", TL("by jammed state (segmentwise)"), RGBColor::GREEN, TL("free"), true, 0, COL_SCHEME_DYNAMIC);
1663
    scheme.addColor(RGBColor::YELLOW, 1., TL("limitedControl"));
1664
    scheme.addColor(RGBColor::RED, 2., TL("jammed"));
1665
    edgeColorer.addScheme(scheme);
1666
    scheme = GUIColorScheme("by current occupancy (segmentwise, brutto)", TL("by current occupancy (segmentwise, brutto)"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1667
    scheme.addColor(RGBColor::RED, 0.95);
1668
    edgeColorer.addScheme(scheme);
1669
    scheme = GUIColorScheme("by current speed (segmentwise)", TL("by current speed (segmentwise)"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1670
    scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1671
    scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1672
    scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1673
    scheme.addColor(RGBColor::BLUE, 120 / 3.6);
1674
    scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1675
    edgeColorer.addScheme(scheme);
1676
    scheme = GUIColorScheme("by current flow (segmentwise)", TL("by current flow (segmentwise)"), RGBColor::BLUE, "", false, 0, COL_SCHEME_DYNAMIC);
1677
    scheme.addColor(RGBColor::RED, 5000.);
1678
    edgeColorer.addScheme(scheme);
1679
    scheme = GUIColorScheme("by relative speed (segmentwise)", TL("by relative speed (segmentwise)"), RGBColor::RED, "", false, 0, COL_SCHEME_DYNAMIC);
1680
    scheme.addColor(RGBColor::YELLOW, 0.25);
1681
    scheme.addColor(RGBColor::GREEN, 0.5);
1682
    scheme.addColor(RGBColor::CYAN, 0.75);
1683
    scheme.addColor(RGBColor::BLUE, 1.);
1684
    scheme.addColor(RGBColor::MAGENTA, 1.25);
1685
    edgeColorer.addScheme(scheme);
1686
    scheme = GUIColorScheme("by insertion-backlog (streetwise)", TL("by insertion-backlog (streetwise)"), RGBColor::GREY, "", false, 0, COL_SCHEME_DYNAMIC);
1687
    scheme.addColor(RGBColor::GREEN, 1.);
1688
    scheme.addColor(RGBColor::YELLOW, 10.);
1689
    scheme.addColor(RGBColor::RED, 100.);
1690
    edgeColorer.addScheme(scheme);
1691
    scheme = GUIColorScheme("by TAZ (streetwise)", TL("by TAZ (streetwise)"), RGBColor(204, 204, 204), TL("no TAZ"), true);
1692
    edgeColorer.addScheme(scheme);
1693
    scheme = GUIColorScheme(SCHEME_NAME_EDGE_PARAM_NUMERICAL, TL(SCHEME_NAME_EDGE_PARAM_NUMERICAL.c_str()), RGBColor(204, 204, 204));
1694
    scheme.setAllowsNegativeValues(true);
1695
    edgeColorer.addScheme(scheme);
1696
    scheme = GUIColorScheme(SCHEME_NAME_EDGEDATA_NUMERICAL, TL(SCHEME_NAME_EDGEDATA_NUMERICAL.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA);
1697
    scheme.setAllowsNegativeValues(true);
1698
    edgeColorer.addScheme(scheme);
1699

1700
    /// add edge scaling schemes
1701
    {
1702
        edgeScaler.addScheme(GUIScaleScheme(TL("uniform"), 1, "", true));
1703
        GUIScaleScheme edgeScheme = GUIScaleScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), 0.5, TL("unselected"), true, 0, COL_SCHEME_MISC);
1704
        edgeScheme.addColor(5, 1., TL("selected"));
1705
        edgeScaler.addScheme(edgeScheme);
1706
        edgeScheme = GUIScaleScheme(TL("by allowed speed (streetwise)"), 0);
1707
        edgeScheme.addColor(10, 150. / 3.6);
1708
        edgeScaler.addScheme(edgeScheme);
1709
        edgeScheme = GUIScaleScheme(TL("by current occupancy (streetwise, brutto)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1710
        edgeScheme.addColor(10, 0.95);
1711
        edgeScaler.addScheme(edgeScheme);
1712
        edgeScheme = GUIScaleScheme(TL("by current speed (streetwise)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1713
        edgeScheme.addColor(10, 150. / 3.6);
1714
        edgeScaler.addScheme(edgeScheme);
1715
        edgeScheme = GUIScaleScheme(TL("by current flow (streetwise)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1716
        edgeScheme.addColor(20, 5000.);
1717
        edgeScaler.addScheme(edgeScheme);
1718
        edgeScheme = GUIScaleScheme(TL("by relative speed (streetwise)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1719
        edgeScheme.addColor(20, 1.);
1720
        edgeScaler.addScheme(edgeScheme);
1721
        edgeScheme = GUIScaleScheme(TL("by insertion-backlog (streetwise)"), 0, "", false, 0, COL_SCHEME_DYNAMIC);
1722
        edgeScheme.addColor(1, 1.);
1723
        edgeScheme.addColor(10, 10.);
1724
        edgeScheme.addColor(50, 100.);
1725
        edgeScaler.addScheme(edgeScheme);
1726
        edgeScheme = GUIScaleScheme(SCHEME_NAME_EDGEDATA_NUMERICAL, TL(SCHEME_NAME_EDGEDATA_NUMERICAL.c_str()), 0.1, TL("missing data"), false, MISSING_DATA);
1727
        edgeScheme.addColor(1, 1.);
1728
        edgeScheme.addColor(2, 10.);
1729
        edgeScheme.addColor(5, 100.);
1730
        edgeScheme.addColor(10, 1000.);
1731
        edgeScheme.setAllowsNegativeValues(true);
1732
        edgeScaler.addScheme(edgeScheme);
1733
    }
1734

1735
    /// add vehicle scaling schemes
1736
    {
1737
        vehicleScaler.addScheme(GUIScaleScheme(TL("uniform"), 1, "", true));
1738
        GUIScaleScheme vehScheme = GUIScaleScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), 1, TL("unselected"), true, 0, COL_SCHEME_MISC);
1739
        vehScheme.addColor(5, 1., TL("selected"));
1740
        vehicleScaler.addScheme(vehScheme);
1741
        vehScheme = GUIScaleScheme(TL("by speed"), 1, "", false, 1, COL_SCHEME_DYNAMIC);
1742
        vehScheme.addColor(5, 150. / 3.6);
1743
        vehScheme.setAllowsNegativeValues(true); // negative speed indicates stopped
1744
        vehScheme.addColor(1, -1.); // stopped on road
1745
        vehScheme.addColor(0.5, -2.); // stopped off-road (parking)
1746
        vehicleScaler.addScheme(vehScheme);
1747
        vehScheme = GUIScaleScheme(TL("by waiting time"), 1, "", false, 1, COL_SCHEME_DYNAMIC);
1748
        vehScheme.addColor(1, 30.);
1749
        vehScheme.addColor(2, 100.);
1750
        vehScheme.addColor(4, 200.);
1751
        vehScheme.addColor(10, 300.);
1752
        vehicleScaler.addScheme(vehScheme);
1753
        vehScheme = GUIScaleScheme(TL("by accumulated waiting time"), 1, "", false, 1, COL_SCHEME_DYNAMIC);
1754
        vehScheme.addColor(5, 100.);
1755
        vehicleScaler.addScheme(vehScheme);
1756
        vehScheme = GUIScaleScheme(TL("by max speed"), 1);
1757
        vehScheme.addColor(1, 30. / 3.6);
1758
        vehScheme.addColor(1, 55. / 3.6);
1759
        vehScheme.addColor(1, 80. / 3.6);
1760
        vehScheme.addColor(1, 120. / 3.6);
1761
        vehScheme.addColor(1, 150. / 3.6);
1762
        vehicleScaler.addScheme(vehScheme);
1763
        vehScheme = GUIScaleScheme(TL("by reroute number"), 1, "", false, 0, COL_SCHEME_DYNAMIC);
1764
        vehScheme.addColor(1, 1.);
1765
        vehScheme.addColor(5, 10.);
1766
        vehicleScaler.addScheme(vehScheme);
1767
        vehScheme = GUIScaleScheme(TL("by offset from best lane"), 0.8, "0", false, 0, COL_SCHEME_DYNAMIC);
1768
        vehScheme.addColor(5, -100, TL("opposite lane"));
1769
        vehScheme.addColor(3, -3, "-3");
1770
        vehScheme.addColor(1.5, -1, "-1");
1771
        vehScheme.addColor(1.5,  1,  "1");
1772
        vehScheme.addColor(3,  3,  "3");
1773
        vehScheme.setAllowsNegativeValues(true);
1774
        vehicleScaler.addScheme(vehScheme);
1775
        vehScheme = GUIScaleScheme(TL("by acceleration"), 0.8, "0", false, 0, COL_SCHEME_DYNAMIC);
1776
        vehScheme.addColor(4, -9.0);
1777
        vehScheme.addColor(2, -4.5 /* -SUMOVTypeParameter::getDefaultDecel() */);
1778
        vehScheme.addColor(1, -0.1);
1779
        vehScheme.addColor(1,  0.1);
1780
        vehScheme.addColor(1,  2.6 /* SUMOVTypeParameter::getDefaultAccel() */);
1781
        vehScheme.addColor(3,  5.2);
1782
        vehScheme.setAllowsNegativeValues(true);
1783
        vehicleScaler.addScheme(vehScheme);
1784
        vehScheme = GUIScaleScheme(TL("by time gap on lane"), 5, "0", false, 0, COL_SCHEME_DYNAMIC);
1785
        vehScheme.addColor(1, -1);
1786
        vehScheme.addColor(1, 1);
1787
        vehScheme.addColor(0.5, 2);
1788
        vehScheme.setAllowsNegativeValues(true);
1789
        vehicleScaler.addScheme(vehScheme);
1790
        vehScheme = GUIScaleScheme(TL("by depart delay"), 0.8);
1791
        vehScheme.addColor(1, 10.);
1792
        vehScheme.addColor(2, 100.);
1793
        vehScheme.addColor(3, 200.);
1794
        vehScheme.addColor(5, 300.);
1795
        vehicleScaler.addScheme(vehScheme);
1796
        vehScheme = GUIScaleScheme(TL("by time loss"), 1, "", false, 0, COL_SCHEME_DYNAMIC);
1797
        vehScheme.addColor(1, 10.);
1798
        vehScheme.addColor(2, 60.);
1799
        vehScheme.addColor(3, 180.);
1800
        vehScheme.addColor(10, 900.);
1801
        vehicleScaler.addScheme(vehScheme);
1802
        vehScheme = GUIScaleScheme(TL("by stop delay"), 0.1, "", false, -1, COL_SCHEME_DYNAMIC);
1803
        vehScheme.addColor(1, 0.);
1804
        vehScheme.addColor(2, 10.);
1805
        vehScheme.addColor(3, 60.);
1806
        vehScheme.addColor(4, 120.);
1807
        vehScheme.addColor(5, 300.);
1808
        vehScheme.addColor(10, 900.);
1809
        vehScheme.setAllowsNegativeValues(true);
1810
        vehicleScaler.addScheme(vehScheme);
1811
        vehScheme = GUIScaleScheme(TL("by stop arrival delay"), 0.1, "", false, INVALID_DOUBLE, COL_SCHEME_DYNAMIC);
1812
        vehScheme.addColor(0.5, -10.);
1813
        vehScheme.addColor(1, 0.);
1814
        vehScheme.addColor(2, 10.);
1815
        vehScheme.addColor(3, 60.);
1816
        vehScheme.addColor(4, 120.);
1817
        vehScheme.addColor(5, 300.);
1818
        vehScheme.addColor(10, 900.);
1819
        vehScheme.setAllowsNegativeValues(true);
1820
        vehicleScaler.addScheme(vehScheme);
1821
        vehScheme = GUIScaleScheme(SCHEME_NAME_PARAM_NUMERICAL, TL(SCHEME_NAME_PARAM_NUMERICAL.c_str()), 1);
1822
        vehScheme.setAllowsNegativeValues(true);
1823
        vehicleScaler.addScheme(vehScheme);
1824
    }
1825
}
1826

1827

1828
void
1829
GUIVisualizationSettings::initNeteditDefaults() {
1830
    // init color schemes
1831
    GUIColorScheme scheme = GUIColorScheme("uniform", TL("uniform"), RGBColor::BLACK, TL("road"), true);
1832
    scheme.addColor(RGBColor::GREY, 1, TL("sidewalk"));
1833
    scheme.addColor(RGBColor(192, 66, 44), 2, TL("bike lane"));
1834
    scheme.addColor(RGBColor(200, 255, 200), 3, TL("green verge"));
1835
    scheme.addColor(RGBColor(150, 200, 200), 4, TL("waterway"));
1836
    scheme.addColor(RGBColor::BLACK, 5, TL("railway"));
1837
    scheme.addColor(RGBColor(64, 0, 64), 6, TL("rails on road"));
1838
    scheme.addColor(RGBColor(92, 92, 92), 7, TL("no passenger")); // paths, service roads etc
1839
    scheme.addColor(RGBColor::RED, 8, TL("closed")); // road closing
1840
    scheme.addColor(RGBColor::GREEN, 9, TL("connector")); // macro-connector
1841
    scheme.addColor(RGBColor::ORANGE, 10, TL("forbidden")); // forbidden road
1842
    scheme.addColor(RGBColor(145, 145, 145), 11, TL("data mode"));
1843
    scheme.addColor(RGBColor(200, 240, 240), 12, TL("airway"));
1844
    laneColorer.addScheme(scheme);
1845
    scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(128, 128, 128, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1846
    scheme.addColor(RGBColor(0, 80, 180, 255), 1., TL("selected"));
1847
    laneColorer.addScheme(scheme);
1848
    scheme = GUIColorScheme("by permission code", TL("by permission code"), RGBColor(240, 240, 240), "nobody");
1849
    scheme.addColor(RGBColor(10, 10, 10), (double)SVC_PASSENGER, "passenger");
1850
    scheme.addColor(RGBColor(128, 128, 128), (double)SVC_PEDESTRIAN, "pedestrian");
1851
    scheme.addColor(RGBColor(80, 80, 80), (double)(SVC_PEDESTRIAN | SVC_DELIVERY), "pedestrian_delivery");
1852
    scheme.addColor(RGBColor(192, 66, 44), (double)SVC_BICYCLE, "bicycle");
1853
    scheme.addColor(RGBColor(40, 100, 40), (double)SVC_BUS, "bus");
1854
    scheme.addColor(RGBColor(166, 147, 26), (double)SVC_TAXI, "taxi");
1855
    scheme.addColor(RGBColor::BLACK, (double)(SVCAll & ~SVC_NON_ROAD), "normal_road");
1856
    scheme.addColor(RGBColor::BLACK, (double)(SVCAll & ~(SVC_PEDESTRIAN | SVC_NON_ROAD)), "disallow_pedestrian");
1857
    scheme.addColor(RGBColor(255, 206, 0), (double)(SVCAll & ~(SVC_PEDESTRIAN | SVC_BICYCLE | SVC_MOPED | SVC_NON_ROAD)), "motorway");
1858
    scheme.addColor(RGBColor(150, 200, 200), (double)SVC_SHIP, "waterway");
1859
    scheme.addColor(RGBColor::GREEN, (double)SVCAll, "all");
1860
    laneColorer.addScheme(scheme);
1861

1862
    scheme = GUIColorScheme("by allowed speed (lanewise)", RGBColor::RED);
1863
    scheme.addColor(RGBColor::YELLOW, 30. / 3.6);
1864
    scheme.addColor(RGBColor::GREEN, 55. / 3.6);
1865
    scheme.addColor(RGBColor::CYAN, 80. / 3.6);
1866
    scheme.addColor(RGBColor::BLUE, 120. / 3.6);
1867
    scheme.addColor(RGBColor::MAGENTA, 150. / 3.6);
1868
    laneColorer.addScheme(scheme);
1869

1870
    scheme = GUIColorScheme("by lane number (streetwise)", RGBColor::RED);
1871
    scheme.addColor(RGBColor::BLUE, 5.);
1872
    laneColorer.addScheme(scheme);
1873

1874
    scheme = GUIColorScheme("by given length/geometrical length", RGBColor::RED);
1875
    scheme.addColor(RGBColor::ORANGE, 0.25);
1876
    scheme.addColor(RGBColor::YELLOW, 0.5);
1877
    scheme.addColor(RGBColor(179, 179, 179, 255), 1.);
1878
    scheme.addColor(RGBColor::GREEN, 2.);
1879
    scheme.addColor(RGBColor::CYAN, 4.);
1880
    scheme.addColor(RGBColor::BLUE, 100.);
1881
    laneColorer.addScheme(scheme);
1882
    laneColorer.addScheme(GUIColorScheme("by angle", TL("by angle"), RGBColor::YELLOW, "", true));
1883

1884
    scheme = GUIColorScheme("by priority", TL("by priority"), RGBColor::YELLOW);
1885
    scheme.addColor(RGBColor::RED, -20.);
1886
    scheme.addColor(RGBColor::GREEN, 20.);
1887
    scheme.setAllowsNegativeValues(true);
1888
    laneColorer.addScheme(scheme);
1889
    scheme = GUIColorScheme("by height at start", TL("by height at start"), RGBColor::RED);
1890
    scheme.addColor(RGBColor::BLUE, -10.);
1891
    scheme.addColor(RGBColor::YELLOW, 50.);
1892
    scheme.addColor(RGBColor::GREEN, 100.);
1893
    scheme.addColor(RGBColor::MAGENTA, 200.);
1894
    scheme.setAllowsNegativeValues(true);
1895
    laneColorer.addScheme(scheme);
1896
    scheme = GUIColorScheme("by height at segment start", TL("by height at segment start"), RGBColor::RED);
1897
    scheme.addColor(RGBColor::BLUE, -10.);
1898
    scheme.addColor(RGBColor::YELLOW, 50.);
1899
    scheme.addColor(RGBColor::GREEN, 100.);
1900
    scheme.addColor(RGBColor::MAGENTA, 200.);
1901
    scheme.setAllowsNegativeValues(true);
1902
    laneColorer.addScheme(scheme);
1903
    scheme = GUIColorScheme("by inclination", TL("by inclination"), RGBColor::GREY);
1904
    scheme.addColor(RGBColor::YELLOW, 0.1);
1905
    scheme.addColor(RGBColor::RED, 0.3);
1906
    scheme.addColor(RGBColor::GREEN, -0.1);
1907
    scheme.addColor(RGBColor::BLUE, -0.3);
1908
    scheme.setAllowsNegativeValues(true);
1909
    laneColorer.addScheme(scheme);
1910
    scheme = GUIColorScheme("by segment inclination", TL("by segment inclination"), RGBColor::GREY);
1911
    scheme.addColor(RGBColor::YELLOW, 0.1);
1912
    scheme.addColor(RGBColor::RED, 0.3);
1913
    scheme.addColor(RGBColor::GREEN, -0.1);
1914
    scheme.addColor(RGBColor::BLUE, -0.3);
1915
    scheme.setAllowsNegativeValues(true);
1916
    laneColorer.addScheme(scheme);
1917
    scheme = GUIColorScheme(SCHEME_NAME_EDGE_PARAM_NUMERICAL, TL(SCHEME_NAME_EDGE_PARAM_NUMERICAL.c_str()), RGBColor(204, 204, 204));
1918
    scheme.setAllowsNegativeValues(true);
1919
    laneColorer.addScheme(scheme);
1920
    scheme = GUIColorScheme(SCHEME_NAME_LANE_PARAM_NUMERICAL, TL(SCHEME_NAME_LANE_PARAM_NUMERICAL.c_str()), RGBColor(204, 204, 204));
1921
    scheme.setAllowsNegativeValues(true);
1922
    laneColorer.addScheme(scheme);
1923
    scheme = GUIColorScheme("by distance (kilometrage)", RGBColor(204, 204, 204));
1924
    scheme.addColor(RGBColor::RED, 1.);
1925
    scheme.addColor(RGBColor::RED, -1.);
1926
    scheme.setAllowsNegativeValues(true);
1927
    laneColorer.addScheme(scheme);
1928
    scheme = GUIColorScheme("by abs distance (kilometrage)", RGBColor(204, 204, 204));
1929
    scheme.addColor(RGBColor::RED, 1.);
1930
    scheme.setAllowsNegativeValues(false);
1931
    laneColorer.addScheme(scheme);
1932
    scheme = GUIColorScheme(SCHEME_NAME_EDGEDATA_NUMERICAL, TL(SCHEME_NAME_EDGEDATA_NUMERICAL.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA);
1933
    scheme.setAllowsNegativeValues(true);
1934
    laneColorer.addScheme(scheme);
1935

1936
    scheme = GUIColorScheme("uniform", TL("uniform"), RGBColor(102, 0, 0), "", true);
1937
    scheme.addColor(RGBColor(204, 0, 0), 1, TL("junction bubble"));
1938
    scheme.addColor(RGBColor(230, 100, 115), 2, TL("geometry points"));
1939
    scheme.addColor(GUIVisualizationColorSettings::SUMO_color_DEADEND_SHOW, 3, TL("connections missing"));
1940
    scheme.addColor(RGBColor::GREEN, 3, TL("custom shape"));
1941
    scheme.addColor(RGBColor(205, 180, 180), 4, TL("data mode"));
1942
    junctionColorer.addScheme(scheme);
1943
    scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(128, 128, 128, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1944
    scheme.addColor(RGBColor(0, 80, 180, 255), 1, TL("selected"));
1945
    junctionColorer.addScheme(scheme);
1946
    scheme = GUIColorScheme(SCHEME_NAME_TYPE, TL(SCHEME_NAME_TYPE.c_str()), RGBColor::GREEN, "traffic_light", true);
1947
    scheme.addColor(RGBColor(0, 128, 0), 1, "traffic_light_unregulated");
1948
    scheme.addColor(RGBColor::YELLOW, 2, "priority");
1949
    scheme.addColor(RGBColor::RED, 3, "priority_stop");
1950
    scheme.addColor(RGBColor::BLUE, 4, "right_before_left");
1951
    scheme.addColor(RGBColor::CYAN, 5, "allway_stop");
1952
    scheme.addColor(RGBColor::GREY, 6, "district");
1953
    scheme.addColor(RGBColor::MAGENTA, 7, "unregulated");
1954
    scheme.addColor(RGBColor::BLACK, 8, "dead_end");
1955
    scheme.addColor(RGBColor::ORANGE, 9, "rail_signal");
1956
    scheme.addColor(RGBColor(172, 108, 44), 10, "zipper"); // brown, darker than the zipper link rule
1957
    scheme.addColor(RGBColor(192, 255, 192), 11, "traffic_light_right_on_red");
1958
    scheme.addColor(RGBColor(128, 0, 128), 12, "rail_crossing"); // dark purple
1959
    scheme.addColor(RGBColor(0, 0, 128), 13, "left_before_right"); // dark blue
1960
    junctionColorer.addScheme(scheme);
1961
    scheme = GUIColorScheme("by height", TL("by height"), RGBColor::GREY);
1962
    scheme.addColor(RGBColor::BLUE, -10.);
1963
    scheme.addColor(RGBColor::RED, 10.);
1964
    scheme.addColor(RGBColor::YELLOW, 50.);
1965
    scheme.addColor(RGBColor::GREEN, 100.);
1966
    scheme.addColor(RGBColor::MAGENTA, 200.);
1967
    scheme.setAllowsNegativeValues(true);
1968
    junctionColorer.addScheme(scheme);
1969

1970
    /// add POI coloring schemes
1971
    poiColorer.addScheme(GUIColorScheme("given POI color", TL("given POI color"), RGBColor::RED, "", true));
1972
    scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(179, 179, 179, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1973
    scheme.addColor(RGBColor(0, 102, 204, 255), 1, TL("selected"));
1974
    poiColorer.addScheme(scheme);
1975
    poiColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::RED, "", true));
1976

1977
    /// add polygon coloring schemes
1978
    polyColorer.addScheme(GUIColorScheme("given polygon color", TL("given polygon color"), RGBColor::ORANGE, "", true));
1979
    scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(179, 179, 179, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1980
    scheme.addColor(RGBColor(0, 102, 204, 255), 1, TL("selected"));
1981
    polyColorer.addScheme(scheme);
1982
    polyColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::ORANGE, "", true));
1983
    polyColorer.addScheme(GUIColorScheme("random", TL("random"), RGBColor::YELLOW, "", true));
1984

1985
    /// add edge scaling schemes
1986
    {
1987
        GUIScaleScheme edgeScheme = GUIScaleScheme(TL("default"), 1, TL("uniform"), true);
1988
        laneScaler.addScheme(edgeScheme);
1989
    }
1990

1991
    /// add data coloring schemes
1992
    dataColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::ORANGE, "", true));
1993
    scheme = GUIColorScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), RGBColor(128, 128, 128, 255), TL("unselected"), true, 0, COL_SCHEME_MISC);
1994
    scheme.addColor(RGBColor(0, 80, 180, 255), 1, TL("selected"));
1995
    dataColorer.addScheme(scheme);
1996
    dataColorer.addScheme(GUIColorScheme("by origin taz", TL("by origin taz"), RGBColor::ORANGE, "", true));
1997
    dataColorer.addScheme(GUIColorScheme("by destination taz", TL("by destination taz"), RGBColor::ORANGE, "", true));
1998
    scheme = GUIColorScheme(SCHEME_NAME_DATA_ATTRIBUTE_NUMERICAL, TL(SCHEME_NAME_DATA_ATTRIBUTE_NUMERICAL.c_str()), COL_MISSING_DATA, TL("missing data"), false, MISSING_DATA);
1999
    scheme.setAllowsNegativeValues(true);
2000
    dataColorer.addScheme(scheme);
2001

2002
    // dummy schemes
2003
    vehicleColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::YELLOW, "", true));
2004
    personColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::YELLOW, "", true));
2005
    containerColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::YELLOW, "", true));
2006
    vehicleScaler.addScheme(GUIScaleScheme(TL("uniform"), 1, "", true));
2007
}
2008

2009

2010
int
2011
GUIVisualizationSettings::getLaneEdgeMode() const {
2012
    if (UseMesoSim) {
2013
        return edgeColorer.getActive();
2014
    }
2015
    return laneColorer.getActive();
2016
}
2017

2018

2019
int
2020
GUIVisualizationSettings::getLaneEdgeScaleMode() const {
2021
    if (UseMesoSim) {
2022
        return edgeScaler.getActive();
2023
    }
2024
    return laneScaler.getActive();
2025
}
2026

2027

2028
GUIColorScheme&
2029
GUIVisualizationSettings::getLaneEdgeScheme() {
2030
    if (UseMesoSim) {
2031
        return edgeColorer.getScheme();
2032
    }
2033
    return laneColorer.getScheme();
2034
}
2035

2036

2037
GUIScaleScheme&
2038
GUIVisualizationSettings::getLaneEdgeScaleScheme() {
2039
    if (UseMesoSim) {
2040
        return edgeScaler.getScheme();
2041
    }
2042
    return laneScaler.getScheme();
2043
}
2044

2045

2046
void
2047
GUIVisualizationSettings::save(OutputDevice& dev) const {
2048
    dev.openTag(SUMO_TAG_VIEWSETTINGS_SCHEME);
2049
    dev.writeAttr(SUMO_ATTR_NAME, name);
2050
    dev.openTag(SUMO_TAG_VIEWSETTINGS_OPENGL);
2051
    dev.writeAttr("dither", dither);
2052
    dev.writeAttr("fps", fps);
2053
    dev.writeAttr("trueZ", trueZ);
2054
    dev.writeAttr("drawBoundaries", drawBoundaries);
2055
    dev.writeAttr("disableDottedContours", disableDottedContours);
2056
    dev.writeAttr("forceDrawRectangleSelection", forceDrawForRectangleSelection);
2057
    geometryIndices.print(dev, "geometryIndices");
2058
    dev.closeTag();
2059
    dev.openTag(SUMO_TAG_VIEWSETTINGS_BACKGROUND);
2060
    dev.writeAttr("backgroundColor", backgroundColor);
2061
    dev.writeAttr("showGrid", showGrid);
2062
    dev.writeAttr("gridXSize", gridXSize);
2063
    dev.writeAttr("gridYSize", gridYSize);
2064
    dev.closeTag();
2065
    // edges
2066
    dev.openTag(SUMO_TAG_VIEWSETTINGS_EDGES);
2067
    dev.writeAttr("laneEdgeMode", getLaneEdgeMode());
2068
    dev.writeAttr("scaleMode", getLaneEdgeScaleMode());
2069
    dev.writeAttr("laneShowBorders", laneShowBorders);
2070
    dev.writeAttr("showBikeMarkings", showBikeMarkings);
2071
    dev.writeAttr("showLinkDecals", showLinkDecals);
2072
    dev.writeAttr("realisticLinkRules", realisticLinkRules);
2073
    dev.writeAttr("showLinkRules", showLinkRules);
2074
    dev.writeAttr("showRails", showRails);
2075
    dev.writeAttr("secondaryShape", secondaryShape);
2076
    dev.writeAttr("hideConnectors", hideConnectors);
2077
    dev.writeAttr("widthExaggeration", laneWidthExaggeration);
2078
    dev.writeAttr("minSize", laneMinSize);
2079
    dev.writeAttr("showDirection", showLaneDirection);
2080
    dev.writeAttr("showSublanes", showSublanes);
2081
    dev.writeAttr("spreadSuperposed", spreadSuperposed);
2082
    dev.writeAttr("disableHideByZoom", disableHideByZoom);
2083
    dev.writeAttr("edgeParam", edgeParam);
2084
    dev.writeAttr("laneParam", laneParam);
2085
    dev.writeAttr("edgeData", edgeData);
2086
    dev.writeAttr("edgeDataID", edgeDataID);
2087
    dev.writeAttr("edgeDataScaling", edgeDataScaling);
2088
    edgeValueRainBow.print(dev, "edgeValue");
2089
    dev.lf();
2090
    dev << "               ";
2091
    edgeName.print(dev, "edgeName");
2092
    dev.lf();
2093
    dev << "               ";
2094
    internalEdgeName.print(dev, "internalEdgeName");
2095
    dev.lf();
2096
    dev << "               ";
2097
    cwaEdgeName.print(dev, "cwaEdgeName");
2098
    dev.lf();
2099
    dev << "               ";
2100
    streetName.print(dev, "streetName");
2101
    dev.lf();
2102
    dev << "               ";
2103
    edgeValue.print(dev, "edgeValue");
2104
    edgeScaleValue.print(dev, "edgeScaleValue");
2105
    laneColorer.save(dev);
2106
    laneScaler.save(dev);
2107
    edgeColorer.save(dev, "meso:");
2108
    edgeScaler.save(dev, "meso:");
2109
    dev.closeTag();
2110
    // vehicles
2111
    dev.openTag(SUMO_TAG_VIEWSETTINGS_VEHICLES);
2112
    dev.writeAttr("vehicleMode", vehicleColorer.getActive());
2113
    dev.writeAttr("vehicleScaleMode", vehicleScaler.getActive());
2114
    dev.writeAttr("vehicleQuality", vehicleQuality);
2115
    vehicleSize.print(dev, "vehicle");
2116
    vehicleValueRainBow.print(dev, "vehicleValue");
2117
    dev.writeAttr("showBlinker", showBlinker);
2118
    dev.writeAttr("drawMinGap", drawMinGap);
2119
    dev.writeAttr("drawBrakeGap", drawBrakeGap);
2120
    dev.writeAttr("showBTRange", showBTRange);
2121
    dev.writeAttr("showRouteIndex", showRouteIndex);
2122
    dev.writeAttr("scaleLength", scaleLength);
2123
    dev.writeAttr("drawReversed", drawReversed);
2124
    dev.writeAttr("showParkingInfo", showParkingInfo);
2125
    dev.writeAttr("showChargingInfo", showChargingInfo);
2126
    dev.writeAttr("vehicleParam", vehicleParam);
2127
    dev.writeAttr("vehicleScaleParam", vehicleScaleParam);
2128
    dev.writeAttr("vehicleTextParam", vehicleTextParam);
2129
    dev.lf();
2130
    dev << "                 ";
2131
    vehicleName.print(dev, "vehicleName");
2132
    dev.lf();
2133
    dev << "                 ";
2134
    vehicleValue.print(dev, "vehicleValue");
2135
    dev.lf();
2136
    dev << "                 ";
2137
    vehicleScaleValue.print(dev, "vehicleScaleValue");
2138
    dev.lf();
2139
    dev << "                 ";
2140
    vehicleText.print(dev, "vehicleText");
2141
    vehicleColorer.save(dev);
2142
    vehicleScaler.save(dev);
2143
    dev.closeTag();
2144
    // persons
2145
    dev.openTag(SUMO_TAG_VIEWSETTINGS_PERSONS);
2146
    dev.writeAttr("personMode", personColorer.getActive());
2147
    dev.writeAttr("personQuality", personQuality);
2148
    dev.writeAttr("showPedestrianNetwork", showPedestrianNetwork);
2149
    dev.writeAttr("pedestrianNetworkColor", pedestrianNetworkColor);
2150
    personSize.print(dev, "person");
2151
    dev.lf();
2152
    dev << "                ";
2153
    personName.print(dev, "personName");
2154
    dev.lf();
2155
    dev << "                 ";
2156
    personValue.print(dev, "personValue");
2157
    personColorer.save(dev);
2158
    dev.closeTag();
2159
    // containers
2160
    dev.openTag(SUMO_TAG_VIEWSETTINGS_CONTAINERS);
2161
    dev.writeAttr("containerMode", containerColorer.getActive());
2162
    dev.writeAttr("containerQuality", containerQuality);
2163
    containerSize.print(dev, "container");
2164
    dev.lf();
2165
    dev << "                ";
2166
    containerName.print(dev, "containerName");
2167
    containerColorer.save(dev);
2168
    dev.closeTag();
2169
    // junctions
2170
    dev.openTag(SUMO_TAG_VIEWSETTINGS_JUNCTIONS);
2171
    dev.writeAttr("junctionMode", junctionColorer.getActive());
2172
    dev.lf();
2173
    dev << "                  ";
2174
    drawLinkTLIndex.print(dev, "drawLinkTLIndex");
2175
    dev.lf();
2176
    dev << "                  ";
2177
    drawLinkJunctionIndex.print(dev, "drawLinkJunctionIndex");
2178
    dev.lf();
2179
    dev << "                  ";
2180
    junctionID.print(dev, "junctionID");
2181
    dev.lf();
2182
    dev << "                  ";
2183
    junctionName.print(dev, "junctionName");
2184
    dev.lf();
2185
    dev << "                  ";
2186
    internalJunctionName.print(dev, "internalJunctionName");
2187
    dev.lf();
2188
    dev << "                  ";
2189
    tlsPhaseIndex.print(dev, "tlsPhaseIndex");
2190
    tlsPhaseName.print(dev, "tlsPhaseName");
2191
    dev.lf();
2192
    dev << "                  ";
2193
    dev.writeAttr("showLane2Lane", showLane2Lane);
2194
    dev.writeAttr("drawShape", drawJunctionShape);
2195
    dev.writeAttr("drawCrossingsAndWalkingareas", drawCrossingsAndWalkingareas);
2196
    junctionSize.print(dev, "junction");
2197
    junctionValueRainBow.print(dev, "junctionValue");
2198
    junctionColorer.save(dev);
2199
    dev.closeTag();
2200
    // additionals
2201
    dev.openTag(SUMO_TAG_VIEWSETTINGS_ADDITIONALS);
2202
    dev.writeAttr("addMode", addMode);
2203
    addSize.print(dev, "add");
2204
    addName.print(dev, "addName");
2205
    addFullName.print(dev, "addFullName");
2206
    // temporal (will be integrated in a schema)
2207
    dev.writeAttr("busStopColor", colorSettings.busStopColor);
2208
    dev.writeAttr("busStopColorSign", colorSettings.busStopColorSign);
2209
    dev.writeAttr("chargingStationColor", colorSettings.chargingStationColor);
2210
    dev.writeAttr("chargingStationColorCharge", colorSettings.chargingStationColorCharge);
2211
    dev.writeAttr("chargingStationColorSign", colorSettings.chargingStationColorSign);
2212
    dev.writeAttr("containerStopColor", colorSettings.containerStopColor);
2213
    dev.writeAttr("containerStopColorSign", colorSettings.containerStopColorSign);
2214
    dev.writeAttr("parkingAreaColor", colorSettings.parkingAreaColor);
2215
    dev.writeAttr("parkingAreaColorSign", colorSettings.parkingAreaColorSign);
2216
    dev.writeAttr("parkingSpaceColor", colorSettings.parkingSpaceColor);
2217
    dev.writeAttr("parkingSpaceColorContour", colorSettings.parkingSpaceColorContour);
2218
    dev.writeAttr("personTripColor", colorSettings.personTripColor);
2219
    dev.writeAttr("personTripWidth", widthSettings.personTripWidth);
2220
    dev.writeAttr("rideColor", colorSettings.rideColor);
2221
    dev.writeAttr("rideWidth", widthSettings.rideWidth);
2222
    dev.writeAttr("selectedAdditionalColor", colorSettings.selectedAdditionalColor);
2223
    dev.writeAttr("selectedConnectionColor", colorSettings.selectedConnectionColor);
2224
    dev.writeAttr("selectedContainerColor", colorSettings.selectedContainerColor);
2225
    dev.writeAttr("selectedContainerPlanColor", colorSettings.selectedContainerPlanColor);
2226
    dev.writeAttr("selectedCrossingColor", colorSettings.selectedCrossingColor);
2227
    dev.writeAttr("selectedEdgeColor", colorSettings.selectedEdgeColor);
2228
    dev.writeAttr("selectedEdgeDataColor", colorSettings.selectedEdgeDataColor);
2229
    dev.writeAttr("selectedLaneColor", colorSettings.selectedLaneColor);
2230
    dev.writeAttr("selectedPersonColor", colorSettings.selectedPersonColor);
2231
    dev.writeAttr("selectedPersonPlanColor", colorSettings.selectedPersonPlanColor);
2232
    dev.writeAttr("selectedProhibitionColor", colorSettings.selectedProhibitionColor);
2233
    dev.writeAttr("selectedRouteColor", colorSettings.selectedRouteColor);
2234
    dev.writeAttr("selectedVehicleColor", colorSettings.selectedVehicleColor);
2235
    dev.writeAttr("selectionColor", colorSettings.selectionColor);
2236
    dev.writeAttr("stopColor", colorSettings.stopColor);
2237
    dev.writeAttr("waypointColor", colorSettings.waypointColor);
2238
    dev.writeAttr("stopContainerColor", colorSettings.stopContainerColor);
2239
    dev.writeAttr("stopPersonColor", colorSettings.stopPersonColor);
2240
    dev.writeAttr("trainStopColor", colorSettings.trainStopColor);
2241
    dev.writeAttr("trainStopColorSign", colorSettings.trainStopColorSign);
2242
    dev.writeAttr("transhipColor", colorSettings.transhipColor);
2243
    dev.writeAttr("transhipWidth", widthSettings.transhipWidth);
2244
    dev.writeAttr("transportColor", colorSettings.transportColor);
2245
    dev.writeAttr("transportWidth", widthSettings.transportWidth);
2246
    dev.writeAttr("tripWidth", widthSettings.tripWidth);
2247
    dev.writeAttr("vehicleTripColor", colorSettings.personTripColor);
2248
    dev.writeAttr("walkColor", colorSettings.walkColor);
2249
    dev.writeAttr("walkWidth", widthSettings.walkWidth);
2250
    dev.closeTag();
2251
    // pois
2252
    dev.openTag(SUMO_TAG_VIEWSETTINGS_POIS);
2253
    dev.writeAttr("poiTextParam", poiTextParam);
2254
    poiSize.print(dev, "poi");
2255
    dev.writeAttr("poiDetail", poiDetail);
2256
    poiName.print(dev, "poiName");
2257
    poiType.print(dev, "poiType");
2258
    poiText.print(dev, "poiText");
2259
    dev.writeAttr("poiUseCustomLayer", poiUseCustomLayer);
2260
    dev.writeAttr("poiCustomLayer", poiCustomLayer);
2261
    poiColorer.save(dev);
2262
    dev.closeTag();
2263
    // polys
2264
    dev.openTag(SUMO_TAG_VIEWSETTINGS_POLYS);
2265
    polySize.print(dev, "poly");
2266
    polyName.print(dev, "polyName");
2267
    polyType.print(dev, "polyType");
2268
    dev.writeAttr("polyUseCustomLayer", polyUseCustomLayer);
2269
    dev.writeAttr("polyCustomLayer", polyCustomLayer);
2270
    polyColorer.save(dev);
2271
    dev.closeTag();
2272
    // 3D
2273
    dev.openTag(SUMO_TAG_VIEWSETTINGS_3D);
2274
    dev.writeAttr("ignoreColorSchemeFor3DVehicles", ignoreColorSchemeFor3DVehicles);
2275
    dev.writeAttr("show3DTLSLinkMarkers", show3DTLSLinkMarkers);
2276
    dev.writeAttr("show3DTLSDomes", show3DTLSDomes);
2277
    dev.writeAttr("show3DHeadUpDisplay", show3DHeadUpDisplay);
2278
    dev.writeAttr("generate3DTLSModels", generate3DTLSModels);
2279
    dev.writeAttr("ambient3DLight", ambient3DLight);
2280
    dev.writeAttr("diffuse3DLight", diffuse3DLight);
2281
    dev.closeTag();
2282
    // legend
2283
    dev.openTag(SUMO_TAG_VIEWSETTINGS_LEGEND);
2284
    dev.writeAttr("showSizeLegend", showSizeLegend);
2285
    dev.writeAttr("showColorLegend", showColorLegend);
2286
    dev.writeAttr("showVehicleColorLegend", showVehicleColorLegend);
2287
    dev.closeTag();
2288

2289
    dev.closeTag();
2290
}
2291

2292

2293
bool
2294
GUIVisualizationSettings::operator==(const GUIVisualizationSettings& v2) {
2295
    if (ignoreColorSchemeFor3DVehicles != v2.ignoreColorSchemeFor3DVehicles) {
2296
        return false;
2297
    }
2298
    if (show3DTLSDomes != v2.show3DTLSDomes) {
2299
        return false;
2300
    }
2301
    if (show3DTLSLinkMarkers != v2.show3DTLSLinkMarkers) {
2302
        return false;
2303
    }
2304
    if (show3DHeadUpDisplay != v2.show3DHeadUpDisplay) {
2305
        return false;
2306
    }
2307
    if (generate3DTLSModels != v2.generate3DTLSModels) {
2308
        return false;
2309
    }
2310
    if (ambient3DLight != v2.ambient3DLight) {
2311
        return false;
2312
    }
2313
    if (diffuse3DLight != v2.diffuse3DLight) {
2314
        return false;
2315
    }
2316
    if (skyColor != v2.skyColor) {
2317
        return false;
2318
    }
2319
    if (dither != v2.dither) {
2320
        return false;
2321
    }
2322
    if (fps != v2.fps) {
2323
        return false;
2324
    }
2325
    if (trueZ != v2.trueZ) {
2326
        return false;
2327
    }
2328
    if (drawBoundaries != v2.drawBoundaries) {
2329
        return false;
2330
    }
2331
    if (disableDottedContours != v2.disableDottedContours) {
2332
        return false;
2333
    }
2334
    if (forceDrawForRectangleSelection != v2.forceDrawForRectangleSelection) {
2335
        return false;
2336
    }
2337
    if (geometryIndices != v2.geometryIndices) {
2338
        return false;
2339
    }
2340
    if (backgroundColor != v2.backgroundColor) {
2341
        return false;
2342
    }
2343
    if (colorSettings != v2.colorSettings) {
2344
        return false;
2345
    }
2346
    if (showGrid != v2.showGrid) {
2347
        return false;
2348
    }
2349
    if (gridXSize != v2.gridXSize) {
2350
        return false;
2351
    }
2352
    if (gridYSize != v2.gridYSize) {
2353
        return false;
2354
    }
2355

2356
    if (!(edgeColorer == v2.edgeColorer)) {
2357
        return false;
2358
    }
2359
    if (!(edgeScaler == v2.edgeScaler)) {
2360
        return false;
2361
    }
2362
    if (!(laneColorer == v2.laneColorer)) {
2363
        return false;
2364
    }
2365
    if (!(laneScaler == v2.laneScaler)) {
2366
        return false;
2367
    }
2368
    if (laneShowBorders != v2.laneShowBorders) {
2369
        return false;
2370
    }
2371
    if (showBikeMarkings != v2.showBikeMarkings) {
2372
        return false;
2373
    }
2374
    if (showLinkDecals != v2.showLinkDecals) {
2375
        return false;
2376
    }
2377
    if (realisticLinkRules != v2.realisticLinkRules) {
2378
        return false;
2379
    }
2380
    if (showLinkRules != v2.showLinkRules) {
2381
        return false;
2382
    }
2383
    if (showRails != v2.showRails) {
2384
        return false;
2385
    }
2386
    if (secondaryShape != v2.secondaryShape) {
2387
        return false;
2388
    }
2389
    if (edgeName != v2.edgeName) {
2390
        return false;
2391
    }
2392
    if (internalEdgeName != v2.internalEdgeName) {
2393
        return false;
2394
    }
2395
    if (cwaEdgeName != v2.cwaEdgeName) {
2396
        return false;
2397
    }
2398
    if (streetName != v2.streetName) {
2399
        return false;
2400
    }
2401
    if (edgeValue != v2.edgeValue) {
2402
        return false;
2403
    }
2404
    if (edgeScaleValue != v2.edgeScaleValue) {
2405
        return false;
2406
    }
2407
    if (hideConnectors != v2.hideConnectors) {
2408
        return false;
2409
    }
2410
    if (laneWidthExaggeration != v2.laneWidthExaggeration) {
2411
        return false;
2412
    }
2413
    if (laneMinSize != v2.laneMinSize) {
2414
        return false;
2415
    }
2416
    if (showLaneDirection != v2.showLaneDirection) {
2417
        return false;
2418
    }
2419
    if (showSublanes != v2.showSublanes) {
2420
        return false;
2421
    }
2422
    if (spreadSuperposed != v2.spreadSuperposed) {
2423
        return false;
2424
    }
2425
    if (disableHideByZoom != v2.disableHideByZoom) {
2426
        return false;
2427
    }
2428
    if (edgeParam != v2.edgeParam) {
2429
        return false;
2430
    }
2431
    if (laneParam != v2.laneParam) {
2432
        return false;
2433
    }
2434
    if (vehicleParam != v2.vehicleParam) {
2435
        return false;
2436
    }
2437
    if (vehicleScaleParam != v2.vehicleScaleParam) {
2438
        return false;
2439
    }
2440
    if (vehicleTextParam != v2.vehicleTextParam) {
2441
        return false;
2442
    }
2443
    if (edgeData != v2.edgeData) {
2444
        return false;
2445
    }
2446
    if (edgeDataID != v2.edgeDataID) {
2447
        return false;
2448
    }
2449
    if (edgeDataScaling != v2.edgeDataScaling) {
2450
        return false;
2451
    }
2452
    if (edgeValueRainBow != v2.edgeValueRainBow) {
2453
        return false;
2454
    }
2455
    if (!(vehicleColorer == v2.vehicleColorer)) {
2456
        return false;
2457
    }
2458
    if (!(vehicleScaler == v2.vehicleScaler)) {
2459
        return false;
2460
    }
2461
    if (vehicleQuality != v2.vehicleQuality) {
2462
        return false;
2463
    }
2464
    if (vehicleSize != v2.vehicleSize) {
2465
        return false;
2466
    }
2467
    if (vehicleValueRainBow != v2.vehicleValueRainBow) {
2468
        return false;
2469
    }
2470
    if (showBlinker != v2.showBlinker) {
2471
        return false;
2472
    }
2473
    if (drawLaneChangePreference != v2.drawLaneChangePreference) {
2474
        return false;
2475
    }
2476
    if (drawMinGap != v2.drawMinGap) {
2477
        return false;
2478
    }
2479
    if (drawBrakeGap != v2.drawBrakeGap) {
2480
        return false;
2481
    }
2482
    if (showBTRange != v2.showBTRange) {
2483
        return false;
2484
    }
2485
    if (showRouteIndex != v2.showRouteIndex) {
2486
        return false;
2487
    }
2488
    if (scaleLength != v2.scaleLength) {
2489
        return false;
2490
    }
2491
    if (drawReversed != v2.drawReversed) {
2492
        return false;
2493
    }
2494
    if (showParkingInfo != v2.showParkingInfo) {
2495
        return false;
2496
    }
2497
    if (showChargingInfo != v2.showChargingInfo) {
2498
        return false;
2499
    }
2500
    if (vehicleName != v2.vehicleName) {
2501
        return false;
2502
    }
2503
    if (vehicleValue != v2.vehicleValue) {
2504
        return false;
2505
    }
2506
    if (vehicleScaleValue != v2.vehicleScaleValue) {
2507
        return false;
2508
    }
2509
    if (vehicleText != v2.vehicleText) {
2510
        return false;
2511
    }
2512
    if (!(personColorer == v2.personColorer)) {
2513
        return false;
2514
    }
2515
    if (personQuality != v2.personQuality) {
2516
        return false;
2517
    }
2518
    if (personSize != v2.personSize) {
2519
        return false;
2520
    }
2521
    if (personName != v2.personName) {
2522
        return false;
2523
    }
2524
    if (personValue != v2.personValue) {
2525
        return false;
2526
    }
2527
    if (showPedestrianNetwork != v2.showPedestrianNetwork) {
2528
        return false;
2529
    }
2530
    if (pedestrianNetworkColor != v2.pedestrianNetworkColor) {
2531
        return false;
2532
    }
2533
    if (!(containerColorer == v2.containerColorer)) {
2534
        return false;
2535
    }
2536
    if (containerQuality != v2.containerQuality) {
2537
        return false;
2538
    }
2539
    if (containerSize != v2.containerSize) {
2540
        return false;
2541
    }
2542
    if (containerName != v2.containerName) {
2543
        return false;
2544
    }
2545
    if (!(junctionColorer == v2.junctionColorer)) {
2546
        return false;
2547
    }
2548
    if (!(poiColorer == v2.poiColorer)) {
2549
        return false;
2550
    }
2551
    if (!(polyColorer == v2.polyColorer)) {
2552
        return false;
2553
    }
2554
    if (drawLinkTLIndex != v2.drawLinkTLIndex) {
2555
        return false;
2556
    }
2557
    if (drawLinkJunctionIndex != v2.drawLinkJunctionIndex) {
2558
        return false;
2559
    }
2560
    if (junctionID != v2.junctionID) {
2561
        return false;
2562
    }
2563
    if (junctionName != v2.junctionName) {
2564
        return false;
2565
    }
2566
    if (internalJunctionName != v2.internalJunctionName) {
2567
        return false;
2568
    }
2569
    if (tlsPhaseIndex != v2.tlsPhaseIndex) {
2570
        return false;
2571
    }
2572
    if (tlsPhaseName != v2.tlsPhaseName) {
2573
        return false;
2574
    }
2575

2576
    if (showLane2Lane != v2.showLane2Lane) {
2577
        return false;
2578
    }
2579

2580
    if (drawJunctionShape != v2.drawJunctionShape) {
2581
        return false;
2582
    }
2583

2584
    if (drawCrossingsAndWalkingareas != v2.drawCrossingsAndWalkingareas) {
2585
        return false;
2586
    }
2587
    if (junctionSize != v2.junctionSize) {
2588
        return false;
2589
    }
2590
    if (junctionValueRainBow != v2.junctionValueRainBow) {
2591
        return false;
2592
    }
2593

2594
    if (addMode != v2.addMode) {
2595
        return false;
2596
    }
2597
    if (addSize != v2.addSize) {
2598
        return false;
2599
    }
2600
    if (addName != v2.addName) {
2601
        return false;
2602
    }
2603
    if (addFullName != v2.addFullName) {
2604
        return false;
2605
    }
2606
    if (poiSize != v2.poiSize) {
2607
        return false;
2608
    }
2609
    if (poiDetail != v2.poiDetail) {
2610
        return false;
2611
    }
2612
    if (poiName != v2.poiName) {
2613
        return false;
2614
    }
2615
    if (poiType != v2.poiType) {
2616
        return false;
2617
    }
2618
    if (poiText != v2.poiText) {
2619
        return false;
2620
    }
2621
    if (poiTextParam != v2.poiTextParam) {
2622
        return false;
2623
    }
2624
    if (poiUseCustomLayer != v2.poiUseCustomLayer) {
2625
        return false;
2626
    }
2627
    if (poiCustomLayer != v2.poiCustomLayer) {
2628
        return false;
2629
    }
2630
    if (polySize != v2.polySize) {
2631
        return false;
2632
    }
2633
    if (polyName != v2.polyName) {
2634
        return false;
2635
    }
2636
    if (polyType != v2.polyType) {
2637
        return false;
2638
    }
2639
    if (polyUseCustomLayer != v2.polyUseCustomLayer) {
2640
        return false;
2641
    }
2642
    if (polyCustomLayer != v2.polyCustomLayer) {
2643
        return false;
2644
    }
2645

2646
    if (showSizeLegend != v2.showSizeLegend) {
2647
        return false;
2648
    }
2649
    if (showColorLegend != v2.showColorLegend) {
2650
        return false;
2651
    }
2652
    if (showVehicleColorLegend != v2.showVehicleColorLegend) {
2653
        return false;
2654
    }
2655
    if (!(dataColorer == v2.dataColorer)) {
2656
        return false;
2657
    }
2658
    if (!(dataValue == v2.dataValue)) {
2659
        return false;
2660
    }
2661
    if (!(tazRelWidthExaggeration == v2.tazRelWidthExaggeration)) {
2662
        return false;
2663
    }
2664
    if (!(edgeRelWidthExaggeration == v2.edgeRelWidthExaggeration)) {
2665
        return false;
2666
    }
2667
    if (!(relDataAttr == v2.relDataAttr)) {
2668
        return false;
2669
    }
2670
    if (!(dataValueRainBow == v2.dataValueRainBow)) {
2671
        return false;
2672
    }
2673

2674
    return true;
2675
}
2676

2677

2678
const RGBColor&
2679
GUIVisualizationSettings::getLinkColor(const LinkState& ls, bool realistic) {
2680
    switch (ls) {
2681
        case LINKSTATE_TL_GREEN_MAJOR:
2682
            return SUMO_color_TL_GREEN_MAJOR;
2683
        case LINKSTATE_TL_GREEN_MINOR:
2684
            return SUMO_color_TL_GREEN_MINOR;
2685
        case LINKSTATE_TL_RED:
2686
            return SUMO_color_TL_RED;
2687
        case LINKSTATE_TL_REDYELLOW:
2688
            return SUMO_color_TL_REDYELLOW;
2689
        case LINKSTATE_TL_YELLOW_MAJOR:
2690
            return SUMO_color_TL_YELLOW_MAJOR;
2691
        case LINKSTATE_TL_YELLOW_MINOR:
2692
            return SUMO_color_TL_YELLOW_MINOR;
2693
        case LINKSTATE_TL_OFF_BLINKING:
2694
            return SUMO_color_TL_OFF_BLINKING;
2695
        case LINKSTATE_TL_OFF_NOSIGNAL:
2696
            return SUMO_color_TL_OFF_NOSIGNAL;
2697
        case LINKSTATE_MAJOR:
2698
            return realistic ? RGBColor::INVISIBLE : SUMO_color_MAJOR;
2699
        case LINKSTATE_MINOR:
2700
            return realistic ? SUMO_color_MAJOR :  SUMO_color_MINOR;
2701
        case LINKSTATE_EQUAL:
2702
            return SUMO_color_EQUAL;
2703
        case LINKSTATE_STOP:
2704
            return realistic ? SUMO_color_MAJOR : SUMO_color_STOP;
2705
        case LINKSTATE_ALLWAY_STOP:
2706
            return realistic ? SUMO_color_MAJOR : SUMO_color_ALLWAY_STOP;
2707
        case LINKSTATE_ZIPPER:
2708
            return realistic ? RGBColor::INVISIBLE : SUMO_color_ZIPPER;
2709
        case LINKSTATE_DEADEND:
2710
            return SUMO_color_DEADEND;
2711
        default:
2712
            throw ProcessError(TLF("No color defined for LinkState '%'", std::string(ls, 1)));
2713
    }
2714
}
2715

2716

2717
double
2718
GUIVisualizationSettings::getTextAngle(double objectAngle) const {
2719
    double viewAngle = objectAngle - angle;
2720
    while (viewAngle < 0) {
2721
        viewAngle += 360;
2722
    }
2723
    // fmod round towards zero which is not want we want for negative numbers
2724
    viewAngle = fmod(viewAngle, 360);
2725
    if (viewAngle > 90 && viewAngle < 270) {
2726
        // avoid reading text on its head
2727
        objectAngle -= 180;
2728
    }
2729
    return objectAngle;
2730
}
2731

2732

2733
bool
2734
GUIVisualizationSettings::flippedTextAngle(double objectAngle) const {
2735
    double viewAngle = objectAngle - angle;
2736
    while (viewAngle < 0) {
2737
        viewAngle += 360;
2738
    }
2739
    // fmod round towards zero which is not want we want for negative numbers
2740
    viewAngle = fmod(viewAngle, 360);
2741
    return (viewAngle > 90 && viewAngle < 270);
2742
}
2743

2744

2745
GUIVisualizationSettings::Detail
2746
GUIVisualizationSettings::getDetailLevel(const double exaggeration) const {
2747
    // calculate factor
2748
    const auto factor = (scale * exaggeration);
2749
    if (factor >= 10) {
2750
        return GUIVisualizationSettings::Detail::Level0;
2751
    } else if (factor >= 5) {
2752
        return GUIVisualizationSettings::Detail::Level1;
2753
    } else if (factor >= 2.5) {
2754
        return GUIVisualizationSettings::Detail::Level2;
2755
    } else if (factor >= 1.25) {
2756
        return GUIVisualizationSettings::Detail::Level3;
2757
    } else {
2758
        return GUIVisualizationSettings::Detail::Level4;
2759
    }
2760
}
2761

2762

2763
bool
2764
GUIVisualizationSettings::drawDetail(const double detail, const double exaggeration) const {
2765
    if (detail <= 0) {
2766
        return true;
2767
    } else {
2768
        return ((scale * exaggeration) >= detail);
2769
    }
2770
}
2771

2772

2773
bool
2774
GUIVisualizationSettings::drawMovingGeometryPoint(const double exaggeration, const double radius) const {
2775
    return (scale * radius * exaggeration > 10);
2776
}
2777

2778
/****************************************************************************/
2779

2780
Product

Resources

Company
