GUIVisualizationSettings.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2025 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Stores the information about how to visualize structures
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <vector>
#include <map>
#include <utils/common/RGBColor.h>
#include <utils/common/ToString.h>
 
#include "GUIPropertySchemeStorage.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class BaseSchemeInfoSource;
class OutputDevice;
class GUIVisualizationSettings;
class GUIGlObject;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
 
// cannot declare this as inner class because it needs to be used in forward
// declaration (@todo fix inclusion order by removing references to guisim!)
struct GUIVisualizationTextSettings {
 
    GUIVisualizationTextSettings(bool _show, double _size, RGBColor _color, RGBColor _bgColor = RGBColor(128, 0, 0, 0), bool _constSize = true, bool _onlySelected = false);
 
    bool operator==(const GUIVisualizationTextSettings& other);
 
    bool operator!=(const GUIVisualizationTextSettings& other);
 
    void print(OutputDevice& dev, const std::string& name) const;
 
    double scaledSize(double scale, double constFactor = 0.1) const;
 
    bool show(const GUIGlObject* o) const;
 
    bool showText;
 
    double size;
 
    RGBColor color;
 
    RGBColor bgColor;
 
    bool constSize;
 
    bool onlySelected;
};
struct GUIVisualizationTextSettings {…};
 
 
struct GUIVisualizationRainbowSettings {
 
    GUIVisualizationRainbowSettings(bool _hideMin, double _minThreshold, bool _hideMax, double _maxThreshold, bool _setNeutral,
                                    double _neutralThreshold, bool _fixRange, int _rainboScheme);
 
    bool operator==(const GUIVisualizationRainbowSettings& other);
 
    bool operator!=(const GUIVisualizationRainbowSettings& other);
 
    void print(OutputDevice& dev, const std::string& name) const;
 
    bool hideMin;
    double minThreshold;
    bool hideMax;
    double maxThreshold;
    bool setNeutral;
    double neutralThreshold;
    bool fixRange;
    int rainbowScheme;
    std::vector<RGBColor> colors;
};
struct GUIVisualizationRainbowSettings {…};
 
 
struct GUIVisualizationSizeSettings {
 
    GUIVisualizationSizeSettings(double _minSize, double _exaggeration = 1.0, bool _constantSize = false, bool _constantSizeSelected = false);
 
    double getExaggeration(const GUIVisualizationSettings& s, const GUIGlObject* o, double factor = 20) const;
 
    bool operator==(const GUIVisualizationSizeSettings& other);
 
    bool operator!=(const GUIVisualizationSizeSettings& other);
 
    void print(OutputDevice& dev, const std::string& name) const;
 
    double minSize;
 
    double exaggeration;
 
    bool constantSize;
 
    bool constantSizeSelected;
};
struct GUIVisualizationSizeSettings {…};
 
 
struct GUIVisualizationColorSettings {
 
    GUIVisualizationColorSettings();
 
    bool operator==(const GUIVisualizationColorSettings& other);
 
    bool operator!=(const GUIVisualizationColorSettings& other);
 
    RGBColor selectionColor;
 
    RGBColor selectedEdgeColor;
 
    RGBColor selectedLaneColor;
 
    RGBColor selectedConnectionColor;
 
    RGBColor selectedProhibitionColor;
 
    RGBColor selectedCrossingColor;
 
    RGBColor selectedAdditionalColor;
 
    RGBColor selectedRouteColor;
 
    RGBColor selectedVehicleColor;
 
    RGBColor selectedPersonColor;
 
    RGBColor selectedPersonPlanColor;
 
    RGBColor selectedContainerColor;
 
    RGBColor selectedContainerPlanColor;
 
    RGBColor selectedEdgeDataColor;
 
    RGBColor busStopColor;
 
    RGBColor busStopColorSign;
 
    RGBColor trainStopColor;
 
    RGBColor trainStopColorSign;
 
    RGBColor containerStopColor;
 
    RGBColor containerStopColorSign;
 
    RGBColor chargingStationColor;
 
    RGBColor chargingStationColorSign;
 
    RGBColor chargingStationColorCharge;
 
    RGBColor parkingAreaColor;
 
    RGBColor parkingAreaColorSign;
 
