MSPerson.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
/****************************************************************************/
// The class for modelling person-movements
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <vector>
#include <set>
#include <utils/common/SUMOTime.h>
#include <utils/common/Command.h>
#include <utils/geom/Position.h>
#include <utils/geom/PositionVector.h>
#include <microsim/transportables/MSTransportable.h>
#include <microsim/transportables/MSStageMoving.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSNet;
class MSEdge;
class MSLane;
class OutputDevice;
class SUMOVehicleParameter;
class MSStoppingPlace;
class SUMOVehicle;
class MSVehicleType;
class MSPModel;
class MSMoveReminder;
 
typedef std::vector<const MSEdge*> ConstMSEdgeVector;
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSPerson : public MSTransportable {
public:
    class MSPersonStage_Access : public MSStage {
    public:
        MSPersonStage_Access(const MSEdge* destination, MSStoppingPlace* toStop,
                             const double arrivalPos, const double arrivalPosLat, const double dist, const bool isExit,
                             const Position& startPos, const Position& endPos);
 
        ~MSPersonStage_Access();
 
        MSStage* clone() const;
 
        virtual void proceed(MSNet* net, MSTransportable* person, SUMOTime now, MSStage* previous);
 
        std::string getStageDescription(const bool isPerson) const;
        std::string getStageSummary(const bool isPerson) const;
 
        Position getPosition(SUMOTime now) const;
 
        double getAngle(SUMOTime now) const;
 
        double getDistance() const {
            return myDist;
        }
 
        double getSpeed() const;
 
        void tripInfoOutput(OutputDevice& os, const MSTransportable* const transportable) const;
 
        void routeOutput(const bool, OutputDevice&, const bool, const MSStage* const) const {};
 
    private:
        class ProceedCmd : public Command {
        public:
            ProceedCmd(MSTransportable* person, MSEdge* edge) : myPerson(person), myStopEdge(edge) {}
            ~ProceedCmd() {}
            SUMOTime execute(SUMOTime currentTime);
        private:
            MSTransportable* const myPerson;
            MSEdge* myStopEdge;
        private:
            ProceedCmd& operator=(const ProceedCmd&);
        };
 
    private:
        const MSEdge* myOrigin;
        const double myDist;
        const bool myAmExit;
        SUMOTime myEstimatedArrival;
        PositionVector myPath;
    };
 
public:
    MSPerson(const SUMOVehicleParameter* pars, MSVehicleType* vtype, MSTransportable::MSTransportablePlan* plan, const double speedFactor);
 
    virtual ~MSPerson();
 
    /* @brief check whether an access stage must be added and return whether a
     * stage was added */
    bool checkAccess(const MSStage* const prior, const bool waitAtStop = true);
 
    const std::string& getNextEdge() const;
 
    const MSEdge* getNextEdgePtr() const;
 
    virtual bool isSelected() const {
        return false;
    }
 
    inline double getChosenSpeedFactor() const {
        return myChosenSpeedFactor;
    }
 
    inline void setChosenSpeedFactor(const double factor) {
        myChosenSpeedFactor = factor;
    }
 
    double getImpatience() const;
 
    bool isJammed() const;
 
    void reroute(const ConstMSEdgeVector& newEdges, double departPos, int firstIndex, int nextIndex);
 
 
    class Influencer {
    public:
        Influencer();
 
 
        ~Influencer();
 
 
        void setRemoteControlled(Position xyPos, MSLane* l, double pos, double posLat, double angle, int edgeOffset, const ConstMSEdgeVector& route, SUMOTime t);
 
        SUMOTime getLastAccessTimeStep() const {
            return myLastRemoteAccess;
        }
 
        void postProcessRemoteControl(MSPerson* p);
 
        bool isRemoteControlled() const;
 
        bool isRemoteAffected(SUMOTime t) const;
 
    private:
        Position myRemoteXYPos;
        MSLane* myRemoteLane;
        double myRemotePos;
        double myRemotePosLat;
        double myRemoteAngle;
        int myRemoteEdgeOffset;
        ConstMSEdgeVector myRemoteRoute;
        SUMOTime myLastRemoteAccess;
    };
 
 
    Influencer& getInfluencer();
 
    const Influencer* getInfluencer() const;
 
    bool hasInfluencer() const {
        return myInfluencer != 0;
    }
 
    void setRemoteState(Position xyPos);
 
private:
    Influencer* myInfluencer;
 
    double myChosenSpeedFactor;
 
private:
    MSPerson(const MSPerson&);
 
    MSPerson& operator=(const MSPerson&);
 
};