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-2026 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
    relDataScaleAttr("count"),
656
    dataValueRainBow(false, -100, false, 100, false, 0, false, 1),
657
    ignoreColorSchemeFor3DVehicles(false),
658
    show3DTLSLinkMarkers(true),
659
    show3DTLSDomes(true),
660
    generate3DTLSModels(false),
661
    show3DHeadUpDisplay(true),
662
    ambient3DLight(OSG_color_AMBIENT),
663
    diffuse3DLight(OSG_color_DIFFUSE),
664
    skyColor(OSG_color_SKY),
665
    showSizeLegend(true),
666
    showColorLegend(false),
667
    showVehicleColorLegend(false),
668
    gaming(false),
669
    drawBoundaries(false),
670
    selectorFrameScale(1.),
671
    drawForViewObjectsHandler(false),
672
    drawForRectangleSelection(false),
673
    forceDrawForRectangleSelection(false),
674
    disableDottedContours(false),
675
    geometryIndices(false, 50, RGBColor(255, 0, 128, 255)),
676
    secondaryShape(false),
677
    lefthand(false),
678
    disableLaneIcons(false),
679
    myIgnoreHideByZoom(false) {
680
    // init defaults depending of netedit or SUMO-GUI
681
    if (netedit) {
682
        initNeteditDefaults();
683
    } else {
684
        initSumoGuiDefaults();
685
    }
686
}
687

688

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

716

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

731

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

821

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

841

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

861

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

885

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

909

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

929

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

947

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

954

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

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

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

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

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

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

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

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

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

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

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

1830

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

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

1873
    scheme = GUIColorScheme("by lane number (streetwise)", TL("by lane number (streetwise)"), RGBColor::RED);
1874
    scheme.addColor(RGBColor::BLUE, 5.);
1875
    laneColorer.addScheme(scheme);
1876

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

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

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

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

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

1989
    /// add edge scaling schemes
1990
    {
1991
        GUIScaleScheme edgeScheme = GUIScaleScheme(TL("default"), 1, TL("uniform"), true);
1992
        laneScaler.addScheme(edgeScheme);
1993
    }
1994

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

2006
    /// add data scaling schemes
2007
    dataScaler.addScheme(GUIScaleScheme(TL("uniform"), 1, "", true));
2008
    GUIScaleScheme dataScheme = GUIScaleScheme(SCHEME_NAME_SELECTION, TL(SCHEME_NAME_SELECTION.c_str()), 1, TL("unselected"), true, 0, COL_SCHEME_MISC);
2009
    dataScheme.addColor(5, 1., TL("selected"));
2010
    dataScaler.addScheme(dataScheme);
2011
    dataScheme = GUIScaleScheme(SCHEME_NAME_DATA_ATTRIBUTE_NUMERICAL, TL(SCHEME_NAME_DATA_ATTRIBUTE_NUMERICAL.c_str()), 1, TL("missing data"), false, MISSING_DATA);
2012
    dataScheme.setAllowsNegativeValues(true);
2013
    dataScheme.addColor(1, 1);
2014
    dataScheme.addColor(5, 100);
2015
    dataScheme.addColor(10, 1000);
2016
    dataScheme.addColor(20, 10000);
2017
    dataScheme.addColor(30, 100000);
2018
    dataScaler.addScheme(dataScheme);
2019

2020
    // dummy schemes
2021
    vehicleColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::YELLOW, "", true));
2022
    personColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::YELLOW, "", true));
2023
    containerColorer.addScheme(GUIColorScheme("uniform", TL("uniform"), RGBColor::YELLOW, "", true));
2024
    vehicleScaler.addScheme(GUIScaleScheme(TL("uniform"), 1, "", true));
2025
}
2026

2027

2028
int
2029
GUIVisualizationSettings::getLaneEdgeMode() const {
2030
    if (UseMesoSim) {
2031
        return edgeColorer.getActive();
2032
    }
2033
    return laneColorer.getActive();
2034
}
2035

2036

2037
int
2038
GUIVisualizationSettings::getLaneEdgeScaleMode() const {
2039
    if (UseMesoSim) {
2040
        return edgeScaler.getActive();
2041
    }
2042
    return laneScaler.getActive();
2043
}
2044

2045

2046
GUIColorScheme&
2047
GUIVisualizationSettings::getLaneEdgeScheme() {
2048
    if (UseMesoSim) {
2049
        return edgeColorer.getScheme();
2050
    }
2051
    return laneColorer.getScheme();
2052
}
2053

2054

