GUIEdge.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 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
/****************************************************************************/
// A road/street connecting two junctions (gui-version)
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <string>
#include <utils/foxtools/fxheader.h>
#include <microsim/MSEdge.h>
#include <utils/gui/globjects/GUIGlObject.h>
#include <utils/gui/settings/GUIPropertySchemeStorage.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MESegment;
class MSBaseVehicle;
class GUILane;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class GUIEdge : public MSEdge, public GUIGlObject {
public:
    GUIEdge(const std::string& id, int numericalID,
            const SumoXMLEdgeFunc function,
            const std::string& streetName, const std::string& edgeType, int priority,
            double distance);
 
 
    ~GUIEdge();
 
    virtual void closeBuilding() override;
 
    /* @brief Returns the gl-ids of all known edges
     * @param[in] includeInternal Whether to include ids of internal edges
     */
    static std::vector<GUIGlID> getIDs(bool includeInternal);
 
    /* @brief Returns the combined length of all edges
     * @param[in] includeInternal Whether to include lengths of internal edges
     * @param[in] eachLane Whether to count each lane separately
     */
    static double getTotalLength(bool includeInternal, bool eachLane);
 
    Boundary getBoundary() const;
 
    MSLane& getLane(int laneNo);
 
    static std::pair<double, double> getLaneOffsets(double x1, double y1,
            double x2, double y2, double prev, double wanted);
 
 
 
 
    virtual GUIGLObjectPopupMenu* getPopUpMenu(GUIMainWindow& app, GUISUMOAbstractView& parent) override;
 
 
    virtual GUIParameterTableWindow* getParameterWindow(GUIMainWindow& app, GUISUMOAbstractView& parent) override;
 
    GUIParameterTableWindow* getTypeParameterWindow(GUIMainWindow& app, GUISUMOAbstractView& parent) override;
 
    Boundary getCenteringBoundary() const override;
 
    const std::string getOptionalName() const override;
 
    void drawGL(const GUIVisualizationSettings& s) const override;
 
    double getClickPriority() const override;
 
    void addTransportable(MSTransportable* t) const override {
        FXMutexLock locker(myLock);
        MSEdge::addTransportable(t);
    }
 
    void removeTransportable(MSTransportable* t) const override {
        FXMutexLock locker(myLock);
        MSEdge::removeTransportable(t);
    }
 
 
    const std::set<MSTransportable*, ComparatorNumericalIdLess>& getPersonsSecure() const {
        myLock.lock();
        return myPersons;
    }
 
    void releasePersons() const {
        myLock.unlock();
    }
 
    double getAllowedSpeed() const;
    double getRelativeSpeed() const;
 
    void setColor(const GUIVisualizationSettings& s) const;
 
    bool setFunctionalColor(const GUIColorer& c) const;
 
    bool setMultiColor(const GUIColorer& c) const;
 
    double getColorValue(const GUIVisualizationSettings& s, int activeScheme) const override;
 
    double getScaleValue(const GUIVisualizationSettings& s, int activeScheme) const;
 
    MESegment* getSegmentAtPosition(const Position& pos);
 
    void drawMesoVehicles(const GUIVisualizationSettings& s) const;
 
    void lock() const override {
        myLock.lock();
    }
 
    void unlock() const override {
        myLock.unlock();
    }
 
    void closeTraffic(const GUILane* lane);
 
    void addRerouter();
 
    const std::vector<RGBColor>& getSegmentColors() const {
        return mySegmentColors;
    }
 
    RGBColor getMesoColor() const {
        return myMesoColor;
    }
 
    bool showDeadEnd() const {
        return myShowDeadEnd;
    }
 
    bool isSelected() const override;
 
    mutable std::vector<RGBColor> mySegmentColors;
 
    bool myShowDeadEnd;
 
    double getPendingEmits() const;
 
private:
    GUIEdge(const GUIEdge& s);
 
    GUIEdge& operator=(const GUIEdge& s);
 
 
private:
    mutable FXMutex myLock;
 
    mutable RGBColor myMesoColor;
 
};