MSPModel_Striping.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2014-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
/****************************************************************************/
// The pedestrian movement model using stripes on sidewalks
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <limits>
#include <utils/common/SUMOTime.h>
#include <utils/common/Command.h>
#include <utils/options/OptionsCont.h>
#include <microsim/MSLane.h>
#include "MSPerson.h"
#include "MSPModel_Interacting.h"
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSNet;
class MSLink;
class MSJunction;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSPModel_Striping : public MSPModel_Interacting {
 
    friend class GUIPerson; // for debugging
 
public:
 
    struct WalkingAreaPath {
        WalkingAreaPath(const MSLane* _from, const MSLane* _walkingArea, const MSLane* _to, const PositionVector& _shape, int _dir, double _angleOverride) :
            from(_from),
            to(_to),
            lane(_walkingArea),
            shape(_shape),
            dir(_dir),
            angleOverride(_angleOverride),
            length(_shape.length()) {
        }
 
        const MSLane* const from;
        const MSLane* const to;
        const MSLane* const lane; // the walkingArea;
        const PositionVector shape;
        const int dir; // the direction when entering this path
        const double angleOverride;
        const double length;
 
    };
 
    typedef std::map<std::pair<const MSLane*, const MSLane*>, const WalkingAreaPath> WalkingAreaPaths;
 
    MSPModel_Striping(const OptionsCont& oc, MSNet* net);
 
    ~MSPModel_Striping();
 
    MSTransportableStateAdapter* add(MSTransportable* transportable, MSStageMoving* stage, SUMOTime now);
 
    MSTransportableStateAdapter* loadState(MSTransportable* transportable, MSStageMoving* stage, std::istringstream& in);
 
 
    static double stripeWidth;
 
    static double dawdling;
 
    static double minGapToVehicle;
 
    static int myWalkingAreaDetail;
 
    static SUMOTime jamTime;
    static SUMOTime jamTimeCrossing;
    static SUMOTime jamTimeNarrow;
 
    static bool myLegacyPosLat;
 
    static const double LOOKAHEAD_SAMEDIR;
    static const double LOOKAHEAD_ONCOMING;
    static const double LOOKAROUND_VEHICLES;
    static const double LOOKAHEAD_ONCOMING_DIST;
 
    static const double LATERAL_PENALTY;
 
    static const double OBSTRUCTED_PENALTY;
 
    static const double INAPPROPRIATE_PENALTY;
 
    static const double ONCOMING_CONFLICT_PENALTY;
 
    static const double OBSTRUCTION_THRESHOLD;
 
    static const double SQUEEZE;
 
    static double RESERVE_FOR_ONCOMING_FACTOR;
    static double RESERVE_FOR_ONCOMING_FACTOR_JUNCTIONS;
    static double RESERVE_FOR_ONCOMING_MAX;
 
    static const double MAX_WAIT_TOLERANCE;
 
    static const double LATERAL_SPEED_FACTOR;
 
    static const double MIN_STARTUP_DIST;
 
 
    // The striping model uses as lateral position the distance of the center of the pedestrian
    // to the left boundary of the lane minus a half stripe width, where right is positive.
    // The vehicle uses the distance to the center of the lane (and left is positive).
    // The function happens to be self inverse so it can be used to convert in both directions.
    inline static double posLatConversion(const double posLat, const double laneWidth) {
        return .5 * (laneWidth - stripeWidth) - posLat;
    }
 
 
protected:
    static const double DIST_FAR_AWAY;
    static const double DIST_BEHIND;
    static const double DIST_OVERLAP;
 
    struct Obstacle;
    class PState;
    typedef std::vector<Obstacle> Obstacles;
    typedef std::map<const MSLane*, Obstacles, ComparatorNumericalIdLess> NextLanesObstacles;
    typedef std::map<const MSLane*, double> MinNextLengths;
 
    struct NextLaneInfo {
        NextLaneInfo(const MSLane* _lane, const MSLink* _link, int _dir) :
            lane(_lane),
            link(_link),
            dir(_dir) {
        }
 
        NextLaneInfo() :
            lane(0),
            link(0),
            dir(UNDEFINED_DIRECTION) {
        }
 
        const MSLane* lane;
        const MSLink* link;
        int dir;
    };
 
    enum ObstacleType {
        OBSTACLE_NONE = 0,
        OBSTACLE_PED = 1,
        OBSTACLE_VEHICLE = 3,
        OBSTACLE_END = 4,
        OBSTACLE_NEXTEND = 5,
        OBSTACLE_LINKCLOSED = 6,
        OBSTACLE_ARRIVALPOS = 7
    };
 