2055
GUIScaleScheme&
2056
GUIVisualizationSettings::getLaneEdgeScaleScheme() {
2057
    if (UseMesoSim) {
2058
        return edgeScaler.getScheme();
2059
    }
2060
    return laneScaler.getScheme();
2061
}
2062

2063

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

2326
    dev.closeTag();
2327
}
2328

2329

2330
bool
2331
GUIVisualizationSettings::operator==(const GUIVisualizationSettings& v2) {
2332
    if (ignoreColorSchemeFor3DVehicles != v2.ignoreColorSchemeFor3DVehicles) {
2333
        return false;
2334
    }
2335
    if (show3DTLSDomes != v2.show3DTLSDomes) {
2336
        return false;
2337
    }
2338
    if (show3DTLSLinkMarkers != v2.show3DTLSLinkMarkers) {
2339
        return false;
2340
    }
2341
    if (show3DHeadUpDisplay != v2.show3DHeadUpDisplay) {
2342
        return false;
2343
    }
2344
    if (generate3DTLSModels != v2.generate3DTLSModels) {
2345
        return false;
2346
    }
2347
    if (ambient3DLight != v2.ambient3DLight) {
2348
        return false;
2349
    }
2350
    if (diffuse3DLight != v2.diffuse3DLight) {
2351
        return false;
2352
    }
2353
    if (skyColor != v2.skyColor) {
2354
        return false;
2355
    }
2356
    if (dither != v2.dither) {
2357
        return false;
2358
    }
2359
    if (fps != v2.fps) {
2360
        return false;
2361
    }
2362
    if (trueZ != v2.trueZ) {
2363
        return false;
2364
    }
2365
    if (drawBoundaries != v2.drawBoundaries) {
2366
        return false;
2367
    }
2368
    if (disableDottedContours != v2.disableDottedContours) {
2369
        return false;
2370
    }
2371
    if (forceDrawForRectangleSelection != v2.forceDrawForRectangleSelection) {
2372
        return false;
2373
    }
2374
    if (geometryIndices != v2.geometryIndices) {
2375
        return false;
2376
    }
2377
    if (backgroundColor != v2.backgroundColor) {
2378
        return false;
2379
    }
2380
    if (colorSettings != v2.colorSettings) {
2381
        return false;
2382
    }
2383
    if (showGrid != v2.showGrid) {
2384
        return false;
2385
    }
2386
    if (gridXSize != v2.gridXSize) {
2387
        return false;
2388
    }
2389
    if (gridYSize != v2.gridYSize) {
2390
        return false;
2391
    }
2392

2393
    if (!(edgeColorer == v2.edgeColorer)) {
2394
        return false;
2395
    }
2396
    if (!(edgeScaler == v2.edgeScaler)) {
2397
        return false;
2398
    }
2399
    if (!(laneColorer == v2.laneColorer)) {
2400
        return false;
2401
    }
2402
    if (!(laneScaler == v2.laneScaler)) {
2403
        return false;
2404
    }
2405
    if (laneShowBorders != v2.laneShowBorders) {
2406
        return false;
2407
    }
2408
    if (showBikeMarkings != v2.showBikeMarkings) {
2409
        return false;
2410
    }
2411
    if (showLinkDecals != v2.showLinkDecals) {
2412
        return false;
2413
    }
2414
    if (realisticLinkRules != v2.realisticLinkRules) {
2415
        return false;
2416
    }
2417
    if (showLinkRules != v2.showLinkRules) {
2418
        return false;
2419
    }
2420
    if (showRails != v2.showRails) {
2421
        return false;
2422
    }
2423
    if (secondaryShape != v2.secondaryShape) {
2424
        return false;
2425
    }
2426
    if (edgeName != v2.edgeName) {
2427
        return false;
2428
    }
2429
    if (internalEdgeName != v2.internalEdgeName) {
2430
        return false;
2431
    }
2432
    if (cwaEdgeName != v2.cwaEdgeName) {
2433
        return false;
2434
    }
2435
    if (streetName != v2.streetName) {
2436
        return false;
2437
    }
2438
    if (edgeValue != v2.edgeValue) {
2439
        return false;
2440
    }
2441
    if (edgeScaleValue != v2.edgeScaleValue) {
2442
        return false;
2443
    }
2444
    if (hideConnectors != v2.hideConnectors) {
2445
        return false;
2446
    }
2447
    if (laneWidthExaggeration != v2.laneWidthExaggeration) {
2448
        return false;
2449
    }
2450
    if (laneMinSize != v2.laneMinSize) {
2451
        return false;
2452
    }
2453
    if (showLaneDirection != v2.showLaneDirection) {
2454
        return false;
2455
    }
2456
    if (showSublanes != v2.showSublanes) {
2457
        return false;
2458
    }
2459
    if (spreadSuperposed != v2.spreadSuperposed) {
2460
        return false;
2461
    }
2462
    if (disableHideByZoom != v2.disableHideByZoom) {
2463
        return false;
2464
    }
2465
    if (edgeParam != v2.edgeParam) {
2466
        return false;
2467
    }
2468
    if (laneParam != v2.laneParam) {
2469
        return false;
2470
    }
2471
    if (vehicleParam != v2.vehicleParam) {
2472
        return false;
2473
    }
2474
    if (vehicleScaleParam != v2.vehicleScaleParam) {
2475
        return false;
2476
    }
2477
    if (vehicleTextParam != v2.vehicleTextParam) {
2478
        return false;
2479
    }
2480
    if (edgeData != v2.edgeData) {
2481
        return false;
2482
    }
2483
    if (edgeDataID != v2.edgeDataID) {
2484
        return false;
2485
    }
2486
    if (edgeDataScaling != v2.edgeDataScaling) {
2487
        return false;
2488
    }
2489
    if (edgeValueRainBow != v2.edgeValueRainBow) {
2490
        return false;
2491
    }
2492
    if (!(vehicleColorer == v2.vehicleColorer)) {
2493
        return false;
2494
    }
2495
    if (!(vehicleScaler == v2.vehicleScaler)) {
2496
        return false;
2497
    }
2498
    if (vehicleQuality != v2.vehicleQuality) {
2499
        return false;
2500
    }
2501
    if (vehicleSize != v2.vehicleSize) {
2502
        return false;
2503
    }
2504
    if (vehicleValueRainBow != v2.vehicleValueRainBow) {
2505
        return false;
2506
    }
2507
    if (showBlinker != v2.showBlinker) {
2508
        return false;
2509
    }
2510
    if (drawLaneChangePreference != v2.drawLaneChangePreference) {
2511
        return false;
2512
    }
2513
    if (drawMinGap != v2.drawMinGap) {
2514
        return false;
2515
    }
2516
    if (drawBrakeGap != v2.drawBrakeGap) {
2517
        return false;
2518
    }
2519
    if (showBTRange != v2.showBTRange) {
2520
        return false;
2521
    }
2522
    if (showRouteIndex != v2.showRouteIndex) {
2523
        return false;
2524
    }
2525
    if (scaleLength != v2.scaleLength) {
2526
        return false;
2527
    }
2528
    if (drawReversed != v2.drawReversed) {
2529
        return false;
2530
    }
2531
    if (showParkingInfo != v2.showParkingInfo) {
2532
        return false;
2533
    }
2534
    if (showChargingInfo != v2.showChargingInfo) {
2535
        return false;
2536
    }
2537
    if (vehicleName != v2.vehicleName) {
2538
        return false;
2539
    }
2540
    if (vehicleValue != v2.vehicleValue) {
2541
        return false;
2542
    }
2543
    if (vehicleScaleValue != v2.vehicleScaleValue) {
2544
        return false;
2545
    }
2546
    if (vehicleText != v2.vehicleText) {
2547
        return false;
2548
    }
2549
    if (!(personColorer == v2.personColorer)) {
2550
        return false;
2551
    }
2552
    if (personQuality != v2.personQuality) {
2553
        return false;
2554
    }
2555
    if (personSize != v2.personSize) {
2556
        return false;
2557
    }
2558
    if (personName != v2.personName) {
2559
        return false;
2560
    }
2561
    if (personValue != v2.personValue) {
2562
        return false;
2563
    }
2564
    if (showPedestrianNetwork != v2.showPedestrianNetwork) {
2565
        return false;
2566
    }
2567
    if (pedestrianNetworkColor != v2.pedestrianNetworkColor) {
2568
        return false;
2569
    }
2570
    if (!(containerColorer == v2.containerColorer)) {
2571
        return false;
2572
    }
2573
    if (containerQuality != v2.containerQuality) {
2574
        return false;
2575
    }
2576
    if (containerSize != v2.containerSize) {
2577
        return false;
2578
    }
2579
    if (containerName != v2.containerName) {
2580
        return false;
2581
    }
2582
    if (!(junctionColorer == v2.junctionColorer)) {
2583
        return false;
2584
    }
2585
    if (!(poiColorer == v2.poiColorer)) {
2586
        return false;
2587
    }
2588
    if (!(polyColorer == v2.polyColorer)) {
2589
        return false;
2590
    }
2591
    if (drawLinkTLIndex != v2.drawLinkTLIndex) {
2592
        return false;
2593
    }
2594
    if (drawLinkJunctionIndex != v2.drawLinkJunctionIndex) {
2595
        return false;
2596
    }
2597
    if (junctionID != v2.junctionID) {
2598
        return false;
2599
    }
2600
    if (junctionName != v2.junctionName) {
2601
        return false;
2602
    }
2603
    if (internalJunctionName != v2.internalJunctionName) {
2604
        return false;
2605
    }
2606
    if (tlsPhaseIndex != v2.tlsPhaseIndex) {
2607
        return false;
2608
    }
2609
    if (tlsPhaseName != v2.tlsPhaseName) {
2610
        return false;
2611
    }
2612

2613
    if (showLane2Lane != v2.showLane2Lane) {
2614
        return false;
2615
    }
2616

2617
    if (drawJunctionShape != v2.drawJunctionShape) {
2618
        return false;
2619
    }
2620

2621
    if (drawCrossingsAndWalkingareas != v2.drawCrossingsAndWalkingareas) {
2622
        return false;
2623
    }
2624
    if (junctionSize != v2.junctionSize) {
2625
        return false;
2626
    }
2627
    if (junctionValueRainBow != v2.junctionValueRainBow) {
2628
        return false;
2629
    }
2630

2631
    if (addMode != v2.addMode) {
2632
        return false;
2633
    }
2634
    if (addSize != v2.addSize) {
2635
        return false;
2636
    }
2637
    if (addName != v2.addName) {
2638
        return false;
2639
    }
2640
    if (addFullName != v2.addFullName) {
2641
        return false;
2642
    }
2643
    if (poiSize != v2.poiSize) {
2644
        return false;
2645
    }
2646
    if (poiDetail != v2.poiDetail) {
2647
        return false;
2648
    }
2649
    if (poiName != v2.poiName) {
2650
        return false;
2651
    }
2652
    if (poiType != v2.poiType) {
2653
        return false;
2654
    }
2655
    if (poiText != v2.poiText) {
2656
        return false;
2657
    }
2658
    if (poiTextParam != v2.poiTextParam) {
2659
        return false;
2660
    }
2661
    if (poiUseCustomLayer != v2.poiUseCustomLayer) {
2662
        return false;
2663
    }
2664
    if (poiCustomLayer != v2.poiCustomLayer) {
2665
        return false;
2666
    }
2667
    if (polySize != v2.polySize) {
2668
        return false;
2669
    }
2670
    if (polyName != v2.polyName) {
2671
        return false;
2672
    }
2673
    if (polyType != v2.polyType) {
2674
        return false;
2675
    }
2676
    if (polyUseCustomLayer != v2.polyUseCustomLayer) {
2677
        return false;
2678
    }
2679
    if (polyCustomLayer != v2.polyCustomLayer) {
2680
        return false;
2681
    }
2682

2683
    if (showSizeLegend != v2.showSizeLegend) {
2684
        return false;
2685
    }
2686
    if (showColorLegend != v2.showColorLegend) {
2687
        return false;
2688
    }
2689
    if (showVehicleColorLegend != v2.showVehicleColorLegend) {
2690
        return false;
2691
    }
2692
    if (!(dataColorer == v2.dataColorer)) {
2693
        return false;
2694
    }
2695
    if (!(dataScaler == v2.dataScaler)) {
2696
        return false;
2697
    }
2698
    if (!(dataValue == v2.dataValue)) {
2699
        return false;
2700
    }
2701
    if (!(tazRelWidthExaggeration == v2.tazRelWidthExaggeration)) {
2702
        return false;
2703
    }
2704
    if (!(edgeRelWidthExaggeration == v2.edgeRelWidthExaggeration)) {
2705
        return false;
2706
    }
2707
    if (!(relDataAttr == v2.relDataAttr)) {
2708
        return false;
2709
    }
2710
    if (!(relDataScaleAttr == v2.relDataScaleAttr)) {
2711
        return false;
2712
    }
2713
    if (!(dataValueRainBow == v2.dataValueRainBow)) {
2714
        return false;
2715
    }
2716

2717
    return true;
2718
}
2719