    RGBColor parkingSpaceColorContour;
 
    RGBColor parkingSpaceColor;
 
    RGBColor stopColor;
 
    RGBColor waypointColor;
 
    RGBColor vehicleTripColor;
 
    RGBColor stopPersonColor;
 
    RGBColor personTripColor;
 
    RGBColor walkColor;
 
    RGBColor rideColor;
 
    RGBColor stopContainerColor;
 
    RGBColor transportColor;
 
    RGBColor transhipColor;
 
    static const RGBColor SUMO_color_DEADEND_SHOW;
 
    static const RGBColor childConnectionColor;
 
    static const RGBColor editShapeColor;
 
    static const RGBColor crossingColor;
 
    static const RGBColor crossingPriorityColor;
 
    static const RGBColor crossingInvalidColor;
 
};
struct GUIVisualizationColorSettings {…};
 
 
struct GUIVisualizationCandidateColorSettings {
 
    static const RGBColor possible;
 
    static const RGBColor source;
 
    static const RGBColor target;
 
    static const RGBColor special;
 
    static const RGBColor conflict;
 
    static const RGBColor invalid;
};
struct GUIVisualizationCandidateColorSettings {…};
 
struct GUIVisualizationNeteditSizeSettings {
 
    static const double junctionBubbleRadius;
 
    static const double junctionGeometryPointRadius;
 
    static const double edgeGeometryPointRadius;
 
    static const double laneGeometryPointRadius;
 
    static const double connectionGeometryPointRadius;
 
    static const double crossingGeometryPointRadius;
 
    static const double polygonGeometryPointRadius;
 
    static const double polygonContourWidth;
 
    static const double polylineWidth;
 
    static const double additionalGeometryPointRadius;
};
struct GUIVisualizationNeteditSizeSettings {…};
 
struct GUIVisualizationConnectionSettings {
 
    static const double connectionWidth;
};
struct GUIVisualizationConnectionSettings {…};
 
 
struct GUIVisualizationAdditionalSettings {
 
    static const RGBColor rerouterColor;
 
    static const double rerouterSize;
 
    static const RGBColor VSSColor;
 
    static const double VSSSize;
 
    static const RGBColor calibratorColor;
 
    static const double calibratorWidth;
 
    static const double calibratorHeight;
 
    static const RGBColor routeProbeColor;
 
    static const double routeProbeSize;
 
    static const RGBColor vaporizerColor;
 
    static const double vaporizerSize;
 
    static const double stopEdgeSize;
 
    static const RGBColor connectionColor;
 
    static const RGBColor connectionColorSelected;
 
    static const double tractionSubstationSize;
 
    static const RGBColor overheadWireColorTop;
 
    static const RGBColor overheadWireColorBot;
 
    static const RGBColor overheadWireColorSelected;
 
    static const double arrowWidth;
 
    static const double arrowLength;
 
    static const double arrowOffset;
 
    static const RGBColor TLSConnectionColor;
};
struct GUIVisualizationAdditionalSettings {…};
 
 
struct GUIVisualizationDetectorSettings {
 
    static const RGBColor E1Color;
 
    static const double E1Width;
 
    static const double E1Height;
 
    static const RGBColor E1InstantColor;
 
    static const double E1InstantWidth;
 
    static const double E1InstantHeight;
 
    static const RGBColor E2Color;
 
    static const double E2Width;
 
    static const double E3Size;
 
    static const RGBColor E3EntryColor;
 
    static const RGBColor E3ExitColor;
 
    static const double E3EntryExitWidth;
 
    static const double E3EntryExitHeight;
};
struct GUIVisualizationDetectorSettings {…};
 
 
struct GUIVisualizationStoppingPlaceSettings {
    static const double stoppingPlaceSignOffset;
 
    static const double busStopWidth;
 
    static const double trainStopWidth;
 
    static const double containerStopWidth;
 
    static const double chargingStationWidth;
 
    static const double symbolExternalRadius;
 
    static const double symbolInternalRadius;
 
    static const double symbolInternalTextSize;
};
struct GUIVisualizationStoppingPlaceSettings {…};
 
 
struct GUIVisualizationDottedContourSettings {
 
    static const double segmentWidth;
 
