MSPModel.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 following model (prototype)
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <limits>
#include <utils/common/SUMOTime.h>
#include <utils/common/Command.h>
#include <utils/common/MsgHandler.h>
#include <utils/geom/GeomHelper.h>
#include <microsim/transportables/MSPerson.h>
#ifdef HAVE_FOX
#include <utils/foxtools/fxheader.h>
#endif
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSNet;
class MSLane;
class MSJunction;
 
typedef std::pair<const MSPerson*, double> PersonDist;
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSPModel {
public:
    // @brief walking directions
    static const int FORWARD;
    static const int BACKWARD;
    static const int UNDEFINED_DIRECTION;
 
    // @brief the safety gap to keep between the car and the pedestrian in all directions
    static const double SAFETY_GAP;
 
    static const double SIDEWALK_OFFSET;
 
    static const double UNSPECIFIED_POS_LAT;
 
    static const double RANDOM_POS_LAT;
 
    virtual ~MSPModel() {};
 
    virtual MSTransportableStateAdapter* add(MSTransportable* transportable, MSStageMoving* stage, SUMOTime now) = 0;
 
    virtual MSTransportableStateAdapter* loadState(MSTransportable* transportable, MSStageMoving* stage, std::istringstream& state) {
        UNUSED_PARAMETER(transportable);
        UNUSED_PARAMETER(stage);
        UNUSED_PARAMETER(state);
        return nullptr;
    }
 
    virtual void clearState() = 0;
 
    virtual void remove(MSTransportableStateAdapter* state) = 0;
 
    virtual bool blockedAtDist(const SUMOTrafficObject* ego, const MSLane* lane, double vehSide, double vehWidth,
                               double oncomingGap, std::vector<const MSPerson*>* collectBlockers) {
        UNUSED_PARAMETER(ego);
        UNUSED_PARAMETER(lane);
        UNUSED_PARAMETER(vehSide);
        UNUSED_PARAMETER(vehWidth);
        UNUSED_PARAMETER(oncomingGap);
        UNUSED_PARAMETER(collectBlockers);
        return false;
    }
 
    virtual bool hasPedestrians(const MSLane* lane) {
        UNUSED_PARAMETER(lane);
        return false;
    }
 
    virtual PersonDist nextBlocking(const MSLane* lane, double minPos, double minRight, double maxLeft, double stopTime = 0, bool bidi = false) {
        UNUSED_PARAMETER(lane);
        UNUSED_PARAMETER(minPos);
        UNUSED_PARAMETER(minRight);
        UNUSED_PARAMETER(maxLeft);
        UNUSED_PARAMETER(stopTime);
        UNUSED_PARAMETER(bidi);
        return PersonDist(nullptr, -1);
    }
 
    virtual bool usingInternalLanes() = 0;
 
    virtual bool usingShortcuts() {
        return false;
    }
 
    virtual int getActiveNumber() = 0;
 
    /* @brief return the arrival direction if the route may be traversed with the given starting direction.
     * param[out] passedEdges: the number of edges that were successfully traversed
     * returns UNDEFINED_DIRECTION if the route cannot be traversed
     */
    static int canTraverse(int dir, const ConstMSEdgeVector& route, int& passedEdges);
};
 
 
class MSTransportableStateAdapter {
public:
    virtual ~MSTransportableStateAdapter() {};
 
    virtual double getEdgePos(SUMOTime now = 0) const = 0;
 
    virtual int getDirection() const = 0;
 
    virtual Position getPosition(const MSStageMoving& stage, SUMOTime now) const = 0;
 
    virtual double getAngle(const MSStageMoving& stage, SUMOTime now) const = 0;
 
    virtual SUMOTime getWaitingTime() const = 0;
 
    virtual double getSpeed(const MSStageMoving& stage) const = 0;
 
    virtual const MSEdge* getNextEdge(const MSStageMoving& stage) const = 0;
 
    virtual void moveTo(MSPerson* p, MSLane* lane, double lanePos, double lanePosLat, SUMOTime t) {
        UNUSED_PARAMETER(p);
        UNUSED_PARAMETER(lane);
        UNUSED_PARAMETER(lanePos);
        UNUSED_PARAMETER(lanePosLat);
        UNUSED_PARAMETER(t);
        WRITE_WARNING(TL("moveTo is ignored by the current movement model"));
    }
 
    virtual void moveToXY(MSPerson* p, Position pos, MSLane* lane, double lanePos,
                          double lanePosLat, double angle, int routeOffset,
                          const ConstMSEdgeVector& edges, SUMOTime t) {
        UNUSED_PARAMETER(p);
        UNUSED_PARAMETER(pos);
        UNUSED_PARAMETER(lane);
        UNUSED_PARAMETER(lanePos);
        UNUSED_PARAMETER(lanePosLat);
        UNUSED_PARAMETER(angle);
        UNUSED_PARAMETER(routeOffset);
        UNUSED_PARAMETER(edges);
        UNUSED_PARAMETER(t);
        WRITE_WARNING(TL("moveToXY is ignored by the current movement model"));
    }
 
    virtual bool isJammed() const {
        return false;
    }
 
    virtual bool isFinished() const {
        return true;
    }
 
    virtual const MSLane* getLane() const {
        return nullptr;
    }
 
    virtual double getPathLength() const {
        return 0;
    }
 
    virtual void saveState(std::ostringstream& out) {
        UNUSED_PARAMETER(out);
    }
 
};