2720

2721
const RGBColor&
2722
GUIVisualizationSettings::getLinkColor(const LinkState& ls, bool realistic) {
2723
    switch (ls) {
2724
        case LINKSTATE_TL_GREEN_MAJOR:
2725
            return SUMO_color_TL_GREEN_MAJOR;
2726
        case LINKSTATE_TL_GREEN_MINOR:
2727
            return SUMO_color_TL_GREEN_MINOR;
2728
        case LINKSTATE_TL_RED:
2729
            return SUMO_color_TL_RED;
2730
        case LINKSTATE_TL_REDYELLOW:
2731
            return SUMO_color_TL_REDYELLOW;
2732
        case LINKSTATE_TL_YELLOW_MAJOR:
2733
            return SUMO_color_TL_YELLOW_MAJOR;
2734
        case LINKSTATE_TL_YELLOW_MINOR:
2735
            return SUMO_color_TL_YELLOW_MINOR;
2736
        case LINKSTATE_TL_OFF_BLINKING:
2737
            return SUMO_color_TL_OFF_BLINKING;
2738
        case LINKSTATE_TL_OFF_NOSIGNAL:
2739
            return SUMO_color_TL_OFF_NOSIGNAL;
2740
        case LINKSTATE_MAJOR:
2741
            return realistic ? RGBColor::INVISIBLE : SUMO_color_MAJOR;
2742
        case LINKSTATE_MINOR:
2743
            return realistic ? SUMO_color_MAJOR :  SUMO_color_MINOR;
2744
        case LINKSTATE_EQUAL:
2745
            return SUMO_color_EQUAL;
2746
        case LINKSTATE_STOP:
2747
            return realistic ? SUMO_color_MAJOR : SUMO_color_STOP;
2748
        case LINKSTATE_ALLWAY_STOP:
2749
            return realistic ? SUMO_color_MAJOR : SUMO_color_ALLWAY_STOP;
2750
        case LINKSTATE_ZIPPER:
2751
            return realistic ? RGBColor::INVISIBLE : SUMO_color_ZIPPER;
2752
        case LINKSTATE_DEADEND:
2753
            return SUMO_color_DEADEND;
2754
        default:
2755
            throw ProcessError(TLF("No color defined for LinkState '%'", std::string(ls, 1)));
2756
    }
2757
}
2758

