GNEEdge.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 (netedit-version, adapted from GUIEdge)
// Basically a container for an NBEdge with drawing and editing capabilities
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <netbuild/NBEdge.h>
#include <netedit/elements/GNECandidateElement.h>
#include <utils/gui/div/GUIGeometry.h>
#include <utils/gui/div/GUIDottedGeometry.h>
 
#include "GNENetworkElement.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class GNENet;
class GNEJunction;
class GNELane;
class GNEConnection;
class GNERouteProbe;
class GNECrossing;
class GNEEdgeType;
class GNEEdgeTemplate;
 
// ===========================================================================
// class definitions
// ===========================================================================
class GNEEdge : public GNENetworkElement, public GNECandidateElement {
 
    friend class GNEChange_Lane;
    friend class GNEChange_Connection;
 
public:
    typedef std::vector<GNELane*> LaneVector;
 
    typedef std::vector<GNEConnection*> ConnectionVector;
 
    GNEEdge(GNENet* net, NBEdge* nbe, bool wasSplit = false, bool loaded = false);
 
    ~GNEEdge();
 
    inline GNEJunction* getFromJunction() const {
        return getParentJunctions().front();
    }
 
    inline GNEJunction* getToJunction() const {
        return getParentJunctions().back();
    }
 
    bool isNetworkElementValid() const;
 
    std::string getNetworkElementProblem() const;
 
 
    void updateGeometry();
 
    Position getPositionInView() const;
 
 
 
    bool checkDrawFromContour() const;
 
    bool checkDrawToContour() const;
 
    bool checkDrawRelatedContour() const;
 
    bool checkDrawOverContour() const;
 
    bool checkDrawDeleteContour() const;
 
    bool checkDrawSelectContour() const;
 
    bool checkDrawMoveContour() const;
 
 
    GNEMoveOperation* getMoveOperation();
 
    void removeGeometryPoint(const Position clickedPosition, GNEUndoList* undoList);
 
    bool hasCustomEndPoints() const;
 
    bool clickedOverShapeStart(const Position& pos) const;
 
    bool clickedOverShapeEnd(const Position& pos) const;
 
    bool clickedOverGeometryPoint(const Position& pos) const;
 
    void updateJunctionPosition(GNEJunction* junction, const Position& origPos);
 
 
    GUIGLObjectPopupMenu* getPopUpMenu(GUIMainWindow& app, GUISUMOAbstractView& parent);
 
    double getExaggeration(const GUIVisualizationSettings& s) const;
 
    Boundary getCenteringBoundary() const;
 
    void updateCenteringBoundary(const bool updateGrid);
 
    const std::string getOptionalName() const;
 
    void drawGL(const GUIVisualizationSettings& s) const;
 
    void deleteGLObject();
 
    void updateGLObject();
 
 
    NBEdge* getNBEdge() const;
 
    std::vector<GNEEdge*> getOppositeEdges() const;
 
    void editEndpoint(Position pos, GNEUndoList* undoList);
 
    void resetEndpoint(const Position& pos, GNEUndoList* undoList);
 
    void resetBothEndpoint(GNEUndoList* undoList);
 
    /* @brief method for getting the Attribute of an XML key
     * @param[in] key The attribute key
     * @return string with the value associated to key
     */
    std::string getAttribute(SumoXMLAttr key) const;
    std::string getAttributeForSelection(SumoXMLAttr key) const;
 
    /* @brief method for setting the attribute and letting the object perform additional changes
     * @param[in] key The attribute key
     * @param[in] value The new value
     * @param[in] undoList The undoList on which to register changes
     */
    void setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList);
 
    /* @brief method for setting the attribute and letting the object perform additional changes
     * @param[in] key The attribute key
     * @param[in] value The new value
     * @param[in] undoList The undoList on which to register changes
     */
    bool isValid(SumoXMLAttr key, const std::string& value);
 
    /* @brief method for check if the value for certain attribute is set
     * @param[in] key The attribute key
     */
    bool isAttributeEnabled(SumoXMLAttr key) const;
 
    /* @brief method for check if the value for certain attribute is computed (for example, due a network recomputing)
     * @param[in] key The attribute key
     */
    bool isAttributeComputed(SumoXMLAttr key) const;
 
 
    const Parameterised::Map& getACParametersMap() const;
 
    void setResponsible(bool newVal);
 
    void setGeometry(PositionVector geom, bool inner);
 
    const Position getFrontUpShapePosition() const;
 
    const Position getFrontDownShapePosition() const;
 
    const Position getBackUpShapePosition() const;
 
    const Position getBackDownShapePosition() const;
 
    void remakeGNEConnections(bool junctionsReady = false);
 
    void copyTemplate(const GNEEdgeTemplate* edgeTemplate, GNEUndoList* undoList);
 
    void copyEdgeType(const GNEEdgeType* edgeType, GNEUndoList* undoList);
 
    std::set<GUIGlID> getLaneGlIDs() const;
 
    const std::vector<GNELane*>& getLanes() const;
 
    const std::vector<GNEConnection*>& getGNEConnections() const;
 
    GNEConnection* retrieveGNEConnection(int fromLane, NBEdge* to, int toLane, bool createIfNoExist = true);
 
    bool wasSplit();
 
    /* @brief compute a splitting position which keeps the resulting edges
     * straight unless the user clicked near a geometry point */
    Position getSplitPos(const Position& clickPos);
 
    void setEdgeID(const std::string& newID);
 
    bool hasRestrictedLane(SUMOVehicleClass vclass) const;
 
    // @brief the radius in which to register clicks for geometry nodes
    static const double SNAP_RADIUS;
 
    // @brief the radius in which to register clicks for geometry nodes (Squared)
    static const double SNAP_RADIUS_SQUARED;
 
    void clearGNEConnections();
 
    int getRouteProbeRelativePosition(GNERouteProbe* routeProbe) const;
 
    std::vector<GNECrossing*> getGNECrossings();
 
    void smooth(GNEUndoList* undoList);
 
    void straightenElevation(GNEUndoList* undoList);
 
    void smoothElevation(GNEUndoList* undoList);
 
    PositionVector smoothShape(const PositionVector& shape, bool forElevation);
 
    GNELane* getLaneByAllowedVClass(const SUMOVehicleClass vClass) const;
 
    GNELane* getLaneByDisallowedVClass(const SUMOVehicleClass vClass) const;
 
    // @brief update vehicle spread geometries
    void updateVehicleSpreadGeometries();
 
    // @brief update vehicle geometries
    void updateVehicleStackLabels();
 
    // @brief update person geometries
    void updatePersonStackLabels();
 
    // @brief update vehicle geometries
    void updateContainerStackLabels();
 
    bool isConvexAngle() const;
 
    bool hasPredecessors() const;
 
    bool hasSuccessors() const;
 
    GNEEdge* getReverseEdge() const;
 