    struct Obstacle {
        Obstacle(int dir, double dist = DIST_FAR_AWAY);
        Obstacle(const PState& ped);
        Obstacle(double _x, double _speed, ObstacleType _type, const std::string& _description, const double width = 0., const SUMOVehicle* veh = nullptr)
            : xFwd(_x + width / 2.), xBack(_x - width / 2.), speed(_speed), type(_type), description(_description), vehicle(veh) {};
 
        double xFwd;
        double xBack;
        double speed;
        ObstacleType type;
        std::string description;
        const SUMOVehicle* vehicle = nullptr;
 
        bool closer(const Obstacle& o, int dir);
    };
 
    class walkingarea_path_sorter {
    public:
        bool operator()(const WalkingAreaPath* p1, const WalkingAreaPath* p2) const {
            if (p1->from->getNumericalID() < p2->from->getNumericalID()) {
                return true;
            }
            if (p1->from->getNumericalID() == p2->from->getNumericalID()) {
                if (p1->to->getNumericalID() < p2->to->getNumericalID()) {
                    return true;
                }
            }
            return false;
        }
    };
 
 
    class PState : public MSPModel_InteractingState {
    public:
        PState(MSPerson* person, MSStageMoving* stage, const MSLane* lane);
 
        PState(MSPerson* person, MSStageMoving* stage, std::istringstream* in = nullptr);
 
        ~PState() {};
        Position getPosition(const MSStageMoving& stage, SUMOTime now) const;
        double getAngle(const MSStageMoving& stage, SUMOTime now) const;
        const MSEdge* getNextEdge(const MSStageMoving& stage) const;
        void moveTo(MSPerson* p, MSLane* lane, double lanePos, double lanePosLat, SUMOTime t);
        void moveToXY(MSPerson* p, Position pos, MSLane* lane, double lanePos,
                      double lanePosLat, double angle, int routeOffset,
                      const ConstMSEdgeVector& edges, SUMOTime t);
 
        NextLaneInfo myNLI;
        const WalkingAreaPath* myWalkingAreaPath;
 
        virtual double getMinX(const bool includeMinGap = true) const;
 
        virtual double getMaxX(const bool includeMinGap = true) const;
 
        double getLength() const;
 
        double getMinGap() const;
 
        double distToLaneEnd() const;
 
        bool moveToNextLane(SUMOTime currentTime);
 
        void walk(const Obstacles& obs, SUMOTime currentTime);
 
        double getImpatience(SUMOTime now) const;
 
        int stripe() const;
        int otherStripe() const;
 
        static int stripe(const double relY);
        int otherStripe(const double relY) const;
 
        /* @brief calculate distance to the given obstacle,
         * - non-negative values signify an obstacle in front of ego
         * the special values DIST_OVERLAP and DIST_BEHIND are used to signify
         * obstacles that overlap and obstacles behind ego respectively
         * the result is the same regardless of walking direction
         */
        double distanceTo(const Obstacle& obs, const bool includeMinGap = true) const;
 
        void mergeObstacles(Obstacles& into, const Obstacles& obs2);
 
        static void mergeObstacles(Obstacles& into, const Obstacles& obs2, int dir, int offset);
 
        bool ignoreRed(const MSLink* link) const;
 
        virtual double getWidth() const;
 
        virtual ObstacleType getOType() const {
            return OBSTACLE_PED;
        }
 
        bool isRemoteControlled() const;
 
        void saveState(std::ostringstream& out);
 
        const MSLane* getNextCrossing() const;
 
        double getLatOffset() const {
            return posLatConversion(myPosLat, myLane->getWidth());
        }
 
        inline double getPosLat() const {
            return myPosLat;
        }
 
        double getPathLength() const;
        void reverse(const double pathLength, const double usableWidth);
        void reset(const double edgePos, const double latPos);
 
    protected:
        PState();
    private:
        PState& operator=(const PState&) = delete;
    };
 
    class PStateVehicle : public PState {
    public:
        PStateVehicle(const MSVehicle* veh, const MSLane* walkingarea, double relX, double relY, double xWidth, double yWidth);
        const std::string& getID() const;
        double getMinX(const bool includeMinGap = true) const;
        double getMaxX(const bool includeMinGap = true) const;
        double getWidth() const;
 
        ObstacleType getOType() const {
            return OBSTACLE_VEHICLE;
        }
 
