MSLane.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2025 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
/****************************************************************************/
// Representation of a lane in the micro simulation
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <memory>
#include <vector>
#include <map>
#include <deque>
#include <cassert>
#include <utils/common/Named.h>
#include <utils/common/Parameterised.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/vehicle/SUMOVehicle.h>
#include <utils/common/NamedRTree.h>
#include <utils/emissions/PollutantsInterface.h>
#include <utils/geom/PositionVector.h>
#include "MSGlobals.h"
#include "MSLeaderInfo.h"
#include "MSMoveReminder.h"
#include "MSVehicle.h"
 
#include <utils/foxtools/MFXSynchQue.h>
#ifdef HAVE_FOX
#include <utils/foxtools/MFXWorkerThread.h>
#endif
#include <utils/common/StopWatch.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSEdge;
class MSBaseVehicle;
class MSLaneChanger;
class MSLink;
class MSVehicleTransfer;
class MSVehicleControl;
class OutputDevice;
class MSLeaderInfo;
class MSJunction;
 
 
// ===========================================================================
// type definitions
// ===========================================================================
typedef std::map<const MSLane*, std::pair<double, double> >  LaneCoverageInfo;
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSLane : public Named, public Parameterised {
public:
    class StoringVisitor {
    public:
        StoringVisitor(std::set<const Named*>& objects, const PositionVector& shape,
                       const double range, const int domain)
            : myObjects(objects), myShape(shape), myRange(range), myDomain(domain) {}
 
        void add(const MSLane* const l) const;
 
    private:
        std::set<const Named*>& myObjects;
        const PositionVector& myShape;
        const double myRange;
        const int myDomain;
 
    private:
        StoringVisitor(const StoringVisitor& src);
 
        StoringVisitor& operator=(const StoringVisitor& src);
    };
 
    friend class MSLaneChanger;
    friend class MSLaneChangerSublane;
 
    friend class MSQueueExport;
    friend class AnyVehicleIterator;
 
    typedef std::vector<MSVehicle*> VehCont;
 
    // TODO: Better documentation
    class AnyVehicleIterator {
    public:
        AnyVehicleIterator(
            const MSLane* lane,
            int i1,
            int i2,
            int i3,
            const int i1End,
            const int i2End,
            const int i3End,
            bool downstream = true) :
            myLane(lane),
            myI1(i1),
            myI2(i2),
            myI3(i3),
            myI1End(i1End),
            myI2End(i2End),
            myI3End(i3End),
            myDownstream(downstream),
            myDirection(downstream ? 1 : -1) {
        }
 
        bool operator== (AnyVehicleIterator const& other) const {
            return (myI1 == other.myI1
                    && myI2 == other.myI2
                    && myI3 == other.myI3
                    && myI1End == other.myI1End
                    && myI2End == other.myI2End
                    && myI3End == other.myI3End);
        }
 
        bool operator!= (AnyVehicleIterator const& other) const {
            return !(*this == other);
        }
 
        const MSVehicle* operator->() {
            return **this;
        }
 
        const MSVehicle* operator*();
 
        AnyVehicleIterator& operator++();
 
    private:
        bool nextIsMyVehicles() const;
 
        const MSLane* myLane;
        int myI1;
        int myI2;
        int myI3;
        int myI1End;
        int myI2End;
        int myI3End;
        bool myDownstream;
        int myDirection;
 
    };
 
 
public:
    enum CollisionAction {
        COLLISION_ACTION_NONE,
        COLLISION_ACTION_WARN,
        COLLISION_ACTION_TELEPORT,
        COLLISION_ACTION_REMOVE
    };
 
    MSLane(const std::string& id, double maxSpeed, double friction, double length, MSEdge* const edge,
           int numericalID, const PositionVector& shape, double width,
           SVCPermissions permissions,
           SVCPermissions changeLeft, SVCPermissions changeRight,
           int index, bool isRampAccel,
           const std::string& type,
           const PositionVector& outlineShape);
 
 
    virtual ~MSLane();
 
    inline int getThreadIndex() const {
        return myRNGIndex % MSGlobals::gNumSimThreads;
    }
 
    inline int getRNGIndex() const {
        return myRNGIndex;
    }
 
    SumoRNG* getRNG() const {
        return &myRNGs[myRNGIndex];
    }
 
    static int getNumRNGs() {
        return (int)myRNGs.size();
    }
 
    static void saveRNGStates(OutputDevice& out);
 
    static void loadRNGState(int index, const std::string& state);
 
 
    void addLink(MSLink* link);
 
    void setOpposite(MSLane* oppositeLane);
 
    void setBidiLane(MSLane* bidyLane);
 
    virtual void addSecondaryShape(const PositionVector& /*shape*/) {}
 
    virtual double getLengthGeometryFactor(bool /*secondaryShape*/) const {
        return myLengthGeometryFactor;
    }
 
    virtual const PositionVector& getShape(bool /*secondaryShape*/) const {
        return myShape;
    }
 
 
 
    virtual void addMoveReminder(MSMoveReminder* rem, bool addToVehicles = true);
 
 
    virtual void removeMoveReminder(MSMoveReminder* rem);
 
 
    inline const std::vector< MSMoveReminder* >& getMoveReminders() const {
        return myMoveReminders;
    }
 
 
 
 
    bool insertVehicle(MSVehicle& v);
 
 
    bool isInsertionSuccess(MSVehicle* vehicle, double speed, double pos, double posLat,
                            bool recheckNextLanes,
                            MSMoveReminder::Notification notification);
 
    // XXX: Documentation?
    bool checkFailure(const MSVehicle* aVehicle, double& speed, double& dist, const double nspeed, const bool patchSpeed, const std::string errorMsg, InsertionCheck check) const;
 
    bool lastInsertion(MSVehicle& veh, double mspeed, double posLat, bool patchSpeed);
 
    bool freeInsertion(MSVehicle& veh, double speed, double posLat,
                       MSMoveReminder::Notification notification = MSMoveReminder::NOTIFICATION_DEPARTED);
 
 
    void forceVehicleInsertion(MSVehicle* veh, double pos, MSMoveReminder::Notification notification, double posLat = 0);
 
 
 
 
    virtual double setPartialOccupation(MSVehicle* v);
 
    virtual void resetPartialOccupation(MSVehicle* v);
 
    virtual void setManeuverReservation(MSVehicle* v);
 
    virtual void resetManeuverReservation(MSVehicle* v);
 
    const MSLeaderInfo getLastVehicleInformation(const MSVehicle* ego, double latOffset, double minPos = 0, bool allowCached = true) const;
 
    const MSLeaderInfo getFirstVehicleInformation(const MSVehicle* ego, double latOffset, bool onlyFrontOnLane, double maxPos = std::numeric_limits<double>::max(), bool allowCached = true) const;
 
 
 
    int getVehicleNumber() const {
        return (int)myVehicles.size();
    }
 
    int getVehicleNumberWithPartials() const {
        return (int)myVehicles.size() + (int)myPartialVehicles.size();
    }
 
    int getPartialVehicleNumber() const {
        return (int)myPartialVehicles.size();
    }
 
 
    virtual const VehCont& getVehiclesSecure() const {
        return myVehicles;
    }
 
 
    AnyVehicleIterator anyVehiclesBegin() const {
        return AnyVehicleIterator(this, 0, 0, 0,
                                  (int)myVehicles.size(), (int)myPartialVehicles.size(), (int)myTmpVehicles.size(), true);
    }
 
    AnyVehicleIterator anyVehiclesEnd() const {
        return AnyVehicleIterator(this, (int)myVehicles.size(), (int)myPartialVehicles.size(), (int)myTmpVehicles.size(),
                                  (int)myVehicles.size(), (int)myPartialVehicles.size(), (int)myTmpVehicles.size(), true);
    }
 
    AnyVehicleIterator anyVehiclesUpstreamBegin() const {
        return AnyVehicleIterator(this, (int)myVehicles.size() - 1, (int)myPartialVehicles.size() - 1, (int)myTmpVehicles.size() - 1,
                                  -1, -1, -1, false);
    }
 
    AnyVehicleIterator anyVehiclesUpstreamEnd() const {
        return AnyVehicleIterator(this, -1, -1, -1, -1, -1, -1, false);
    }
 
    virtual void releaseVehicles() const { }
 
 
 
 
 
    inline int getNumericalID() const {
        return myNumericalID;
    }
 
 
    inline const PositionVector& getShape() const {
        return myShape;
    }
 
    inline double getLengthGeometryFactor() const {
        return myLengthGeometryFactor;
    }
 
    inline bool isAccelLane() const {
        return myIsRampAccel;
    }
 
    const std::string& getLaneType() const {
        return myLaneType;
    }
 
    /* @brief fit the given lane position to a visibly suitable geometry position
     * (lane length might differ from geometry length) */
    inline double interpolateLanePosToGeometryPos(double lanePos) const {
        return lanePos * myLengthGeometryFactor;
    }
 
    /* @brief fit the given lane position to a visibly suitable geometry position
     * and return the coordinates */
    inline const Position geometryPositionAtOffset(double offset, double lateralOffset = 0) const {
        return myShape.positionAtOffset(interpolateLanePosToGeometryPos(offset), lateralOffset);
    }
 
    /* @brief fit the given geometry position to a valid lane position
     * (lane length might differ from geometry length) */
    inline double interpolateGeometryPosToLanePos(double geometryPos) const {
        return geometryPos / myLengthGeometryFactor;
    }
 
    inline double getVehicleMaxSpeed(const SUMOTrafficObject* const veh) const {
        return getVehicleMaxSpeed(veh, veh->getMaxSpeed());
    }
 
 
    inline double getVehicleMaxSpeed(const SUMOTrafficObject* const veh, double vehMaxSpeed) const {
        if (myRestrictions != nullptr) {
            std::map<SUMOVehicleClass, double>::const_iterator r = myRestrictions->find(veh->getVClass());
            if (r != myRestrictions->end()) {
                if (mySpeedByVSS || mySpeedByTraCI) {
                    return MIN2(myMaxSpeed, MIN2(vehMaxSpeed, r->second * veh->getChosenSpeedFactor()));
                } else {
                    return MIN2(vehMaxSpeed, r->second * veh->getChosenSpeedFactor());
                }
            }
        }
        return MIN2(vehMaxSpeed, myMaxSpeed * veh->getChosenSpeedFactor());
    }
 
 
    inline double getSpeedLimit() const {
        return myMaxSpeed;
    }
 
    inline double getFrictionCoefficient() const {
        return myFrictionCoefficient;
    }
 
    inline double getLength() const {
        return myLength;
    }
 
 
    inline SVCPermissions getPermissions() const {
        return myPermissions;
    }
 
    inline SVCPermissions getChangeLeft() const {
        return myChangeLeft;
    }
 
    inline SVCPermissions getChangeRight() const {
        return myChangeRight;
    }
 
    double getWidth() const {
        return myWidth;
    }
 
    int getIndex() const {
        return myIndex;
    }
 
    int getCrossingIndex() const;
 
 
 
    virtual void planMovements(const SUMOTime t);
 
    virtual void setJunctionApproaches() const;
 
    void updateLeaderInfo(const MSVehicle* veh, VehCont::reverse_iterator& vehPart, VehCont::reverse_iterator& vehRes, MSLeaderInfo& ahead) const;
 
    virtual void executeMovements(const SUMOTime t);
 
    virtual void integrateNewVehicles();
 
    void markRecalculateBruttoSum();
 
    void updateLengthSum();
 
 
    inline bool needsCollisionCheck() const {
        return myNeedsCollisionCheck;
    }
 
    inline void requireCollisionCheck() {
        myNeedsCollisionCheck = true;
    }
 
    virtual void detectCollisions(SUMOTime timestep, const std::string& stage);
 
 
    virtual bool appropriate(const MSVehicle* veh) const;
 
 
    const std::vector<MSLink*>& getLinkCont() const {
        return myLinks;
    }
 
    const MSLink* getLinkTo(const MSLane* const) const;
 
    const MSLane* getInternalFollowingLane(const MSLane* const) const;
 
    const MSLink* getEntryLink() const;
 
 
    bool empty() const {
        assert(myVehBuffer.size() == 0);
        return myVehicles.empty();
    }
 
    void setMaxSpeed(double val, bool byVSS = false, bool byTraCI = false, double jamThreshold = -1);
 
    void setFrictionCoefficient(double val);
 
    void setLength(double val);
 
    MSEdge& getEdge() const {
        return *myEdge;
    }
 
    const MSJunction* getFromJunction() const;
    const MSJunction* getToJunction() const;
 
    const MSEdge* getNextNormal() const;
 
 
    const MSLane* getFirstInternalInConnection(double& offset) const;
 
 
 
    static bool dictionary(const std::string& id, MSLane* lane);
 
 
    static MSLane* dictionary(const std::string& id);
 
 
    static void clear();
 
 
    static int dictSize() {
        return (int)myDict.size();
    }
 
 
    static void insertIDs(std::vector<std::string>& into);
 
 
    template<class RTREE>
    static void fill(RTREE& into);
 
 
    static void initRNGs(const OptionsCont& oc);
 
 
 
    // XXX: succLink does not exist... Documentation?
    static std::vector<MSLink*>::const_iterator succLinkSec(const SUMOVehicle& veh,
            int nRouteSuccs,
            const MSLane& succLinkSource,
            const std::vector<MSLane*>& conts);
 
 
    inline bool isLinkEnd(std::vector<MSLink*>::const_iterator& i) const {
        return i == myLinks.end();
    }
 
    inline bool isLinkEnd(std::vector<MSLink*>::iterator& i) {
        return i == myLinks.end();
    }
 
    inline bool isEmpty() const {
        return myVehicles.empty() && myPartialVehicles.empty();
    }
 
    bool isInternal() const;
 
    bool isNormal() const;
 
    bool isCrossing() const;
 
    bool isWalkingArea() const;
 
    MSVehicle* getLastFullVehicle() const;
 
    MSVehicle* getFirstFullVehicle() const;
 
    MSVehicle* getLastAnyVehicle() const;
 
    MSVehicle* getFirstAnyVehicle() const;
 
    /* @brief remove the vehicle from this lane
     * @param[notify] whether moveReminders of the vehicle shall be triggered
     */
    virtual MSVehicle* removeVehicle(MSVehicle* remVehicle, MSMoveReminder::Notification notification, bool notify = true);
 
    void leftByLaneChange(MSVehicle* v);
    void enteredByLaneChange(MSVehicle* v);
 
    MSLane* getParallelLane(int offset, bool includeOpposite = true) const;
 
 
    void setPermissions(SVCPermissions permissions, long long transientID);
    void resetPermissions(long long transientID);
    bool hadPermissionChanges() const;
 
    void setChangeLeft(SVCPermissions permissions);
 
    void setChangeRight(SVCPermissions permissions);
 
    inline bool allowsVehicleClass(SUMOVehicleClass vclass) const {
        return (myPermissions & vclass) == vclass;
    }
 
    bool allowsVehicleClass(SUMOVehicleClass vclass, int routingMode) const;
 
    inline bool allowsChangingLeft(SUMOVehicleClass vclass) const {
        return (myChangeLeft & vclass) == vclass;
    }
 
    inline bool allowsChangingRight(SUMOVehicleClass vclass) const {
        return (myChangeRight & vclass) == vclass;
    }
 
    void addIncomingLane(MSLane* lane, MSLink* viaLink);
 
 
    struct IncomingLaneInfo {
        MSLane* lane;
        double length;
        MSLink* viaLink;
    };
 
    const std::vector<IncomingLaneInfo>& getIncomingLanes() const {
        return myIncomingLanes;
    }
 
 
    void addApproachingLane(MSLane* lane, bool warnMultiCon);
    inline bool isApproachedFrom(MSEdge* const edge) {
        return myApproachingLanes.find(edge) != myApproachingLanes.end();
    }
    bool isApproachedFrom(MSEdge* const edge, MSLane* const lane);
 
    double getVehicleStopOffset(const MSVehicle* veh) const;
 
    const StopOffset& getLaneStopOffsets() const;
 
    void setLaneStopOffset(const StopOffset& stopOffset);
 
    enum MinorLinkMode {
        FOLLOW_NEVER = 0,
        FOLLOW_ALWAYS = 1,
        FOLLOW_ONCOMING = 2,
    };
 
    MSLeaderDistanceInfo getFollowersOnConsecutive(const MSVehicle* ego, double backOffset,
            bool allSublanes, double searchDist = -1, MinorLinkMode mLinkMode = FOLLOW_ALWAYS) const;
 
    double getMissingRearGap(const MSVehicle* leader, double backOffset, double leaderSpeed) const;
 
    std::pair<MSVehicle* const, double> getLeader(const MSVehicle* veh, const double vehPos, const std::vector<MSLane*>& bestLaneConts, double dist = -1, bool checkTmpVehicles = false) const;
 
    std::pair<MSVehicle* const, double> getLeaderOnConsecutive(double dist, double seen,
            double speed, const MSVehicle& veh, const std::vector<MSLane*>& bestLaneConts, bool considerCrossingFoes = true) const;
 
    void getLeadersOnConsecutive(double dist, double seen, double speed, const MSVehicle* ego,
                                 const std::vector<MSLane*>& bestLaneConts, MSLeaderDistanceInfo& result, bool oppositeDirection = false) const;
 
 
    void addLeaders(const MSVehicle* vehicle, double vehPos, MSLeaderDistanceInfo& result, bool oppositeDirection = false);
 
 
    std::pair<MSVehicle* const, double> getCriticalLeader(double dist, double seen, double speed, const MSVehicle& veh) const;
 
    /* @brief return the partial vehicle closest behind ego or 0
     * if no such vehicle exists */
    MSVehicle* getPartialBehind(const MSVehicle* ego) const;
 
    MSLeaderInfo getPartialBeyond() const;
 
    std::set<MSVehicle*> getSurroundingVehicles(double startPos, double downstreamDist, double upstreamDist, std::shared_ptr<LaneCoverageInfo> checkedLanes) const;
 
    std::set<MSVehicle*> getVehiclesInRange(const double a, const double b) const;
 
    std::vector<const MSJunction*> getUpcomingJunctions(double pos, double range, const std::vector<MSLane*>& contLanes) const;
 
    std::vector<const MSLink*> getUpcomingLinks(double pos, double range, const std::vector<MSLane*>& contLanes) const;
 
    MSLane* getLogicalPredecessorLane() const;
 
    const MSLane* getNormalPredecessorLane() const;
 
    const MSLane* getNormalSuccessorLane() const;
 
    MSLane* getLogicalPredecessorLane(const MSEdge& fromEdge) const;
 
 
    MSLane* getCanonicalPredecessorLane() const;
 
 
    MSLane* getCanonicalSuccessorLane() const;
 
    LinkState getIncomingLinkState() const;
 
    const std::vector<std::pair<const MSLane*, const MSEdge*> > getOutgoingViaLanes() const;
 
    std::vector<const MSLane*> getNormalIncomingLanes() const;
 
 
 
    double getMeanSpeed() const;
 
    double getMeanSpeedBike() const;
 
    double getWaitingSeconds() const;
 
 
    double getBruttoOccupancy() const;
 
 
    double getNettoOccupancy() const;
 
 
    inline double getBruttoVehLenSum() const {
        return myBruttoVehicleLengthSum;
    }
 
 
    template<PollutantsInterface::EmissionType ET>
    double getEmissions() const {
        double ret = 0;
        for (MSVehicle* const v : getVehiclesSecure()) {
            ret += v->getEmissions<ET>();
        }
        releaseVehicles();
        return ret;
    }
 
 
    double getHarmonoise_NoiseEmissions() const;
 
    void setRightSideOnEdge(double value, int rightmostSublane) {
        myRightSideOnEdge = value;
        myRightmostSublane = rightmostSublane;
    }
 
    void initRestrictions();
 
    void checkBufferType();
 
    double getRightSideOnEdge() const {
        return myRightSideOnEdge;
    }
 
    int getRightmostSublane() const {
        return myRightmostSublane;
    }
 
    double getCenterOnEdge() const {
        return myRightSideOnEdge + 0.5 * myWidth;
    }
 
    void sortPartialVehicles();
 
    void sortManeuverReservations();
 
    MSLane* getOpposite() const;
 
    MSLane* getParallelOpposite() const;
 
    double getOppositePos(double pos) const;
 
    /* @brief find leader for a vehicle depending on the relative driving direction
     * @param[in] ego The ego vehicle
     * @param[in] dist The look-ahead distance when looking at consecutive lanes
     * @param[in] oppositeDir Whether the lane has the opposite driving direction of ego
     * @return the leader vehicle and its gap to ego
     */
    std::pair<MSVehicle* const, double> getOppositeLeader(const MSVehicle* ego, double dist, bool oppositeDir, MinorLinkMode mLinkMode = MinorLinkMode::FOLLOW_NEVER) const;
 
    /* @brief find follower for a vehicle that is located on the opposite of this lane
     * @param[in] ego The ego vehicle
     * @return the follower vehicle and its gap to ego
     */
    std::pair<MSVehicle* const, double> getOppositeFollower(const MSVehicle* ego) const;
 
 
    std::pair<MSVehicle* const, double> getFollower(const MSVehicle* ego, double egoPos, double dist, MinorLinkMode mLinkMode) const;
 
 
    void addParking(MSBaseVehicle* veh);
 
    virtual void removeParking(MSBaseVehicle* veh);
 
    const std::set<const MSBaseVehicle*>& getParkingVehicles() const {
        return myParkingVehicles;
    }
 
    virtual bool isSelected() const {
        return false;
    }
 
    MSLane* getBidiLane() const;
 
    bool mustCheckJunctionCollisions() const;
 
#ifdef HAVE_FOX
    MFXWorkerThread::Task* getPlanMoveTask(const SUMOTime time) {
        mySimulationTask.init(&MSLane::planMovements, time);
        return &mySimulationTask;
    }
 
    MFXWorkerThread::Task* getExecuteMoveTask(const SUMOTime time) {
        mySimulationTask.init(&MSLane::executeMovements, time);
        return &mySimulationTask;
    }
 
    MFXWorkerThread::Task* getLaneChangeTask(const SUMOTime time) {
        mySimulationTask.init(&MSLane::changeLanes, time);
        return &mySimulationTask;
    }
#endif
 
    std::vector<StopWatch<std::chrono::nanoseconds> >& getStopWatch() {
        return myStopWatch;
    }
 
    void changeLanes(const SUMOTime time);
 
 
    void saveState(OutputDevice& out);
 
    void clearState();
 
    void loadState(const std::vector<SUMOVehicle*>& vehs);
 
 
    /* @brief helper function for state saving: checks whether any outgoing
     * links are being approached */
    bool hasApproaching() const;
 
 
 
    void visit(const MSLane::StoringVisitor& cont) const {
        cont.add(this);
    }
 
    bool hasPedestrians() const;
 
    std::pair<const MSPerson*, double> nextBlocking(double minPos, double minRight, double maxLeft, double stopTime = 0, bool bidi = false) const;
 
    double getSpaceTillLastStanding(const MSVehicle* ego, bool& foundStopped) const;
 
    double getMaximumBrakeDist() const;
 
    inline const PositionVector* getOutlineShape() const {
        return myOutlineShape;
    }
 
    static void initCollisionOptions(const OptionsCont& oc);
    static void initCollisionAction(const OptionsCont& oc, const std::string& option, CollisionAction& myAction);
 
    static CollisionAction getCollisionAction() {
        return myCollisionAction;
    }
 
    static CollisionAction getIntermodalCollisionAction() {
        return myIntermodalCollisionAction;
    }
 
    static DepartSpeedDefinition& getDefaultDepartSpeedDefinition() {
        return myDefaultDepartSpeedDefinition;
    }
 
    static double& getDefaultDepartSpeed() {
        return myDefaultDepartSpeed;
    }
 
 
    static const long CHANGE_PERMISSIONS_PERMANENT = 0;
    static const long CHANGE_PERMISSIONS_GUI = 1;
 
protected:
    virtual void swapAfterLaneChange(SUMOTime t);
 
    virtual void incorporateVehicle(MSVehicle* veh, double pos, double speed, double posLat,
                                    const MSLane::VehCont::iterator& at,
                                    MSMoveReminder::Notification notification = MSMoveReminder::NOTIFICATION_DEPARTED);
 
    void detectPedestrianJunctionCollision(const MSVehicle* collider, const PositionVector& colliderBoundary, const MSLane* foeLane,
                                           SUMOTime timestep, const std::string& stage,
                                           std::set<const MSVehicle*, ComparatorNumericalIdLess>& toRemove,
                                           std::set<const MSVehicle*, ComparatorNumericalIdLess>& toTeleport);
 
    bool detectCollisionBetween(SUMOTime timestep, const std::string& stage, MSVehicle* collider, MSVehicle* victim,
                                std::set<const MSVehicle*, ComparatorNumericalIdLess>& toRemove,
                                std::set<const MSVehicle*, ComparatorNumericalIdLess>& toTeleport) const;
 
    void handleCollisionBetween(SUMOTime timestep, const std::string& stage, const MSVehicle* collider, const MSVehicle* victim,
                                double gap, double latGap,
                                std::set<const MSVehicle*, ComparatorNumericalIdLess>& toRemove,
                                std::set<const MSVehicle*, ComparatorNumericalIdLess>& toTeleport) const;
 
    void handleIntermodalCollisionBetween(SUMOTime timestep, const std::string& stage, const MSVehicle* collider, const MSTransportable* victim,
                                          double gap, const std::string& collisionType,
                                          std::set<const MSVehicle*, ComparatorNumericalIdLess>& toRemove,
                                          std::set<const MSVehicle*, ComparatorNumericalIdLess>& toTeleport) const;
 
    /* @brief determine depart speed and whether it may be patched
     * @param[in] veh The departing vehicle
     * @param[out] whether the speed may be patched to account for safety
     * @return the depart speed
     */
    double getDepartSpeed(const MSVehicle& veh, bool& patchSpeed);
 
    /* @brief determine the lateral depart position
     * @param[in] veh The departing vehicle
     * @return the lateral depart position
     */
    double getDepartPosLat(const MSVehicle& veh);
 
    double safeInsertionSpeed(const MSVehicle* veh, double seen, const MSLeaderInfo& leaders, double speed);
 
    bool checkForPedestrians(const MSVehicle* aVehicle, double& speed, double& dist, double pos, bool patchSpeed) const;
 
    bool hasApproaching(const std::vector<MSLink*>& links) const;
 
    double getFractionalVehicleLength(bool brutto) const;
 
    static bool isFrontalCollision(const MSVehicle* collider, const MSVehicle* victim);
 
    int myNumericalID;
 
    PositionVector myShape;
 
    PositionVector* myOutlineShape = nullptr;
 
    int myIndex;
 
    VehCont myVehicles;
 
    VehCont myPartialVehicles;
 
    VehCont myTmpVehicles;
 
    MFXSynchQue<MSVehicle*, std::vector<MSVehicle*> > myVehBuffer;
 
    VehCont myManeuverReservations;
 
    /* @brief list of vehicles that are parking near this lane
     * (not necessarily on the road but having reached their stop on this lane)
     * */
    std::set<const MSBaseVehicle*> myParkingVehicles;
 
    double myLength;
 
    const double myWidth;
 
    StopOffset myLaneStopOffset;
 
    MSEdge* const myEdge;
 
    double myMaxSpeed;
    double myFrictionCoefficient;
 
    bool mySpeedByVSS;
 
    bool mySpeedByTraCI;
 
    SVCPermissions myPermissions;
 
    SVCPermissions myChangeLeft;
    SVCPermissions myChangeRight;
 
    SVCPermissions myOriginalPermissions;
 
    const std::map<SUMOVehicleClass, double>* myRestrictions;
 
    std::vector<IncomingLaneInfo> myIncomingLanes;
 
    mutable MSLane* myLogicalPredecessorLane;
 
    mutable MSLane* myCanonicalPredecessorLane;
 
    mutable MSLane* myCanonicalSuccessorLane;
 
    double myBruttoVehicleLengthSum;
 
    double myNettoVehicleLengthSum;
 
    double myBruttoVehicleLengthSumToRemove;
 
    double myNettoVehicleLengthSumToRemove;
 
    bool myRecalculateBruttoSum;
 
    std::vector<MSLink*> myLinks;
 
    std::map<MSEdge*, std::vector<MSLane*> > myApproachingLanes;
 
    mutable MSLeaderInfo myLeaderInfo;
    mutable MSLeaderInfo myFollowerInfo;
 
    mutable SUMOTime myLeaderInfoTime;
    mutable SUMOTime myFollowerInfoTime;
 
    const double myLengthGeometryFactor;
 
    const bool myIsRampAccel;
 
    const std::string myLaneType;
 
    double myRightSideOnEdge;
    int myRightmostSublane;
 
    bool myNeedsCollisionCheck;
 
    // @brief the neighboring opposite direction or nullptr
    MSLane* myOpposite;
 
    // @brief bidi lane or nullptr
    MSLane* myBidiLane;
 
    // @brief transient changes in permissions
    std::map<long long, SVCPermissions> myPermissionChanges;
 
    // @brief index of the associated thread-rng
    int myRNGIndex;
 
    typedef std::map< std::string, MSLane* > DictType;
 
    static DictType myDict;
 
    static std::vector<SumoRNG> myRNGs;
 
private:
    std::vector< MSMoveReminder* > myMoveReminders;
 
    static CollisionAction myCollisionAction;
    static CollisionAction myIntermodalCollisionAction;
    static bool myCheckJunctionCollisions;
    static double myCheckJunctionCollisionMinGap;
    static SUMOTime myCollisionStopTime;
    static SUMOTime myIntermodalCollisionStopTime;
    static double myCollisionMinGapFactor;
    static bool myExtrapolateSubstepDepart;
    static DepartSpeedDefinition myDefaultDepartSpeedDefinition;
    static double myDefaultDepartSpeed;
    class vehicle_position_sorter {
    public:
        explicit vehicle_position_sorter(const MSLane* lane) :
            myLane(lane) {
        }
 
 
        int operator()(MSVehicle* v1, MSVehicle* v2) const;
 
        const MSLane* myLane;
 
    };
 
    class vehicle_natural_position_sorter {
    public:
        explicit vehicle_natural_position_sorter(const MSLane* lane) :
            myLane(lane) {
        }
 
 
        int operator()(MSVehicle* v1, MSVehicle* v2) const;
 
        const MSLane* myLane;
 
    };
 
    class by_connections_to_sorter {
    public:
        explicit by_connections_to_sorter(const MSEdge* const e);
 
        int operator()(const MSEdge* const e1, const MSEdge* const e2) const;
 
    private:
        const MSEdge* const myEdge;
        double myLaneDir;
    };
 
 
 
    class incoming_lane_priority_sorter {
    public:
        explicit incoming_lane_priority_sorter(const MSLane* targetLane);
 
        int operator()(const IncomingLaneInfo& lane1, const IncomingLaneInfo& lane2) const;
 
    private:
        const MSLane* const myLane;
        double myLaneDir;
    };
 
 
    class outgoing_lane_priority_sorter {
    public:
        explicit outgoing_lane_priority_sorter(const MSLane* sourceLane);
 
        int operator()(const MSLink* link1, const MSLink* link2) const;
 
    private:
        double myLaneDir;
    };
 
    class edge_finder {
    public:
        edge_finder(MSEdge* e) : myEdge(e) {}
        bool operator()(const IncomingLaneInfo& ili) const {
            return &(ili.lane->getEdge()) == myEdge;
        }
    private:
        const MSEdge* const myEdge;
    };
 
#ifdef HAVE_FOX
    typedef void(MSLane::*Operation)(const SUMOTime);
 
    class SimulationTask : public MFXWorkerThread::Task {
    public:
        SimulationTask(MSLane& l, const SUMOTime time)
            : myLane(l), myTime(time) {}
        void init(Operation operation, const SUMOTime time) {
            myOperation = operation;
            myTime = time;
        }
        void run(MFXWorkerThread* /*context*/) {
            try {
                (myLane.*(myOperation))(myTime);
            } catch (ProcessError& e) {
                WRITE_ERROR(e.what());
            }
        }
    private:
        Operation myOperation = nullptr;
        MSLane& myLane;
        SUMOTime myTime;
    private:
        SimulationTask& operator=(const SimulationTask&) = delete;
    };
 
    SimulationTask mySimulationTask;
    mutable FXMutex myLeaderInfoMutex;
    mutable FXMutex myFollowerInfoMutex;
    mutable FXMutex myPartialOccupatorMutex;
#endif
    std::vector<StopWatch<std::chrono::nanoseconds> > myStopWatch;
 
private:
    MSLane(const MSLane&) = delete;
 
    MSLane& operator=(const MSLane&) = delete;
 
 
};
 
// specialized implementation for speedup and avoiding warnings
#define LANE_RTREE_QUAL RTree<MSLane*, MSLane, float, 2, MSLane::StoringVisitor>
 
template<>
inline float LANE_RTREE_QUAL::RectSphericalVolume(Rect* a_rect) {
    ASSERT(a_rect);
    const float extent0 = a_rect->m_max[0] - a_rect->m_min[0];
    const float extent1 = a_rect->m_max[1] - a_rect->m_min[1];
    return .78539816f * (extent0 * extent0 + extent1 * extent1);
}
 
template<>
inline LANE_RTREE_QUAL::Rect LANE_RTREE_QUAL::CombineRect(Rect* a_rectA, Rect* a_rectB) {
    ASSERT(a_rectA && a_rectB);
    Rect newRect;
    newRect.m_min[0] = rtree_min(a_rectA->m_min[0], a_rectB->m_min[0]);
    newRect.m_max[0] = rtree_max(a_rectA->m_max[0], a_rectB->m_max[0]);
    newRect.m_min[1] = rtree_min(a_rectA->m_min[1], a_rectB->m_min[1]);
    newRect.m_max[1] = rtree_max(a_rectA->m_max[1], a_rectB->m_max[1]);
    return newRect;
}