GNEPathManager.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
/****************************************************************************/
// Manager for paths in netedit (routes, trips, flows...)
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <netbuild/NBEdge.h>
#include <netbuild/NBVehicle.h>
#include <netedit/elements/GNEContour.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/router/SUMOAbstractRouter.h>
#include <utils/gui/globjects/GUIGlObject.h>
#include <utils/gui/settings/GUIVisualizationSettings.h>
 
 
// ===========================================================================
// class definitions
// ===========================================================================
 
class GNENet;
class GNEAttributeCarrier;
class GNEEdge;
class GNELane;
class GNEJunction;
class GNEAdditional;
 
class GNEPathManager {
 
public:
    class PathElement;
 
    class Segment {
 
    public:
        Segment(GNEPathManager* pathManager, PathElement* element, const GNELane* lane, std::vector<Segment*>& segments);
 
        Segment(GNEPathManager* pathManager, PathElement* element, const GNEJunction* junction, std::vector<Segment*>& segments);
 
        ~Segment();
 
        GNEContour* getContour() const;
 
        bool isFirstSegment() const;
 
        bool isLastSegment() const;
 
        PathElement* getPathElement() const;
 
        const GNELane* getLane() const;
 
        const GNELane* getPreviousLane() const;
 
        const GNELane* getNextLane() const;
 
        const GNEJunction* getJunction() const;
 
        Segment* getNextSegment() const;
 
        Segment* getPreviousSegment() const;
 
        bool isLabelSegment() const;
 
        void markSegmentLabel();
 
    protected:
        GNEPathManager* myPathManager;
 
        PathElement* myPathElement;
 
        const GNELane* myLane;
 
        const GNEJunction* myJunction;
 
        Segment* myNextSegment;
 
        Segment* myPreviousSegment;
 
        bool myLabelSegment;
 
        GNEContour* myContour;
 
    private:
        Segment();
 
        Segment(const Segment&) = delete;
 
        Segment& operator=(const Segment&) = delete;
    };
 
    class PathElement : public GUIGlObject {
 
    public:
        enum Options {
            NETWORK_ELEMENT =       1 << 0, // Network element
            ADDITIONAL_ELEMENT =    1 << 1, // Additional element
            DEMAND_ELEMENT =        1 << 2, // Demand element
            DATA_ELEMENT =          1 << 3, // Data element
            ROUTE =                 1 << 4, // Route (needed for overlapping labels)
        };
 
        PathElement(GUIGlObjectType type, const std::string& microsimID, FXIcon* icon, const int options);
 
        virtual ~PathElement();
 
        bool isNetworkElement() const;
 
        bool isAdditionalElement() const;
 
        bool isDemandElement() const;
 
        bool isDataElement() const;
 
        bool isRoute() const;
 
        virtual void computePathElement() = 0;
 
        virtual bool isPathElementSelected() const = 0;
 
        virtual void drawLanePartialGL(const GUIVisualizationSettings& s, const GNEPathManager::Segment* segment, const double offsetFront) const = 0;
 
        virtual void drawJunctionPartialGL(const GUIVisualizationSettings& s, const GNEPathManager::Segment* segment, const double offsetFront) const = 0;
 
        virtual GNELane* getFirstPathLane() const = 0;
 
        virtual GNELane* getLastPathLane() const = 0;
 
    private:
        const int myOption;
 
        PathElement() = delete;
 
        PathElement(const PathElement&) = delete;
 
        PathElement& operator=(const PathElement&) = delete;
    };
 
    class PathCalculator {
 
    public:
        PathCalculator(const GNENet* net);
 
        ~PathCalculator();
 
        void updatePathCalculator();
 
        std::vector<GNEEdge*> calculateDijkstraPath(const SUMOVehicleClass vClass, const std::vector<GNEEdge*>& edges) const;
 
        std::vector<GNEEdge*> calculateDijkstraPath(const SUMOVehicleClass vClass, GNEEdge* fromEdge, GNEEdge* toEdge) const;
 
        std::vector<GNEEdge*> calculateDijkstraPath(const SUMOVehicleClass vClass, GNEEdge* fromEdge, GNEJunction* toJunction) const;
 
        std::vector<GNEEdge*> calculateDijkstraPath(const SUMOVehicleClass vClass, GNEJunction* fromJunction, GNEEdge* toEdge) const;
 
        std::vector<GNEEdge*> calculateDijkstraPath(const SUMOVehicleClass vClass, GNEJunction* fromJunction, GNEJunction* toJunction) const;
 
        void calculateReachability(const SUMOVehicleClass vClass, GNEEdge* originEdge);
 
