MSPModel_Interacting.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 abstract superclass for pedestrian models which actually interact with vehicles
/****************************************************************************/
#pragma once
#include <config.h>
 
#include "MSPModel.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSPModel_InteractingState;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSPModel_Interacting : public MSPModel {
public:
    ~MSPModel_Interacting();
 
    virtual void clearState();
 
    virtual void remove(MSTransportableStateAdapter* state);
 
    bool blockedAtDist(const SUMOTrafficObject* ego, const MSLane* lane, double vehSide, double vehWidth,
                       double oncomingGap, std::vector<const MSPerson*>* collectBlockers);
 
    PersonDist nextBlocking(const MSLane* lane, double minPos, double minRight, double maxLeft, double stopTime = 0, bool bidi = false);
 
    bool hasPedestrians(const MSLane* lane);
 
    bool usingInternalLanes();
 
    static bool usingInternalLanesStatic();
 
    int getActiveNumber() {
        return myNumActivePedestrians;
    }
 
    void registerActive() {
        myNumActivePedestrians++;
    }
 
    static void unregisterCrossingApproach(const MSPModel_InteractingState& ped, const MSLane* crossing);
 
protected:
    typedef std::vector<MSPModel_InteractingState*> Pedestrians;
    typedef std::map<const MSLane*, Pedestrians, ComparatorNumericalIdLess> ActiveLanes;
 
    Pedestrians& getPedestrians(const MSLane* lane);
 
    int myNumActivePedestrians = 0;
 
    ActiveLanes myActiveLanes;
 
    bool myAmActive = false;
 
    std::set<MSLink*> myApproachedCrossings;
 
    static Pedestrians noPedestrians;
 
};
 
 
class MSPModel_InteractingState : public MSTransportableStateAdapter {
public:
    MSPModel_InteractingState(MSPerson* person, MSStageMoving* stage, const MSLane* lane) :
        myPerson(person),
        myStage(stage),
        myLane(lane),
        myEdgePos(stage != nullptr ? stage->getDepartPos() : 0.),
        myPosLat(stage != nullptr ? stage->getDepartPosLat() : 0.),
        myDir(MSPModel::UNDEFINED_DIRECTION),
        myWaitingToEnter(person != nullptr) {}
 
    ~MSPModel_InteractingState() {};
 
    inline double getEdgePos(SUMOTime /* now */) const {
        return myEdgePos;
    }
 
    inline int getDirection() const {
        return myDir;
    }
 
    inline SUMOTime getWaitingTime() const {
        return myWaitingTime;
    }
 
    inline double getSpeed(const MSStageMoving& /* stage */) const {
        return mySpeed;
    }
 
    inline bool isJammed() const {
        return myAmJammed;
    }
 
    inline const MSLane* getLane() const {
        return myLane;
    }
 
    virtual const MSLane* getNextCrossing() const {
        return nullptr;
    }
 
    virtual double getLatOffset() const {
        return myPosLat;
    }
 
    inline MSPerson* getPerson() const {
        return myPerson;
    }
 
    inline MSStageMoving* getStage() const {
        return myStage;
    }
 
    inline bool isWaitingToEnter() const {
        return myWaitingToEnter;
    }
 
    inline const Position& getRemotePosition() const {
        return myRemoteXYPos;
    }
 
    virtual const std::string& getID() const {
        return myPerson->getID();
    }
 
    virtual double getAngle(const MSStageMoving&, SUMOTime) const {
        return myAngle;
    }
 
protected:
    MSPerson* myPerson = nullptr;
    MSStageMoving* myStage = nullptr;
    const MSLane* myLane = nullptr;
    double myEdgePos = 0.;
    double myPosLat = 0.;
    int myDir = MSPModel::UNDEFINED_DIRECTION;
    double mySpeed = 0.;
    double mySpeedLat = 0.;
    bool myWaitingToEnter = false;
    SUMOTime myWaitingTime = 0;
    bool myAmJammed = false;
    Position myRemoteXYPos = Position::INVALID;
    mutable double myAngle = std::numeric_limits<double>::max();
 
private:
    MSPModel_InteractingState& operator=(const MSPModel_InteractingState&) = delete;
};