GUITriggeredRerouter.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
/****************************************************************************/
// Reroutes vehicles passing an edge (gui-version)
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <string>
#include <foreign/rtree/SUMORTree.h>
#include <microsim/trigger/MSTriggeredRerouter.h>
#include <utils/gui/globjects/GUIGlObject_AbstractAdd.h>
#include <utils/gui/globjects/GUIGLObjectPopupMenu.h>
#include <gui/GUIManipulator.h>
 
// ===========================================================================
// class declarations
// ===========================================================================
class GUIEdge;
 
// ===========================================================================
// class definitions
// ===========================================================================
class GUITriggeredRerouter
    : public MSTriggeredRerouter,
      public GUIGlObject_AbstractAdd {
public:
    GUITriggeredRerouter(const std::string& id, const MSEdgeVector& edges, double prob,
                         bool off, bool optional, SUMOTime timeThreshold,
                         const std::string& vTypes, const Position& pos, const double radius,
                         SUMORTree& rtree);
 
 
    ~GUITriggeredRerouter();
 
 
    void myEndElement(int element);
 
 
 
    GUIGLObjectPopupMenu* getPopUpMenu(GUIMainWindow& app,
                                       GUISUMOAbstractView& parent);
 
    GUIParameterTableWindow* getParameterWindow(GUIMainWindow& app,
            GUISUMOAbstractView& parent);
 
    double getExaggeration(const GUIVisualizationSettings& s) const;
 
    Boundary getCenteringBoundary() const;
 
    void drawGL(const GUIVisualizationSettings& s) const;
 
    GUIManipulator* openManipulator(GUIMainWindow& app,
                                    GUISUMOAbstractView& parent);
 
    void shiftProbs();
 
public:
 
    enum RerouterEdgeType {
        REROUTER_TRIGGER_EDGE,
        REROUTER_CLOSED_EDGE,
        REROUTER_SWITCH_EDGE
    };
    enum RerouterEdgeType {…};
 
    class GUITriggeredRerouterEdge : public GUIGlObject {
 
    public:
        GUITriggeredRerouterEdge(GUIEdge* edge, GUITriggeredRerouter* parent, RerouterEdgeType edgeType, int distIndex = -1,
                                 const Position& pos = Position::INVALID, const double radius = std::numeric_limits<double>::max());
 
        virtual ~GUITriggeredRerouterEdge();
 
 
 
        GUIGLObjectPopupMenu* getPopUpMenu(GUIMainWindow& app,
                                           GUISUMOAbstractView& parent);
 
        GUIParameterTableWindow* getParameterWindow(GUIMainWindow& app,
                GUISUMOAbstractView& parent);
 
        double getExaggeration(const GUIVisualizationSettings& s) const;
 
        Boundary getCenteringBoundary() const;
 
        void drawGL(const GUIVisualizationSettings& s) const;
 
        void onLeftBtnPress(void* data);
 
        RerouterEdgeType getRerouterEdgeType() const {
            return myEdgeType;
        }
        RerouterEdgeType getRerouterEdgeType() const  {…}
 
        const MSEdge* getEdge() const {
            return myEdge;
        }
        const MSEdge* getEdge() const  {…}
 
    private:
        typedef std::vector<Position> PosCont;
 
        typedef std::vector<double> RotCont;
 
    private:
        GUITriggeredRerouter* myParent;
 
        MSEdge* myEdge;
 
        const RerouterEdgeType myEdgeType;
 
        PosCont myFGPositions;
 
        RotCont myFGRotations;
 
        Boundary myBoundary;
 
        std::vector<double> myHalfWidths;
 
        int myDistIndex;
    };
    class GUITriggeredRerouterEdge : public GUIGlObject {…};
 
public:
    class GUITriggeredRerouterPopupMenu : public GUIGLObjectPopupMenu {
        FXDECLARE(GUITriggeredRerouterPopupMenu)
    public:
 
        GUITriggeredRerouterPopupMenu(GUIMainWindow& app, GUISUMOAbstractView& parent, GUIGlObject* o);
 
        ~GUITriggeredRerouterPopupMenu();
 
        long onCmdOpenManip(FXObject*, FXSelector, void*);
 
    protected:
        GUITriggeredRerouterPopupMenu() { }
 
    };
    class GUITriggeredRerouterPopupMenu : public GUIGLObjectPopupMenu {…};
 
 
    class GUIManip_TriggeredRerouter : public GUIManipulator {
        FXDECLARE(GUIManip_TriggeredRerouter)
    public:
        enum {
            MID_USER_DEF = FXDialogBox::ID_LAST,
            MID_PRE_DEF,
            MID_OPTION,
            MID_CLOSE,
            MID_SHIFT_PROBS,
            ID_LAST
        };
        GUIManip_TriggeredRerouter(GUIMainWindow& app, const std::string& name, GUITriggeredRerouter& o);
 
        virtual ~GUIManip_TriggeredRerouter();
 
        long onCmdClose(FXObject*, FXSelector, void*);
        long onCmdUserDef(FXObject*, FXSelector, void*);
        long onUpdUserDef(FXObject*, FXSelector, void*);
        long onCmdChangeOption(FXObject*, FXSelector, void*);
        long onCmdShiftProbs(FXObject*, FXSelector, void*);
 
    private:
        GUIMainWindow* myParent;
 
        FXint myChosenValue;
 
        FXDataTarget myChosenTarget;
 
        double myUsageProbability;
 
        FXRealSpinner* myUsageProbabilityDial;
 
        FXDataTarget myUsageProbabilityTarget;
 
        GUITriggeredRerouter* myObject;
 
    protected:
        GUIManip_TriggeredRerouter() { }
 
    };
    class GUIManip_TriggeredRerouter : public GUIManipulator {…};
 
 
private:
    Boundary myBoundary;
 
    std::vector<GUITriggeredRerouterEdge*> myEdgeVisualizations;
 
    int myShiftProbDistIndex;
};
class GUITriggeredRerouter {…};