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/settings/GUIVisualizationSettings.h>
 
 
// ===========================================================================
// class declaration
// ===========================================================================
 
class GNENet;
class GNEEdge;
class GNELane;
class GNEJunction;
class GNEAdditional;
class GNEPathElement;
class GNESegment;
class GUIGlObject;
 
// ===========================================================================
// class definitions
// ===========================================================================
 
class GNEPathManager {
 
    friend class GNESegment;
 
public:
 
    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 GNESegment* 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 GNEPathElement* getPathElement(const GUIGlObject* GLObject) const;
 
    const std::vector<GNESegment*>& getPathElementSegments(GNEPathElement* pathElement) const;
 
    PathDraw* getPathDraw();
 
    bool isPathValid(const GNEPathElement* pathElement) const;
 
    const GNELane* getFirstLane(const GNEPathElement* pathElement) const;
 
    void calculatePath(GNEPathElement* pathElement, SUMOVehicleClass vClass, GNELane* fromLane, GNELane* toLane);
 
    void calculatePath(GNEPathElement* pathElement, SUMOVehicleClass vClass, GNELane* fromLane, GNEJunction* toJunction);
 
    void calculatePath(GNEPathElement* pathElement, SUMOVehicleClass vClass, GNEJunction* fromJunction, GNELane* toLane);
 
    void calculatePath(GNEPathElement* pathElement, SUMOVehicleClass vClass, GNEJunction* fromJunction, GNEJunction* toJunction);
 
    void calculatePath(GNEPathElement* pathElement, SUMOVehicleClass vClass, const std::vector<GNEEdge*>& edges);
 
    void calculateConsecutivePathEdges(GNEPathElement* pathElement, SUMOVehicleClass vClass, const std::vector<GNEEdge*>& edges,
                                       const int firstLaneIndex = -1, const int lastLaneIndex = -1);
 
    void calculateConsecutivePathLanes(GNEPathElement* pathElement, const std::vector<GNELane*>& lanes);
 
    void removePath(GNEPathElement* pathElement);
 
    void drawLanePathElements(const GUIVisualizationSettings& s, const GNELane* lane) const;
 
    void drawJunctionPathElements(const GUIVisualizationSettings& s, const GNEJunction* junction) const;
 
    void redrawPathElements(const GUIVisualizationSettings& s) const;
 
    void invalidateLanePath(const GNELane* lane);
 
    void invalidateJunctionPath(const GNEJunction* junction);
 
    void clearSegments();
 
protected:
    void addSegmentInLaneSegments(GNESegment* segment, const GNELane* lane);
 
    void addSegmentInJunctionSegments(GNESegment* segment, const GNEJunction* junction);
 
    void clearSegmentFromJunctionAndLaneSegments(GNESegment* segment);
 
    bool connectedLanes(const GNELane* fromLane, const GNELane* toLane) const;
 
    void buildPath(GNEPathElement* pathElement, SUMOVehicleClass vClass, const std::vector<GNEEdge*> path,
                   GNELane* fromLane, GNEJunction* fromJunction, GNELane* toLane, GNEJunction* toJunction);
 
    PathCalculator* myPathCalculator;
 
    PathDraw* myPathDraw;
 
    std::map<const GNEPathElement*, std::vector<GNESegment*> > myPaths;
 
    std::map<const GNELane*, std::set<GNESegment*> > myLaneSegments;
 
    std::map<const GNEJunction*, std::set<GNESegment*> > myJunctionSegments;
 
    bool myCleaningSegments = false;
 
private:
    void markLabelSegment(const std::vector<GNESegment*>& segments) const;
 
    const std::vector<GNESegment*> myEmptySegments;
 
    GNEPathManager(const GNEPathManager&) = delete;
 
    GNEPathManager& operator=(const GNEPathManager&) = delete;
};