protected:
    NBEdge* myNBEdge;
 
    LaneVector myLanes;
 
    ConnectionVector myGNEConnections;
 
    Position myPositionBeforeMoving;
 
    bool myAmResponsible;
 
    bool myWasSplit;
 
    std::string myConnectionStatus;
 
private:
    class StackPosition : public std::pair<double, double> {
 
    public:
        StackPosition(const double departPos, const double length);
 
        double beginPosition() const;
 
        double endPosition() const;
    };
 
    class StackDemandElements : public std::pair<StackPosition, std::vector<GNEDemandElement*> > {
 
    public:
        StackDemandElements(const StackPosition stackedPosition, GNEDemandElement* demandElement);
 
        void addDemandElements(GNEDemandElement* demandElement);
 
        const StackPosition& getStackPosition() const;
 
        const std::vector<GNEDemandElement*>& getDemandElements() const;
    };
 
    Boundary myEdgeBoundary;
 
    bool myUpdateGeometry;
 
    void setAttribute(SumoXMLAttr key, const std::string& value);
 
    void setMoveShape(const GNEMoveResult& moveResult);
 
    void commitMoveShape(const GNEMoveResult& moveResult, GNEUndoList* undoList);
 
    void setNumLanes(int numLanes, GNEUndoList* undoList);
 
    void updateFirstParentJunction(const std::string& value);
 
    void updateSecondParentJunction(const std::string& value);
 
    void addLane(GNELane* lane, const NBEdge::Lane& laneAttrs, bool recomputeConnections);
 
    void removeLane(GNELane* lane, bool recomputeConnections);
 
    void addConnection(NBEdge::Connection nbCon, bool selectAfterCreation = false);
 
    void removeConnection(NBEdge::Connection nbCon);
 
    void removeEdgeFromCrossings(GNEJunction* junction, GNEUndoList* undoList);
 
    void setShapeStartPos(const Position& pos);
 
    void setShapeEndPos(const Position& pos);
 
    const std::map<const GNELane*, std::vector<GNEDemandElement*> > getVehiclesOverEdgeMap() const;
 
    const std::map<const GNELane*, std::vector<GNEDemandElement*> > getPersonsOverEdgeMap() const;
 
    const std::map<const GNELane*, std::vector<GNEDemandElement*> > getContainersOverEdgeMap() const;
 
    void drawEdgeGeometryPoints(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d) const;
 
    void drawStartGeometryPoint(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d,
                                const double geometryPointRadius, const double exaggeration) const;
 
    void drawEndGeometryPoint(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d,
                              const double geometryPointRadius, const double exaggeration) const;
 
    void drawEdgeName(const GUIVisualizationSettings& s) const;
 
    void drawLaneStopOffset(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d) const;
 
    void drawEdgeShape(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d) const;
 
    void drawChildrens(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d) const;
 
    void calculateEdgeContour(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d) const;
 
    void drawTAZElements(const GUIVisualizationSettings& s) const;
 
    bool drawBigGeometryPoints() const;
 
    bool areStackPositionOverlapped(const GNEEdge::StackPosition& vehicleA, const GNEEdge::StackPosition& vehicleB) const;
 
    GNEMoveOperation* processMoveFromJunctionSelected(const PositionVector originalShape, const Position mousePosition, const double snapRadius);
 
    GNEMoveOperation* processMoveToJunctionSelected(const PositionVector originalShape, const Position mousePosition, const double snapRadius);
 
    GNEMoveOperation* processMoveBothJunctionSelected();
 
    GNEMoveOperation* processNoneJunctionSelected(const double snapRadius);
 
    double getGeometryPointRadius() const;
 
    GNEEdge(const GNEEdge& s) = delete;
 
    GNEEdge& operator=(const GNEEdge& s) = delete;
};