    static const double segmentWidthSmall;
 
    static const double segmentWidthLarge;
 
    static const double segmentLength;
 
    static const RGBColor firstInspectedColor;
 
    static const RGBColor secondInspectedColor;
 
    static const RGBColor firstFrontColor;
 
    static const RGBColor secondFrontColor;
};
struct GUIVisualizationDottedContourSettings {…};
 
 
struct GUIVisualizationWidthSettings {
 
    GUIVisualizationWidthSettings();
 
    bool operator==(const GUIVisualizationWidthSettings& other);
 
    bool operator!=(const GUIVisualizationWidthSettings& other);
 
    double tripWidth;
 
    double personTripWidth;
 
    double walkWidth;
 
    double rideWidth;
 
    double transportWidth;
 
    double transhipWidth;
 
    static const double routeWidth;
 
    static const double embeddedRouteWidth;
};
struct GUIVisualizationWidthSettings {…};
 
 
struct GUIVisualizationDetailSettings {
 
    static const double tmp;
};
struct GUIVisualizationDetailSettings {…};
 
 
class GUIVisualizationSettings {
 
public:
 
    enum class Detail : int {
        Level0 = 0,
        CircleResolution32 = 0,     // circle resolution = 32
        DrawPolygonTesselation = 0, // draw polygons tesselated
        LaneDetails = 0,            // offset, icons, indicators...
        Text = 0,                   // draw text (E2, routes...)
        VehiclePoly = 0,            // draw vehicles as polygons
        JunctionElementDetails = 0, // draw junction elements with high detail (crossings, connections..)
        LockedIcons = 0,            // draw lock icons
 
        Level1 = 1,
        CircleResolution16 = 1,         // circle resolution = 16
        VehicleBox = 1,                 // vehicles as boxes
        AdditionalDetails = 1,          // stoppingPlace signs, EntryExit arrows...
        GeometryPoint = 1,              // draw geometry points
        JunctionElement = 1,            // crossings, walking area, connections and internal lanes
        DottedContoursResampled = 1,    // resample dotted contours
        PreciseSelection = 1,           // precise selection using boundaries
        DottedContours = 1,             // draw dotted contours
 
        Level2 = 2,
        CircleResolution8 = 2,  // circle resolution = 8
        DrawPolygonSquare = 2,  // draw polygons as squares
        VehicleTriangle = 2,    // draw vehicles as triangles
        Additionals = 2,        // draw additional elements
        GeometryBoxLines = 2,   // draw lines instead boxes in GUIGeometry::drawGeometry
 
        Level3 = 3,
        CircleResolution4 = 3,  // draw circle resolution as squares
        TLSIcon = 3,            // draw TLS icons
 
        Level4 = 4,
        GeometryBoxSimpleLine = 4,  // draw lines with width = 1 instead boxes in GUIGeometry::drawGeometry
    };
    enum class Detail : int {…};
 
    GUIVisualizationSettings(const std::string& _name, bool _netedit = false);
 
    bool checkDrawJunction(const Boundary& b, const bool selected) const;
 
    bool checkDrawEdge(const Boundary& b) const;
 
    void updateIgnoreHideByZoom();
 
    bool checkDrawAdditional(Detail d, const bool selected) const;
 
    bool checkDrawPoly(const Boundary& b, const bool selected) const;
 
    bool checkDrawPOI(const double w, const double h, const Detail d, const bool selected) const;
 
    bool checkDrawVehicle(Detail d, const bool selected) const;
 
    bool checkDrawPerson(Detail d, const bool selected) const;
 
    bool checkDrawContainer(Detail d, const bool selected) const;
 
    void copy(const GUIVisualizationSettings& s);
 
    void initNeteditDefaults();
    void initSumoGuiDefaults();
 
    void save(OutputDevice& dev) const;
 
    int getLaneEdgeMode() const;
 
    int getLaneEdgeScaleMode() const;
 
    GUIColorScheme& getLaneEdgeScheme();
 
    GUIScaleScheme& getLaneEdgeScaleScheme();
 
    bool operator==(const GUIVisualizationSettings& vs2);
 
    static const RGBColor& getLinkColor(const LinkState& ls, bool realistic = false);
 
    double getTextAngle(double objectAngle) const;
 