        bool consecutiveEdgesConnected(const SUMOVehicleClass vClass, const GNEEdge* from, const GNEEdge* to) const;
 
        bool busStopConnected(const GNEAdditional* busStop, const GNEEdge* edge) const;
 
        bool isPathCalculatorUpdated() const;
 
        void invalidatePathCalculator();
 
    private:
        const GNENet* myNet;
 
        bool myPathCalculatorUpdated;
 
        SUMOAbstractRouter<NBRouterEdge, NBVehicle>* myDijkstraRouter;
 
        std::vector<GNEEdge*> optimizeJunctionPath(const std::vector<GNEEdge*>& edges) const;
    };
 
    class PathDraw {
 
    public:
        PathDraw();
 
        ~PathDraw();
 
        void clearPathDraw();
 
        bool checkDrawPathGeometry(const GUIVisualizationSettings& s, const GNELane* lane, SumoXMLTag tag);
 
        bool checkDrawPathGeometry(const GUIVisualizationSettings& s, const Segment* segment, SumoXMLTag tag);
 
    private:
        std::map<const GNELane*, std::set<SumoXMLTag> > myLaneDrawedElements;
 
        std::map<const std::pair<const GNELane*, const GNELane*>, std::set<SumoXMLTag> > myLane2laneDrawedElements;
    };
 
    GNEPathManager(const GNENet* net);
 
    ~GNEPathManager();
 
    PathCalculator* getPathCalculator();
 
    const PathElement* getPathElement(const GUIGlObject* GLObject) const;
 
    const std::vector<Segment*>& getPathElementSegments(PathElement* pathElement) const;
 
    PathDraw* getPathDraw();
 
    bool isPathValid(const PathElement* pathElement) const;
 
    const GNELane* getFirstLane(const PathElement* pathElement) const;
 
    void calculatePath(PathElement* pathElement, SUMOVehicleClass vClass, GNELane* fromLane, GNELane* toLane);
 
    void calculatePath(PathElement* pathElement, SUMOVehicleClass vClass, GNELane* fromLane, GNEJunction* toJunction);
 
    void calculatePath(PathElement* pathElement, SUMOVehicleClass vClass, GNEJunction* fromJunction, GNELane* toLane);
 
    void calculatePath(PathElement* pathElement, SUMOVehicleClass vClass, GNEJunction* fromJunction, GNEJunction* toJunction);
 
    void calculatePath(PathElement* pathElement, SUMOVehicleClass vClass, const std::vector<GNEEdge*>& edges);
 
    void calculateConsecutivePathEdges(PathElement* pathElement, SUMOVehicleClass vClass, const std::vector<GNEEdge*>& edges,
                                       const int firstLaneIndex = -1, const int lastLaneIndex = -1);
 
    void calculateConsecutivePathLanes(PathElement* pathElement, const std::vector<GNELane*>& lanes);
 
    void removePath(PathElement* pathElement);
 
    void drawLanePathElements(const GUIVisualizationSettings& s, const GNELane* lane) const;
 
    void drawJunctionPathElements(const GUIVisualizationSettings& s, const GNEJunction* junction) const;
 
    void addPathElementToRedrawBuffer(const GNEPathManager::PathElement* pathElement) const;
 
    void invalidateLanePath(const GNELane* lane);
 
    void invalidateJunctionPath(const GNEJunction* junction);
 
    void clearSegments();
 
protected:
    void addSegmentInLaneSegments(Segment* segment, const GNELane* lane);
 
    void addSegmentInJunctionSegments(Segment* segment, const GNEJunction* junction);
 
    void clearSegmentFromJunctionAndLaneSegments(Segment* segment);
 
    bool connectedLanes(const GNELane* fromLane, const GNELane* toLane) const;
 
    void buildPath(PathElement* pathElement, SUMOVehicleClass vClass, const std::vector<GNEEdge*> path,
                   GNELane* fromLane, GNEJunction* fromJunction, GNELane* toLane, GNEJunction* toJunction);
 
    PathCalculator* myPathCalculator;
 
    PathDraw* myPathDraw;
 
    std::map<const PathElement*, std::vector<Segment*> > myPaths;
 
    std::map<const GNELane*, std::set<Segment*> > myLaneSegments;
 
    std::map<const GNEJunction*, std::set<Segment*> > myJunctionSegments;
 
    bool myCleaningSegments = false;
 
private:
    void markLabelSegment(const std::vector<Segment*>& segments) const;
 
    const std::vector<Segment*> myEmptySegments;
 
    GNEPathManager(const GNEPathManager&) = delete;
 
    GNEPathManager& operator=(const GNEPathManager&) = delete;
};