2759

2760
double
2761
GUIVisualizationSettings::getTextAngle(double objectAngle) const {
2762
    double viewAngle = objectAngle - angle;
2763
    while (viewAngle < 0) {
2764
        viewAngle += 360;
2765
    }
2766
    // fmod round towards zero which is not want we want for negative numbers
2767
    viewAngle = fmod(viewAngle, 360);
2768
    if (viewAngle > 90 && viewAngle < 270) {
2769
        // avoid reading text on its head
2770
        objectAngle -= 180;
2771
    }
2772
    return objectAngle;
2773
}
2774

2775

2776
bool
2777
GUIVisualizationSettings::flippedTextAngle(double objectAngle) const {
2778
    double viewAngle = objectAngle - angle;
2779
    while (viewAngle < 0) {
2780
        viewAngle += 360;
2781
    }
2782
    // fmod round towards zero which is not want we want for negative numbers
2783
    viewAngle = fmod(viewAngle, 360);
2784
    return (viewAngle > 90 && viewAngle < 270);
2785
}
2786

2787

2788
GUIVisualizationSettings::Detail
2789
GUIVisualizationSettings::getDetailLevel(const double exaggeration) const {
2790
    // calculate factor
2791
    const auto factor = (scale * exaggeration);
2792
    if (factor >= 10) {
2793
        return GUIVisualizationSettings::Detail::Level0;
2794
    } else if (factor >= 5) {
2795
        return GUIVisualizationSettings::Detail::Level1;
2796
    } else if (factor >= 2.5) {
2797
        return GUIVisualizationSettings::Detail::Level2;
2798
    } else if (factor >= 1.25) {
2799
        return GUIVisualizationSettings::Detail::Level3;
2800
    } else {
2801
        return GUIVisualizationSettings::Detail::Level4;
2802
    }
2803
}
2804

2805

2806
bool
2807
GUIVisualizationSettings::drawDetail(const double detail, const double exaggeration) const {
2808
    if (detail <= 0) {
2809
        return true;
2810
    } else {
2811
        return ((scale * exaggeration) >= detail);
2812
    }
2813
}
2814

2815

2816
bool
2817
GUIVisualizationSettings::drawMovingGeometryPoint(const double exaggeration, const double radius) const {
2818
    return (scale * radius * exaggeration > 10);
2819
}
2820

2821
/****************************************************************************/
2822

2823
Product

Resources

Company