    bool flippedTextAngle(double objectAngle) const;
 
    Detail getDetailLevel(const double exaggeration) const;
 
    bool drawDetail(const double detail, const double exaggeration) const;
 
    bool drawMovingGeometryPoint(const double exaggeration, const double radius) const;
 
    std::string name;
 
    bool netedit;
 
    double angle;
 
    bool dither;
 
    bool fps;
 
    bool trueZ;
 
 
    RGBColor backgroundColor;
 
    bool showGrid;
 
    double gridXSize, gridYSize;
 
 
    GUIColorer edgeColorer;
 
    GUIScaler edgeScaler;
 
    static bool UseMesoSim;
 
    GUIColorer laneColorer;
 
    GUIScaler laneScaler;
 
    bool laneShowBorders;
 
    bool showBikeMarkings;
 
    bool showLinkDecals;
 
    bool realisticLinkRules;
 
    bool showLinkRules;
 
    bool showRails;
 
    GUIVisualizationTextSettings edgeName, internalEdgeName, cwaEdgeName, streetName, edgeValue, edgeScaleValue;
 
    bool hideConnectors;
 
    double laneWidthExaggeration;
 
    double laneMinSize;
 
    bool showLaneDirection;
 
    bool showSublanes;
 
    bool spreadSuperposed;
 
    bool disableHideByZoom;
 
    std::string edgeParam, laneParam;
    std::string vehicleParam;
    std::string vehicleScaleParam;
    std::string vehicleTextParam;
 
    std::string edgeData;
    std::string edgeDataID;
    std::string edgeDataScaling;
 
    GUIVisualizationRainbowSettings edgeValueRainBow;
 
 
    GUIColorer vehicleColorer;
 
    GUIScaler vehicleScaler;
 
    int vehicleQuality;
 
    bool showBlinker;
 
    bool drawLaneChangePreference;
 
    bool drawMinGap;
 
    bool drawBrakeGap;
 
    bool showBTRange;
 
    bool showRouteIndex;
 
    bool scaleLength;
 
    bool drawReversed;
 
    bool showParkingInfo;
 
    bool showChargingInfo;
 
    // Setting bundles for controling the size of the drawn vehicles
    GUIVisualizationSizeSettings vehicleSize;
 
    // Setting bundles for optional drawing vehicle names or color value
    GUIVisualizationTextSettings vehicleName, vehicleValue, vehicleScaleValue, vehicleText;
 
    GUIVisualizationRainbowSettings vehicleValueRainBow;
 
 
 
    GUIColorer personColorer;
 
    int personQuality;
 
    // Setting bundles for controling the size of the drawn persons
    GUIVisualizationSizeSettings personSize;
 
    // Setting bundles for optional drawing person names
    GUIVisualizationTextSettings personName, personValue;
 
    bool showPedestrianNetwork;
 
    RGBColor pedestrianNetworkColor;
 
 
 
    GUIColorer containerColorer;
 
    int containerQuality;
 
    // Setting bundles for controling the size of the drawn containers
    GUIVisualizationSizeSettings containerSize;
 
    // Setting bundles for optional drawing container names
    GUIVisualizationTextSettings containerName;
 
 
 
    GUIColorer junctionColorer;
 
    // Setting bundles for optional drawing junction names and indices
    GUIVisualizationTextSettings drawLinkTLIndex, drawLinkJunctionIndex, junctionID, junctionName, internalJunctionName, tlsPhaseIndex, tlsPhaseName;
 
    bool showLane2Lane;
    bool drawJunctionShape;
    bool drawCrossingsAndWalkingareas;
    // Setting bundles for controling the size of the drawn junction
    GUIVisualizationSizeSettings junctionSize;
 
    GUIVisualizationRainbowSettings junctionValueRainBow;
 
 
 
    // @todo decouple addExageration for POIs, Polygons, Triggers etc
    int addMode;
    // Setting bundles for controling the size of additional items
    GUIVisualizationSizeSettings addSize;
    // Setting bundles for optional drawing additional names
    GUIVisualizationTextSettings addName;
    // Setting bundles for optional drawing additional full names
    GUIVisualizationTextSettings addFullName;
 
 
 