        const MSVehicle* getVehicle() const {
            return myVehicle;
        }
    private:
        const MSVehicle* myVehicle;
        const double myXWidth;
        const double myYWidth;
    };
 
 
    class MovePedestrians : public Command {
    public:
        MovePedestrians(MSPModel_Striping* model) : myModel(model) {};
        ~MovePedestrians() {};
        SUMOTime execute(SUMOTime currentTime);
    private:
        MSPModel_Striping* const myModel;
    private:
        MovePedestrians& operator=(const MovePedestrians&) = delete;
    };
 
    class by_xpos_sorter {
    public:
        by_xpos_sorter(int dir): myDir(dir) {}
 
    public:
        bool operator()(const MSPModel_InteractingState* p1, const MSPModel_InteractingState* p2) const {
            if (p1->getEdgePos(0) != p2->getEdgePos(0)) {
                return myDir * p1->getEdgePos(0) > myDir * p2->getEdgePos(0);
            }
            return p1->getID() < p2->getID();
        }
 
    private:
        const int myDir;
    };
 
 
    void moveInDirection(SUMOTime currentTime, std::set<MSPerson*>& changedLane, int dir);
 
    void moveInDirectionOnLane(Pedestrians& pedestrians, const MSLane* lane, SUMOTime currentTime, std::set<MSPerson*>& changedLane, int dir, bool debug);
 
    void arriveAndAdvance(Pedestrians& pedestrians, SUMOTime currentTime, std::set<MSPerson*>& changedLane, int dir);
 
    const ActiveLanes& getActiveLanes() {
        return myActiveLanes;
    }
 
private:
    static void DEBUG_PRINT(const Obstacles& obs);
 
    static int connectedDirection(const MSLane* from, const MSLane* to);
 
    static NextLaneInfo getNextLane(const PState& ped, const MSLane* currentLane, const MSLane* prevLane);
 
    static const MSLane* getNextWalkingArea(const MSLane* currentLane, const int dir, const MSLink*& link);
 
    static void initWalkingAreaPaths(const MSNet* net);
 
    static void insertWalkArePaths(const MSEdge* edge, WalkingAreaPaths& into);
 
    static const WalkingAreaPath* getWalkingAreaPath(const MSEdge* walkingArea, const MSLane* before, const MSLane* after);
 
    static const WalkingAreaPath* getArbitraryPath(const MSEdge* walkingArea);
 
    static const WalkingAreaPath* guessPath(const MSEdge* walkingArea, const MSEdge* before, const MSEdge* after);
 
    static int numStripes(const MSLane* lane);
 
    static Obstacles getNeighboringObstacles(const Pedestrians& pedestrians, int egoIndex, int stripes);
 
    const Obstacles& getNextLaneObstacles(NextLanesObstacles& nextLanesObs, const MSLane* lane, const MSLane* nextLane, int stripes,
                                          int nextDir, double currentLength, int currentDir);
 
    static void transformToCurrentLanePositions(Obstacles& o, int currentDir, int nextDir, double currentLength, double nextLength);
 
    static void addCloserObstacle(Obstacles& obs, double x, int stripe, int numStripes, const std::string& id, double width, int dir, ObstacleType type);
 
    /* @brief compute stripe-offset to transform relY values from a lane with origStripes into a lane wit destStrips
     * @note this is called once for transforming nextLane peds to into the current system as obstacles and another time
     * (in reverse) to transform the pedestrian coordinates into the nextLane-coordinates when changing lanes
     */
    static int getStripeOffset(int origStripes, int destStripes, bool addRemainder);
 
    static bool addCrossingVehs(const MSLane* crossing, int stripes, double lateral_offset, int dir, Obstacles& crossingVehs, bool prio);
 
    static Obstacles getVehicleObstacles(const MSLane* lane, int dir, PState* ped = 0);
 
    static bool addVehicleFoe(const MSVehicle* veh, const MSLane* walkingarea, const Position& relPos, double xWidth, double yWidth, double lateral_offset,
                              double minY, double maxY, Pedestrians& toDelete, Pedestrians& transformedPeds);
 
    static int getReserved(int stripes, double factor);
 
    static void registerCrossingApproach(const PState& ped, const MSLane* crossing, const MSLane* beforeWA);
 
private:
    static WalkingAreaPaths myWalkingAreaPaths;
    static std::map<const MSEdge*, std::vector<const MSLane*> > myWalkingAreaFoes;
    static MinNextLengths myMinNextLengths;
};