    GUIColorer poiColorer;
 
    // Setting bundles for controling the size of the drawn POIs
    GUIVisualizationSizeSettings poiSize;
 
    int poiDetail;
 
    // Setting bundles for optional drawing poi names
    GUIVisualizationTextSettings poiName;
 
    // Setting bundles for optional drawing poi types
    GUIVisualizationTextSettings poiType;
 
    // Setting bundles for optional drawing poi text
    GUIVisualizationTextSettings poiText;
 
    std::string poiTextParam;
 
    bool poiUseCustomLayer;
 
    double poiCustomLayer;
 
    GUIColorer polyColorer;
 
    // Setting bundles for controling the size of the drawn polygons
    GUIVisualizationSizeSettings polySize;
 
    // Setting bundles for optional drawing polygon names
    GUIVisualizationTextSettings polyName;
 
    // Setting bundles for optional drawing polygon types
    GUIVisualizationTextSettings polyType;
 
    bool polyUseCustomLayer;
 
    double polyCustomLayer;
 
 
    GUIColorer dataColorer;
    GUIVisualizationTextSettings dataValue;
 
    double tazRelWidthExaggeration;
 
    double edgeRelWidthExaggeration;
 
    std::string relDataAttr;
 
    GUIVisualizationRainbowSettings dataValueRainBow;
 
 
    bool ignoreColorSchemeFor3DVehicles;
 
    bool show3DTLSLinkMarkers;
 
    bool show3DTLSDomes;
 
    bool generate3DTLSModels;
 
    bool show3DHeadUpDisplay;
 
    RGBColor ambient3DLight;
    RGBColor diffuse3DLight;
 
    RGBColor skyColor;
 
 
 
    bool showSizeLegend;
 
    bool showColorLegend;
 
    bool showVehicleColorLegend;
 
    double scale;
 
    bool gaming;
 
    bool drawBoundaries;
 
    double selectorFrameScale;
 
    bool drawForViewObjectsHandler;
 
    bool drawForRectangleSelection;
 
    bool forceDrawForRectangleSelection;
 
    bool disableDottedContours;
 
    // Setting bundles for optional drawing geometry point indices
    GUIVisualizationTextSettings geometryIndices;
 
    bool secondaryShape;
 
    bool lefthand;
 
    bool disableLaneIcons;
 
    static const std::string SCHEME_NAME_EDGE_PARAM_NUMERICAL;
    static const std::string SCHEME_NAME_LANE_PARAM_NUMERICAL;
    static const std::string SCHEME_NAME_PARAM_NUMERICAL;
    static const std::string SCHEME_NAME_EDGEDATA_NUMERICAL;
    static const std::string SCHEME_NAME_DATA_ATTRIBUTE_NUMERICAL;
    static const std::string SCHEME_NAME_SELECTION;
    static const std::string SCHEME_NAME_TYPE;
    static const std::string SCHEME_NAME_PERMISSION_CODE;
    static const std::string SCHEME_NAME_EDGEDATA_LIVE;
 
    static const double MISSING_DATA;
    static RGBColor COL_MISSING_DATA;
 
    static std::map<std::string, std::vector<RGBColor> > RAINBOW_SCHEMES;
 
    GUIVisualizationColorSettings colorSettings;
 
    GUIVisualizationCandidateColorSettings candidateColorSettings;
 
    GUIVisualizationNeteditSizeSettings neteditSizeSettings;
 
    GUIVisualizationConnectionSettings connectionSettings;
 
    GUIVisualizationAdditionalSettings additionalSettings;
 
    GUIVisualizationDetectorSettings detectorSettings;
 
    GUIVisualizationStoppingPlaceSettings stoppingPlaceSettings;
 
    GUIVisualizationDottedContourSettings dottedContourSettings;
 
    GUIVisualizationWidthSettings widthSettings;
 
    GUIVisualizationDetailSettings detailSettings;
 
    double BoundarySizeDrawing = 15;
 
protected:
    bool myIgnoreHideByZoom;
 
private:
    GUIVisualizationSettings(const GUIVisualizationSettings&) = default;
 
    GUIVisualizationSettings& operator=(const GUIVisualizationSettings&) = default;
};
class GUIVisualizationSettings {…};