AbstractLanePerception (Open Traffic Sim road classes 0.10.00 API)

java.lang.Object
- org.opentrafficsim.core.gtu.perception.AbstractPerception
- - org.opentrafficsim.road.gtu.lane.perceptionold.AbstractLanePerception

All Implemented Interfaces:

Serializable, org.opentrafficsim.core.gtu.perception.Perception, LanePerception

Direct Known Subclasses:

LanePerceptionFull
```
public abstract class AbstractLanePerception
extends org.opentrafficsim.core.gtu.perception.AbstractPerception
implements LanePerception
```
The perception module of a GTU based on lanes. It is responsible for perceiving (sensing) the environment of the GTU, which includes the locations of other GTUs. Perception is done at a certain time, and the perceived information might have a limited validity. In that sense, Perception is stateful. Information can be requested as often as needed, but will only be recalculated when asked explicitly. This abstract class provides the building blocks for lane-based perception.
Perception for lane-based GTUs involves information about GTUs in front of the owner GTU on the same lane (the 'leader' GTU), parallel vehicles (important if we want to change lanes), distance to other vehicles on parallel lanes, as well in front as to the back (important if we want to change lanes), and information about obstacles, traffic lights, speed signs, and ending lanes.
Copyright (c) 2013-2016 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
BSD-style license. See OpenTrafficSim License.
$LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $, initial version Nov 15, 2015

Author:

Alexander Verbraeck, Peter Knoppers

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description

AbstractLanePerception(LaneBasedGTU gtu)
Create a new LanePerception module.

Constructors
Constructor and Description
`AbstractLanePerception(LaneBasedGTU gtu)` Create a new LanePerception module.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Map<Lane,Set<Lane>>`	`accessibleAdjacentLaneMap(org.opentrafficsim.core.network.LateralDirectionality lateralDirection)`
`Lane`	`bestAccessibleAdjacentLane(Lane currentLane, org.opentrafficsim.core.network.LateralDirectionality lateralDirection, org.djunits.value.vdouble.scalar.Length longitudinalPosition)` Determine whether there is a lane to the left or to the right of this lane, which is accessible from this lane, or null if no lane could be found.
`boolean`	`existsGtuAlongside(org.opentrafficsim.core.network.LateralDirectionality lat)` Whether there is a GTU alongside, i.e.
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<Boolean>`	`existsGtuAlongsideTimeStamped(org.opentrafficsim.core.network.LateralDirectionality lat)` Whether there is a GTU alongside, i.e.
`Map<Lane,Set<Lane>>`	`getAccessibleAdjacentLanesLeft()`
`Map<Lane,Set<Lane>>`	`getAccessibleAdjacentLanesRight()`
`Headway`	`getBackwardHeadway()`
`SortedSet<RelativeLane>`	`getCurrentCrossSection()` Returns a set of relative lanes representing the current cross section.
`SortedSet<AbstractHeadwayGTU>`	`getFirstFollowers(org.opentrafficsim.core.network.LateralDirectionality lat)` Set of followers on a lane, which is usually 0 or 1, but possibly more in case of an upstream merge with no intermediate GTU.
`SortedSet<AbstractHeadwayGTU>`	`getFirstLeaders(org.opentrafficsim.core.network.LateralDirectionality lat)` Set of leaders on a lane, which is usually 0 or 1, but possibly more in case of a downstream split with no intermediate GTU.
`SortedSet<AbstractHeadwayGTU>`	`getFollowers(RelativeLane lane)` Set of followers on a lane, including adjacent GTU's who's REAR is back of the own vehicle REAR.
`Headway`	`getForwardHeadway()`
`LaneBasedGTU`	`getGtu()`
`SortedSet<InfrastructureLaneChangeInfo>`	`getInfrastructureLaneChangeInfo(RelativeLane lane)` Returns infrastructure lane change info of a lane.
`SortedSet<HeadwayConflict>`	`getIntersectionConflicts(RelativeLane lane)` Returns a set of intersection conflicts along the route.
`LanePathInfo`	`getLanePathInfo()` Retrieve the last perceived lane path info.
`SortedSet<AbstractHeadwayGTU>`	`getLeaders(RelativeLane lane)` Set of leaders on a lane, including adjacent GTU's who's FRONT is ahead of the own vehicle FRONT.
`org.djunits.value.vdouble.scalar.Length`	`getLegalLaneChangePossibility(RelativeLane fromLane, org.opentrafficsim.core.network.LateralDirectionality lat)` Returns the distance over which a lane change remains legally possible.
`Collection<Headway>`	`getNeighboringHeadways(org.opentrafficsim.core.network.LateralDirectionality lateralDirection)`
`Collection<Headway>`	`getNeighboringHeadwaysLeft()`
`Collection<Headway>`	`getNeighboringHeadwaysRight()`
`Collection<Headway>`	`getParallelHeadways(org.opentrafficsim.core.network.LateralDirectionality lateralDirection)`
`Collection<Headway>`	`getParallelHeadwaysLeft()`
`Collection<Headway>`	`getParallelHeadwaysRight()`
`org.djunits.value.vdouble.scalar.Length`	`getPhysicalLaneChangePossibility(RelativeLane fromLane, org.opentrafficsim.core.network.LateralDirectionality lat)` Returns the distance over which a lane change remains physically possible.
`org.djunits.value.vdouble.scalar.Speed`	`getSpeedLimit()`
`SpeedLimitProspect`	`getSpeedLimitProspect(RelativeLane lane)` Returns the prospect for speed limits on a lane (dynamic speed limits may vary between lanes).
`int`	`getSplitNumber(InfrastructureLaneChangeInfo info)` Split number of given infrastructure lane change info, 0 if it does not regard a split.
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<Map<Lane,Set<Lane>>>`	`getTimeStampedAccessibleAdjacentLanesLeft()`
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<Map<Lane,Set<Lane>>>`	`getTimeStampedAccessibleAdjacentLanesRight()`
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<Headway>`	`getTimeStampedBackwardHeadway()`
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<RelativeLane>>`	`getTimeStampedCurrentCrossSection()` Returns a set of relative lanes representing the current cross section.
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<AbstractHeadwayGTU>>`	`getTimeStampedFirstFollowers(org.opentrafficsim.core.network.LateralDirectionality lat)` Set of followers on a lane, which is usually 0 or 1, but possibly more in case of an upstream merge with no intermediate GTU.
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<AbstractHeadwayGTU>>`	`getTimeStampedFirstLeaders(org.opentrafficsim.core.network.LateralDirectionality lat)` Set of leaders on a lane, which is usually 0 or 1, but possibly more in case of a downstream split with no intermediate GTU.
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<AbstractHeadwayGTU>>`	`getTimeStampedFollowers(RelativeLane lane)` Set of followers on a lane, including adjacent GTU's who's REAR is back of the own vehicle REAR.
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<Headway>`	`getTimeStampedForwardHeadway()`
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<InfrastructureLaneChangeInfo>>`	`getTimeStampedInfrastructureLaneChangeInfo(RelativeLane lane)` Returns infrastructure lane change info of a lane.
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<HeadwayConflict>>`	`getTimeStampedIntersectionConflicts(RelativeLane lane)` Returns a set of intersection conflicts along the route.
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<AbstractHeadwayGTU>>`	`getTimeStampedLeaders(RelativeLane lane)` Set of leaders on a lane, including adjacent GTU's who's FRONT is ahead of the own vehicle FRONT.
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<org.djunits.value.vdouble.scalar.Length>`	`getTimeStampedLegalLaneChangePossibility(RelativeLane fromLane, org.opentrafficsim.core.network.LateralDirectionality lat)` Returns the distance over which a lane change remains legally possible.
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<Collection<Headway>>`	`getTimeStampedNeighboringHeadwaysLeft()`
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<Collection<Headway>>`	`getTimeStampedNeighboringHeadwaysRight()`
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<Collection<Headway>>`	`getTimeStampedParallelHeadwaysLeft()`
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<Collection<Headway>>`	`getTimeStampedParallelHeadwaysRight()`
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<org.djunits.value.vdouble.scalar.Length>`	`getTimeStampedPhysicalLaneChangePossibility(RelativeLane fromLane, org.opentrafficsim.core.network.LateralDirectionality lat)` Returns the distance over which a lane change remains physically possible.
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<org.djunits.value.vdouble.scalar.Speed>`	`getTimeStampedSpeedLimit()`
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<SpeedLimitProspect>`	`getTimeStampedSpeedLimitProspect(RelativeLane lane)` Returns the prospect for speed limits on a lane (dynamic speed limits may vary between lanes).
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<Integer>`	`getTimeStampedSplitNumber(InfrastructureLaneChangeInfo info)` Split number of given infrastructure lane change info, 0 if it does not regard a split.
`org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<HeadwayTrafficLight>>`	`getTimeStampedTrafficLights()` Returns a set of traffic lights along the route.
`SortedSet<HeadwayTrafficLight>`	`getTrafficLights()` Returns a set of traffic lights along the route.
`void`	`updateAccessibleAdjacentLanesLeft()` Build a set of Lanes that is adjacent to the given lane that this GTU can enter, for the left lateral direction.
`void`	`updateAccessibleAdjacentLanesRight()` Build a set of Lanes that is adjacent to the given lane that this GTU can enter, for the left lateral direction.
`void`	`updateBackwardHeadway()` Update who's behind us and how far away the nearest object (e.g., a GTU) is.
`void`	`updateCurrentCrossSection()` Updates a set of relative lanes representing the current cross section.
`void`	`updateFirstFollowers()` Updates of followers on a lane, which is usually 0 or 1, but possibly more in case of an upstream merge with no intermediate GTU.
`void`	`updateFirstLeaders()` Updates of leaders on a lane, which is usually 0 or 1, but possibly more in case of a downstream split with no intermediate GTU.
`void`	`updateFollowers()` Updates set of followers on a lane, including adjacent GTU's who's REAR is back of the own vehicle REAR.
`void`	`updateForwardHeadway()` Update who's in front of us and how far away the nearest object (e.g., a GTU) is.
`void`	`updateGtuAlongside()` Updates whether there is a GTU alongside, i.e.
`void`	`updateInfrastructureLaneChangeInfo()` Updates infrastructure lane change info of a lane.
`void`	`updateIntersectionConflicts()` Updates a set of intersection conflicts along the route.
`void`	`updateLanePathInfo()`
`void`	`updateLaneTrafficLeft()` Update the information about the objects (e.g., GTUs) left of our GTU, and behind us or ahead on the left hand side.
`void`	`updateLaneTrafficRight()` Update the information about the objects (e.g., GTUs) right of our GTU, and behind us or ahead on the left hand side.
`void`	`updateLeaders()` Updates set of leaders on a lane, including adjacent GTU's who's FRONT is ahead of the own vehicle FRONT.
`void`	`updateLegalLaneChangePossibility()` Updates the distance over which a lane change remains legally possible.
`void`	`updateParallelHeadwaysLeft()` Update the information about the objects (e.g., GTUs) parallel to our GTU on the left side.
`void`	`updateParallelHeadwaysRight()` Update the information about the objects (e.g., GTUs) parallel to our GTU on the right side.
`void`	`updatePhysicalLaneChangePossibility()` Updates the distance over which a lane change remains physically possible.
`void`	`updateSpeedLimit()` Update the perceived speed limit.
`void`	`updateSpeedLimitProspect()` Updates the prospect for speed limits on a lane (dynamic speed limits may vary between lanes).
`void`	`updateSplitNumber()` Updates split numbers of infrastructure lane change info, 0 if it does not regard a split.
`void`	`updateTrafficLights()` Updates a set of traffic lights along the route.

Methods inherited from class org.opentrafficsim.core.gtu.perception.AbstractPerception
addPerceptionCategory, contains, getPerceptionCategory, perceive, removePerceptionCategory, toString

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.opentrafficsim.core.gtu.perception.Perception
addPerceptionCategory, contains, getPerceptionCategory, perceive, removePerceptionCategory

- Constructor Detail
  - AbstractLanePerception
```
public AbstractLanePerception(LaneBasedGTU gtu)
```
    Create a new LanePerception module. Because the constructor is often called inside the constructor of a GTU, this constructor does not ask for the pointer to the GTU, as it is often impossible to provide at the time of construction. Use the setter of the GTU instead.
    
    Parameters:
    
    gtu - GTU
- Method Detail
  - updateLanePathInfo
```
public final void updateLanePathInfo()
                              throws org.opentrafficsim.core.gtu.GTUException,
                                     org.opentrafficsim.core.network.NetworkException,
                                     org.opentrafficsim.core.gtu.behavioralcharacteristics.ParameterException
```
    Throws:
    
    org.opentrafficsim.core.gtu.GTUException - when the GTU was not initialized yet.
    
    org.opentrafficsim.core.network.NetworkException - when the speed limit for a GTU type cannot be retrieved from the network.
    
    org.opentrafficsim.core.gtu.behavioralcharacteristics.ParameterException - in case of not being able to retrieve parameter ParameterTypes.LOOKAHEAD
  - updateSpeedLimit
```
public final void updateSpeedLimit()
                            throws org.opentrafficsim.core.gtu.GTUException,
                                   org.opentrafficsim.core.network.NetworkException
```
    Update the perceived speed limit.
    
    Specified by:
    
    updateSpeedLimit in interface LanePerception
    
    Throws:
    
    org.opentrafficsim.core.gtu.GTUException - when the GTU was not initialized yet.
    
    org.opentrafficsim.core.network.NetworkException - when the speed limit for a GTU type cannot be retreived from the network.
  - updateForwardHeadway
```
public final void updateForwardHeadway()
                                throws org.opentrafficsim.core.gtu.GTUException,
                                       org.opentrafficsim.core.network.NetworkException,
                                       org.opentrafficsim.core.gtu.behavioralcharacteristics.ParameterException
```
    Update who's in front of us and how far away the nearest object (e.g., a GTU) is.
    
    Specified by:
    
    updateForwardHeadway in interface LanePerception
    
    Throws:
    
    org.opentrafficsim.core.gtu.GTUException - when the GTU was not initialized yet.
    
    org.opentrafficsim.core.network.NetworkException - when the headway cannot be determined for this GTU, usually due to routing problems.
    
    org.opentrafficsim.core.gtu.behavioralcharacteristics.ParameterException - when there is a parameter problem, e.g., retrieving the forwardHeadwayDistance.
  - updateBackwardHeadway
```
public final void updateBackwardHeadway()
                                 throws org.opentrafficsim.core.gtu.GTUException,
                                        org.opentrafficsim.core.network.NetworkException,
                                        org.opentrafficsim.core.gtu.behavioralcharacteristics.ParameterException
```
    Update who's behind us and how far away the nearest object (e.g., a GTU) is.
    
    Specified by:
    
    updateBackwardHeadway in interface LanePerception
    
    Throws:
    
    org.opentrafficsim.core.gtu.GTUException - when the GTU was not initialized yet.
    
    org.opentrafficsim.core.network.NetworkException - when the headway cannot be determined for this GTU, usually due to routing problems.
    
    org.opentrafficsim.core.gtu.behavioralcharacteristics.ParameterException - when there is a parameter problem, e.g., retrieving the backwardHeadwayDistance.
  - updateAccessibleAdjacentLanesLeft
```
public final void updateAccessibleAdjacentLanesLeft()
                                             throws org.opentrafficsim.core.gtu.GTUException
```
    Build a set of Lanes that is adjacent to the given lane that this GTU can enter, for the left lateral direction.
    
    Specified by:
    
    updateAccessibleAdjacentLanesLeft in interface LanePerception
    
    Throws:
    
    org.opentrafficsim.core.gtu.GTUException - when the GTU was not initialized yet.
  - updateAccessibleAdjacentLanesRight
```
public final void updateAccessibleAdjacentLanesRight()
                                              throws org.opentrafficsim.core.gtu.GTUException
```
    Build a set of Lanes that is adjacent to the given lane that this GTU can enter, for the left lateral direction.
    
    Specified by:
    
    updateAccessibleAdjacentLanesRight in interface LanePerception
    
    Throws:
    
    org.opentrafficsim.core.gtu.GTUException - when the GTU was not initialized yet.
  - updateParallelHeadwaysLeft
```
public final void updateParallelHeadwaysLeft()
                                      throws org.opentrafficsim.core.gtu.GTUException
```
    Update the information about the objects (e.g., GTUs) parallel to our GTU on the left side.
    
    Specified by:
    
    updateParallelHeadwaysLeft in interface LanePerception
    
    Throws:
    
    org.opentrafficsim.core.gtu.GTUException - when the GTU was not initialized yet.
  - updateParallelHeadwaysRight
```
public final void updateParallelHeadwaysRight()
                                       throws org.opentrafficsim.core.gtu.GTUException
```
    Update the information about the objects (e.g., GTUs) parallel to our GTU on the right side.
    
    Specified by:
    
    updateParallelHeadwaysRight in interface LanePerception
    
    Throws:
    
    org.opentrafficsim.core.gtu.GTUException - when the GTU was not initialized yet.
  - updateLaneTrafficLeft
```
public final void updateLaneTrafficLeft()
                                 throws org.opentrafficsim.core.gtu.GTUException,
                                        org.opentrafficsim.core.network.NetworkException,
                                        org.opentrafficsim.core.gtu.behavioralcharacteristics.ParameterException
```
    Update the information about the objects (e.g., GTUs) left of our GTU, and behind us or ahead on the left hand side.
    
    Specified by:
    
    updateLaneTrafficLeft in interface LanePerception
    
    Throws:
    
    org.opentrafficsim.core.gtu.GTUException - when the GTU was not initialized yet.
    
    org.opentrafficsim.core.network.NetworkException - when there is an inconsistency in the lanes on this network
    
    org.opentrafficsim.core.gtu.behavioralcharacteristics.ParameterException - when there is a parameter problem.
  - updateLaneTrafficRight
```
public final void updateLaneTrafficRight()
                                  throws org.opentrafficsim.core.gtu.GTUException,
                                         org.opentrafficsim.core.network.NetworkException,
                                         org.opentrafficsim.core.gtu.behavioralcharacteristics.ParameterException
```
    Update the information about the objects (e.g., GTUs) right of our GTU, and behind us or ahead on the left hand side.
    
    Specified by:
    
    updateLaneTrafficRight in interface LanePerception
    
    Throws:
    
    org.opentrafficsim.core.gtu.GTUException - when the GTU was not initialized yet.
    
    org.opentrafficsim.core.network.NetworkException - when there is an inconsistency in the lanes on this network
    
    org.opentrafficsim.core.gtu.behavioralcharacteristics.ParameterException - when there is a parameter problem.
  - accessibleAdjacentLaneMap
```
public final Map<Lane,Set<Lane>> accessibleAdjacentLaneMap(org.opentrafficsim.core.network.LateralDirectionality lateralDirection)
```
    Specified by:
    
    accessibleAdjacentLaneMap in interface LanePerception
    
    Parameters:
    
    lateralDirection - the direction to return the accessible adjacent lane map for
    
    Returns:
    
    the accessible adjacent lane map for the given direction
  - getNeighboringHeadways
```
public final Collection<Headway> getNeighboringHeadways(org.opentrafficsim.core.network.LateralDirectionality lateralDirection)
```
    Specified by:
    
    getNeighboringHeadways in interface LanePerception
    
    Parameters:
    
    lateralDirection - the direction to return the parallel headway collection for
    
    Returns:
    
    the the objects (e.g., GTUs) in parallel, in front and behind for the lane in the given direction, with their headway relative to our GTU, and information about the status of the adjacent objects
  - getParallelHeadways
```
public final Collection<Headway> getParallelHeadways(org.opentrafficsim.core.network.LateralDirectionality lateralDirection)
```
    Specified by:
    
    getParallelHeadways in interface LanePerception
    
    Parameters:
    
    lateralDirection - the direction to return the neighboring headway collection for
    
    Returns:
    
    the the parallel objects (e.g., GTUs) for the given direction, with information about their status and parallel overlap with our GTU.
  - bestAccessibleAdjacentLane
```
public final Lane bestAccessibleAdjacentLane(Lane currentLane,
                                             org.opentrafficsim.core.network.LateralDirectionality lateralDirection,
                                             org.djunits.value.vdouble.scalar.Length longitudinalPosition)
```
    Determine whether there is a lane to the left or to the right of this lane, which is accessible from this lane, or null if no lane could be found. The method takes the LongitidinalDirectionality of the lane into account. In other words, if we drive FORWARD and look for a lane on the LEFT, and there is a lane but the Directionality of that lane is not FORWARD or BOTH, null will be returned.
    A lane is called adjacent to another lane if the lateral edges are not more than a delta distance apart. This means that a lane that overlaps with another lane is not returned as an adjacent lane.
    The algorithm also looks for RoadMarkerAcross elements between the lanes to determine the lateral permeability for a GTU. A RoadMarkerAcross is seen as being between two lanes if its center line is not more than delta distance from the relevant lateral edges of the two adjacent lanes.
    When there are multiple lanes that are adjacent, which could e.g. be the case if an overlapping tram lane and a car lane are adjacent to the current lane, the widest lane that best matches the GTU accessibility of the provided GTUType is returned.
    Note: LEFT is seen as a negative lateral direction, RIGHT as a positive lateral direction.
    FIXME In other places in OTS LEFT is positive (and RIGHT is negative). This should be made more consistent.
    
    Parameters:
    
    currentLane - the lane to look for the best accessible adjacent lane
    
    lateralDirection - the direction (LEFT, RIGHT) to look at
    
    longitudinalPosition - Length; the position of the GTU along currentLane
    
    Returns:
    
    the lane if it is accessible, or null if there is no lane, it is not accessible, or the driving direction does not match.
  - getGtu
```
public final LaneBasedGTU getGtu()
```
    Specified by:
    
    getGtu in interface org.opentrafficsim.core.gtu.perception.Perception
    
    Specified by:
    
    getGtu in interface LanePerception
    
    Overrides:
    
    getGtu in class org.opentrafficsim.core.gtu.perception.AbstractPerception
    
    Returns:
    
    the gtu for which this is the perception
  - getLanePathInfo
```
public final LanePathInfo getLanePathInfo()
```
    Retrieve the last perceived lane path info.
    
    Returns:
    
    LanePathInfo
  - getForwardHeadway
```
public final Headway getForwardHeadway()
```
    Specified by:
    
    getForwardHeadway in interface LanePerception
    
    Returns:
    
    forwardHeadway, the forward headway and first object (e.g., a GTU) in front
  - getBackwardHeadway
```
public final Headway getBackwardHeadway()
```
    Specified by:
    
    getBackwardHeadway in interface LanePerception
    
    Returns:
    
    backwardHeadwayGTU, the backward headway and first object (e.g., a GTU) behind
  - getAccessibleAdjacentLanesLeft
```
public final Map<Lane,Set<Lane>> getAccessibleAdjacentLanesLeft()
```
    Specified by:
    
    getAccessibleAdjacentLanesLeft in interface LanePerception
    
    Returns:
    
    accessibleAdjacentLanesLeft, the accessible adjacent lanes on the left
  - getAccessibleAdjacentLanesRight
```
public final Map<Lane,Set<Lane>> getAccessibleAdjacentLanesRight()
```
    Specified by:
    
    getAccessibleAdjacentLanesRight in interface LanePerception
    
    Returns:
    
    accessibleAdjacentLanesRight, the accessible adjacent lanes on the right
  - getNeighboringHeadwaysLeft
```
public final Collection<Headway> getNeighboringHeadwaysLeft()
```
    Specified by:
    
    getNeighboringHeadwaysLeft in interface LanePerception
    
    Returns:
    
    neighboringHeadwaysLeft, the objects (e.g., GTUs) in parallel, in front and behind on the left neighboring lane, with their headway relative to our GTU, and information about the status of the adjacent objects
  - getNeighboringHeadwaysRight
```
public final Collection<Headway> getNeighboringHeadwaysRight()
```
    Specified by:
    
    getNeighboringHeadwaysRight in interface LanePerception
    
    Returns:
    
    neighboringHeadwaysRight, the objects (e.g., GTUs) in parallel, in front and behind on the right neighboring lane, with their headway relative to our GTU, and information about the status of the adjacent objects
  - getParallelHeadwaysLeft
```
public final Collection<Headway> getParallelHeadwaysLeft()
```
    Specified by:
    
    getParallelHeadwaysLeft in interface LanePerception
    
    Returns:
    
    parallelHeadwaysLeft, the parallel objects (e.g., GTUs) on the left, with information about their status and parallel overlap with our GTU.
  - getParallelHeadwaysRight
```
public final Collection<Headway> getParallelHeadwaysRight()
```
    Specified by:
    
    getParallelHeadwaysRight in interface LanePerception
    
    Returns:
    
    parallelHeadwaysRight, the parallel objects (e.g., GTUs) on the right, with information about their status and parallel overlap with our GTU.
  - getSpeedLimit
```
public final org.djunits.value.vdouble.scalar.Speed getSpeedLimit()
```
    Specified by:
    
    getSpeedLimit in interface LanePerception
    
    Returns:
    
    speedLimit
  - getTimeStampedForwardHeadway
```
public final org.opentrafficsim.core.gtu.perception.TimeStampedObject<Headway> getTimeStampedForwardHeadway()
```
    Specified by:
    
    getTimeStampedForwardHeadway in interface LanePerception
    
    Returns:
    
    TimeStamped forwardHeadway, the forward headway and first object (e.g., a GTU) in front
  - getTimeStampedBackwardHeadway
```
public final org.opentrafficsim.core.gtu.perception.TimeStampedObject<Headway> getTimeStampedBackwardHeadway()
```
    Specified by:
    
    getTimeStampedBackwardHeadway in interface LanePerception
    
    Returns:
    
    TimeStamped backwardHeadwayGTU, the backward headway and first object (e.g., a GTU) behind
  - getTimeStampedAccessibleAdjacentLanesLeft
```
public final org.opentrafficsim.core.gtu.perception.TimeStampedObject<Map<Lane,Set<Lane>>> getTimeStampedAccessibleAdjacentLanesLeft()
```
    Specified by:
    
    getTimeStampedAccessibleAdjacentLanesLeft in interface LanePerception
    
    Returns:
    
    TimeStamped accessibleAdjacentLanesLeft, the accessible adjacent lanes on the left
  - getTimeStampedAccessibleAdjacentLanesRight
```
public final org.opentrafficsim.core.gtu.perception.TimeStampedObject<Map<Lane,Set<Lane>>> getTimeStampedAccessibleAdjacentLanesRight()
```
    Specified by:
    
    getTimeStampedAccessibleAdjacentLanesRight in interface LanePerception
    
    Returns:
    
    TimeStamped accessibleAdjacentLanesRight, the accessible adjacent lanes on the right
  - getTimeStampedNeighboringHeadwaysLeft
```
public final org.opentrafficsim.core.gtu.perception.TimeStampedObject<Collection<Headway>> getTimeStampedNeighboringHeadwaysLeft()
```
    Specified by:
    
    getTimeStampedNeighboringHeadwaysLeft in interface LanePerception
    
    Returns:
    
    TimeStamped neighboringHeadwaysLeft, the objects (e.g., GTUs) in parallel, in front and behind on the left neighboring lane, with their headway relative to our GTU, and information about the status of the adjacent objects
  - getTimeStampedNeighboringHeadwaysRight
```
public final org.opentrafficsim.core.gtu.perception.TimeStampedObject<Collection<Headway>> getTimeStampedNeighboringHeadwaysRight()
```
    Specified by:
    
    getTimeStampedNeighboringHeadwaysRight in interface LanePerception
    
    Returns:
    
    TimeStamped neighboringHeadwaysRight, the objects (e.g., GTUs) in parallel, in front and behind on the right neighboring lane, with their headway relative to our GTU, and information about the status of the adjacent objects
  - getTimeStampedParallelHeadwaysLeft
```
public final org.opentrafficsim.core.gtu.perception.TimeStampedObject<Collection<Headway>> getTimeStampedParallelHeadwaysLeft()
```
    Specified by:
    
    getTimeStampedParallelHeadwaysLeft in interface LanePerception
    
    Returns:
    
    TimeStamped parallelHeadwaysLeft, the parallel objects (e.g., GTUs) on the left, with information about their status and parallel overlap with our GTU.
  - getTimeStampedParallelHeadwaysRight
```
public final org.opentrafficsim.core.gtu.perception.TimeStampedObject<Collection<Headway>> getTimeStampedParallelHeadwaysRight()
```
    Specified by:
    
    getTimeStampedParallelHeadwaysRight in interface LanePerception
    
    Returns:
    
    TimeStamped parallelHeadwaysRight, the parallel objects (e.g., GTUs) on the right, with information about their status and parallel overlap with our GTU.
  - getTimeStampedSpeedLimit
```
public final org.opentrafficsim.core.gtu.perception.TimeStampedObject<org.djunits.value.vdouble.scalar.Speed> getTimeStampedSpeedLimit()
```
    Specified by:
    
    getTimeStampedSpeedLimit in interface LanePerception
    
    Returns:
    
    TimeStamped speedLimit
  - getFirstLeaders
```
public SortedSet<AbstractHeadwayGTU> getFirstLeaders(org.opentrafficsim.core.network.LateralDirectionality lat)
```
    Set of leaders on a lane, which is usually 0 or 1, but possibly more in case of a downstream split with no intermediate GTU. This is shown below. Suppose A needs to go straight. If A considers a lane change to the left, both GTUs B (who's tail ~ is still on the straight lane) and C need to be considered for whether it's safe to do so. In case of multiple splits close to one another, the returned set may contain even more than 2 leaders. Leaders are sorted by headway value.
```
          | |
 _________/B/_____
 _ _?_ _ _~_ _C_ _
 _ _A_ _ _ _ _ _ _
 _________________
 
```
    Specified by:
    
    getFirstLeaders in interface LanePerception
    
    Parameters:
    
    lat - LEFT, null (current) or RIGHT
    
    Returns:
    
    list of followers on a lane
  - getFirstFollowers
```
public SortedSet<AbstractHeadwayGTU> getFirstFollowers(org.opentrafficsim.core.network.LateralDirectionality lat)
```
    Set of followers on a lane, which is usually 0 or 1, but possibly more in case of an upstream merge with no intermediate GTU. This is shown below. If A considers a lane change to the left, both GTUs B and C need to be considered for whether it's safe to do so. In case of multiple merges close to one another, the returned set may contain even more than 2 followers. Followers are sorted by tailway value.
```
        | |
        |C| 
 ________\ \______
 _ _B_|_ _ _ _ _?_
 _ _ _|_ _ _ _ _A_ 
 _____|___________
 
```
    Specified by:
    
    getFirstFollowers in interface LanePerception
    
    Parameters:
    
    lat - LEFT, null (current) or RIGHT
    
    Returns:
    
    list of followers on a lane
  - existsGtuAlongside
```
public boolean existsGtuAlongside(org.opentrafficsim.core.network.LateralDirectionality lat)
```
    Whether there is a GTU alongside, i.e. with overlap, in an adjacent lane.
    
    Specified by:
    
    existsGtuAlongside in interface LanePerception
    
    Parameters:
    
    lat - LEFT or RIGHT, null not allowed
    
    Returns:
    
    whether there is a GTU alongside, i.e. with overlap, in an adjacent lane
  - getLeaders
```
public SortedSet<AbstractHeadwayGTU> getLeaders(RelativeLane lane)
```
    Set of leaders on a lane, including adjacent GTU's who's FRONT is ahead of the own vehicle FRONT. Leaders are sorted by headway value.
    
    Specified by:
    
    getLeaders in interface LanePerception
    
    Parameters:
    
    lane - relative lateral lane
    
    Returns:
    
    set of leaders on a lane, including adjacent GTU's who's FRONT is ahead of the own vehicle FRONT
  - getFollowers
```
public SortedSet<AbstractHeadwayGTU> getFollowers(RelativeLane lane)
```
    Set of followers on a lane, including adjacent GTU's who's REAR is back of the own vehicle REAR. Follower are are sorted by tailway value.
    
    Specified by:
    
    getFollowers in interface LanePerception
    
    Parameters:
    
    lane - relative lateral lane
    
    Returns:
    
    set of followers on a lane, including adjacent GTU's who's REAR is back of the own vehicle REAR
  - getInfrastructureLaneChangeInfo
```
public SortedSet<InfrastructureLaneChangeInfo> getInfrastructureLaneChangeInfo(RelativeLane lane)
```
    Returns infrastructure lane change info of a lane. A set is returned as multiple points may force lane changes. Which point is considered most critical is a matter of driver interpretation and may change over time. This is shown below. Suppose vehicle A needs to take the off-ramp, and that behavior is that the minimum distance per required lane change determines how critical it is. First, 400m before the lane-drop, the off-ramp is critical. 300m downstream, the lane-drop is critical. Info is sorted by distance, closest first.
```
 _______
 _ _A_ _\_________
 _ _ _ _ _ _ _ _ _
 _________ _ _ ___
          \_______
     (-)        Lane-drop: 1 lane change  in 400m (400m per lane change)
     (--------) Off-ramp:  3 lane changes in 900m (300m per lane change, critical)
     
     (-)        Lane-drop: 1 lane change  in 100m (100m per lane change, critical)
     (--------) Off-ramp:  3 lane changes in 600m (200m per lane change)
 
```
    Specified by:
    
    getInfrastructureLaneChangeInfo in interface LanePerception
    
    Parameters:
    
    lane - relative lateral lane
    
    Returns:
    
    infrastructure lane change info of a lane
  - getSplitNumber
```
public int getSplitNumber(InfrastructureLaneChangeInfo info)
```
    Split number of given infrastructure lane change info, 0 if it does not regard a split.
```
  ________________
  _ _ _ _ _ _ _ _____________
 A___.....____________.....__
     \______          \______ (destination of A)
                          ^
                          |
             This split provides the 1st 
      infrastructure info on the current lane. 
      It regards the 3rd split along the road.
                 split number = 3
 
```
    Specified by:
    
    getSplitNumber in interface LanePerception
    
    Parameters:
    
    info - infrastructure lane change info
    
    Returns:
    
    split number of given infrastructure lane change info, 0 if it does not regard a split
  - getSpeedLimitProspect
```
public SpeedLimitProspect getSpeedLimitProspect(RelativeLane lane)
```
    Returns the prospect for speed limits on a lane (dynamic speed limits may vary between lanes).
    
    Specified by:
    
    getSpeedLimitProspect in interface LanePerception
    
    Parameters:
    
    lane - relative lateral lane
    
    Returns:
    
    prospect for speed limits on a lane
  - getLegalLaneChangePossibility
```
public org.djunits.value.vdouble.scalar.Length getLegalLaneChangePossibility(RelativeLane fromLane,
                                                                             org.opentrafficsim.core.network.LateralDirectionality lat)
```
    Returns the distance over which a lane change remains legally possible.
    
    Specified by:
    
    getLegalLaneChangePossibility in interface LanePerception
    
    Parameters:
    
    fromLane - lane from which the lane change possibility is requested
    
    lat - LEFT or RIGHT, null not allowed
    
    Returns:
    
    distance over which a lane change remains possible
  - getPhysicalLaneChangePossibility
```
public org.djunits.value.vdouble.scalar.Length getPhysicalLaneChangePossibility(RelativeLane fromLane,
                                                                                org.opentrafficsim.core.network.LateralDirectionality lat)
```
    Returns the distance over which a lane change remains physically possible.
    
    Specified by:
    
    getPhysicalLaneChangePossibility in interface LanePerception
    
    Parameters:
    
    fromLane - lane from which the lane change possibility is requested
    
    lat - LEFT or RIGHT, null not allowed
    
    Returns:
    
    distance over which a lane change remains possible
  - getCurrentCrossSection
```
public SortedSet<RelativeLane> getCurrentCrossSection()
```
    Returns a set of relative lanes representing the current cross section. Lanes are sorted left to right.
    
    Specified by:
    
    getCurrentCrossSection in interface LanePerception
    
    Returns:
    
    set of relative lanes representing the current cross section
  - getTrafficLights
```
public SortedSet<HeadwayTrafficLight> getTrafficLights()
```
    Returns a set of traffic lights along the route. Traffic lights are sorted by headway value.
    
    Specified by:
    
    getTrafficLights in interface LanePerception
    
    Returns:
    
    set of traffic lights along the route
  - getIntersectionConflicts
```
public SortedSet<HeadwayConflict> getIntersectionConflicts(RelativeLane lane)
```
    Returns a set of intersection conflicts along the route. Conflicts are sorted by headway value.
    
    Specified by:
    
    getIntersectionConflicts in interface LanePerception
    
    Parameters:
    
    lane - relative lateral lane
    
    Returns:
    
    set of intersection conflicts along the route
  - getTimeStampedFirstLeaders
```
public org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<AbstractHeadwayGTU>> getTimeStampedFirstLeaders(org.opentrafficsim.core.network.LateralDirectionality lat)
```
    Set of leaders on a lane, which is usually 0 or 1, but possibly more in case of a downstream split with no intermediate GTU. This is shown below. Suppose A needs to go straight. If A considers a lane change to the left, both GTUs B (who's tail ~ is still on the straight lane) and C need to be considered for whether it's safe to do so. In case of multiple splits close to one another, the returned set may contain even more than 2 leaders. Leaders are sorted by headway value.
```
          | |
 _________/B/_____
 _ _?_ _ _~_ _C_ _
 _ _A_ _ _ _ _ _ _
 _________________
 
```
    Specified by:
    
    getTimeStampedFirstLeaders in interface LanePerception
    
    Parameters:
    
    lat - LEFT, null (current) or RIGHT
    
    Returns:
    
    list of followers on a lane
  - getTimeStampedFirstFollowers
```
public org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<AbstractHeadwayGTU>> getTimeStampedFirstFollowers(org.opentrafficsim.core.network.LateralDirectionality lat)
```
    Set of followers on a lane, which is usually 0 or 1, but possibly more in case of an upstream merge with no intermediate GTU. This is shown below. If A considers a lane change to the left, both GTUs B and C need to be considered for whether it's safe to do so. In case of multiple merges close to one another, the returned set may contain even more than 2 followers. Followers are sorted by tailway value.
```
        | |
        |C| 
 ________\ \______
 _ _B_|_ _ _ _ _?_
 _ _ _|_ _ _ _ _A_ 
 _____|___________
 
```
    Specified by:
    
    getTimeStampedFirstFollowers in interface LanePerception
    
    Parameters:
    
    lat - LEFT, null (current) or RIGHT
    
    Returns:
    
    list of followers on a lane
  - existsGtuAlongsideTimeStamped
```
public org.opentrafficsim.core.gtu.perception.TimeStampedObject<Boolean> existsGtuAlongsideTimeStamped(org.opentrafficsim.core.network.LateralDirectionality lat)
```
    Whether there is a GTU alongside, i.e. with overlap, in an adjacent lane.
    
    Specified by:
    
    existsGtuAlongsideTimeStamped in interface LanePerception
    
    Parameters:
    
    lat - LEFT or RIGHT, null not allowed
    
    Returns:
    
    whether there is a GTU alongside, i.e. with overlap, in an adjacent lane
  - getTimeStampedLeaders
```
public org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<AbstractHeadwayGTU>> getTimeStampedLeaders(RelativeLane lane)
```
    Set of leaders on a lane, including adjacent GTU's who's FRONT is ahead of the own vehicle FRONT. Leaders are sorted by headway value.
    
    Specified by:
    
    getTimeStampedLeaders in interface LanePerception
    
    Parameters:
    
    lane - relative lateral lane
    
    Returns:
    
    set of leaders on a lane, including adjacent GTU's who's FRONT is ahead of the own vehicle FRONT
  - getTimeStampedFollowers
```
public org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<AbstractHeadwayGTU>> getTimeStampedFollowers(RelativeLane lane)
```
    Set of followers on a lane, including adjacent GTU's who's REAR is back of the own vehicle REAR. Follower are are sorted by tailway value.
    
    Specified by:
    
    getTimeStampedFollowers in interface LanePerception
    
    Parameters:
    
    lane - relative lateral lane
    
    Returns:
    
    set of followers on a lane, including adjacent GTU's who's REAR is back of the own vehicle REAR
  - getTimeStampedInfrastructureLaneChangeInfo
```
public org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<InfrastructureLaneChangeInfo>> getTimeStampedInfrastructureLaneChangeInfo(RelativeLane lane)
```
    Returns infrastructure lane change info of a lane. A set is returned as multiple points may force lane changes. Which point is considered most critical is a matter of driver interpretation and may change over time. This is shown below. Suppose vehicle A needs to take the off-ramp, and that behavior is that the minimum distance per required lane change determines how critical it is. First, 400m before the lane-drop, the off-ramp is critical. 300m downstream, the lane-drop is critical. Info is sorted by distance, closest first.
```
 _______
 _ _A_ _\_________
 _ _ _ _ _ _ _ _ _
 _________ _ _ ___
          \_______
     (-)        Lane-drop: 1 lane change  in 400m (400m per lane change)
     (--------) Off-ramp:  3 lane changes in 900m (300m per lane change, critical)
     
     (-)        Lane-drop: 1 lane change  in 100m (100m per lane change, critical)
     (--------) Off-ramp:  3 lane changes in 600m (200m per lane change)
 
```
    Specified by:
    
    getTimeStampedInfrastructureLaneChangeInfo in interface LanePerception
    
    Parameters:
    
    lane - relative lateral lane
    
    Returns:
    
    infrastructure lane change info of a lane
  - getTimeStampedSplitNumber
```
public org.opentrafficsim.core.gtu.perception.TimeStampedObject<Integer> getTimeStampedSplitNumber(InfrastructureLaneChangeInfo info)
```
    Split number of given infrastructure lane change info, 0 if it does not regard a split.
```
  ________________
  _ _ _ _ _ _ _ _____________
 A___.....____________.....__
     \______          \______ (destination of A)
                          ^
                          |
             This split provides the 1st 
      infrastructure info on the current lane. 
      It regards the 3rd split along the road.
                 split number = 3
 
```
    Specified by:
    
    getTimeStampedSplitNumber in interface LanePerception
    
    Parameters:
    
    info - infrastructure lane change info
    
    Returns:
    
    split number of given infrastructure lane change info, 0 if it does not regard a split
  - getTimeStampedSpeedLimitProspect
```
public org.opentrafficsim.core.gtu.perception.TimeStampedObject<SpeedLimitProspect> getTimeStampedSpeedLimitProspect(RelativeLane lane)
```
    Returns the prospect for speed limits on a lane (dynamic speed limits may vary between lanes).
    
    Specified by:
    
    getTimeStampedSpeedLimitProspect in interface LanePerception
    
    Parameters:
    
    lane - relative lateral lane
    
    Returns:
    
    prospect for speed limits on a lane
  - getTimeStampedLegalLaneChangePossibility
```
public org.opentrafficsim.core.gtu.perception.TimeStampedObject<org.djunits.value.vdouble.scalar.Length> getTimeStampedLegalLaneChangePossibility(RelativeLane fromLane,
                                                                                                                                                  org.opentrafficsim.core.network.LateralDirectionality lat)
```
    Returns the distance over which a lane change remains legally possible.
    
    Specified by:
    
    getTimeStampedLegalLaneChangePossibility in interface LanePerception
    
    Parameters:
    
    fromLane - lane from which the lane change possibility is requested
    
    lat - LEFT or RIGHT, null not allowed
    
    Returns:
    
    distance over which a lane change remains possible
  - getTimeStampedPhysicalLaneChangePossibility
```
public org.opentrafficsim.core.gtu.perception.TimeStampedObject<org.djunits.value.vdouble.scalar.Length> getTimeStampedPhysicalLaneChangePossibility(RelativeLane fromLane,
                                                                                                                                                     org.opentrafficsim.core.network.LateralDirectionality lat)
```
    Returns the distance over which a lane change remains physically possible.
    
    Specified by:
    
    getTimeStampedPhysicalLaneChangePossibility in interface LanePerception
    
    Parameters:
    
    fromLane - lane from which the lane change possibility is requested
    
    lat - LEFT or RIGHT, null not allowed
    
    Returns:
    
    distance over which a lane change remains possible
  - getTimeStampedCurrentCrossSection
```
public org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<RelativeLane>> getTimeStampedCurrentCrossSection()
```
    Returns a set of relative lanes representing the current cross section. Lanes are sorted left to right.
    
    Specified by:
    
    getTimeStampedCurrentCrossSection in interface LanePerception
    
    Returns:
    
    set of relative lanes representing the current cross section
  - getTimeStampedTrafficLights
```
public org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<HeadwayTrafficLight>> getTimeStampedTrafficLights()
```
    Returns a set of traffic lights along the route. Traffic lights are sorted by headway value.
    
    Specified by:
    
    getTimeStampedTrafficLights in interface LanePerception
    
    Returns:
    
    set of traffic lights along the route
  - getTimeStampedIntersectionConflicts
```
public org.opentrafficsim.core.gtu.perception.TimeStampedObject<SortedSet<HeadwayConflict>> getTimeStampedIntersectionConflicts(RelativeLane lane)
```
    Returns a set of intersection conflicts along the route. Conflicts are sorted by headway value.
    
    Specified by:
    
    getTimeStampedIntersectionConflicts in interface LanePerception
    
    Parameters:
    
    lane - relative lateral lane
    
    Returns:
    
    set of intersection conflicts along the route
  - updateFirstLeaders
```
public void updateFirstLeaders()
```
    Updates of leaders on a lane, which is usually 0 or 1, but possibly more in case of a downstream split with no intermediate GTU. This is shown below. Suppose A needs to go straight. If A considers a lane change to the left, both GTUs B (who's tail ~ is still on the straight lane) and C need to be considered for whether it's safe to do so. In case of multiple splits close to one another, the returned set may contain even more than 2 leaders. Leaders are sorted by headway value.
```
          | |
 _________/B/_____
 _ _?_ _ _~_ _C_ _
 _ _A_ _ _ _ _ _ _
 _________________
 
```
    Specified by:
    
    updateFirstLeaders in interface LanePerception
  - updateFirstFollowers
```
public void updateFirstFollowers()
```
    Updates of followers on a lane, which is usually 0 or 1, but possibly more in case of an upstream merge with no intermediate GTU. This is shown below. If A considers a lane change to the left, both GTUs B and C need to be considered for whether it's safe to do so. In case of multiple merges close to one another, the returned set may contain even more than 2 followers. Followers are sorted by tailway value.
```
        | |
        |C| 
 ________\ \______
 _ _B_|_ _ _ _ _?_
 _ _ _|_ _ _ _ _A_ 
 _____|___________
 
```
    Specified by:
    
    updateFirstFollowers in interface LanePerception
  - updateGtuAlongside
```
public void updateGtuAlongside()
```
    Updates whether there is a GTU alongside, i.e. with overlap, in an adjacent lane.
    
    Specified by:
    
    updateGtuAlongside in interface LanePerception
  - updateLeaders
```
public void updateLeaders()
```
    Updates set of leaders on a lane, including adjacent GTU's who's FRONT is ahead of the own vehicle FRONT. Leaders are sorted by headway value.
    
    Specified by:
    
    updateLeaders in interface LanePerception
  - updateFollowers
```
public void updateFollowers()
```
    Updates set of followers on a lane, including adjacent GTU's who's REAR is back of the own vehicle REAR. Follower are are sorted by tailway value.
    
    Specified by:
    
    updateFollowers in interface LanePerception
  - updateInfrastructureLaneChangeInfo
```
public void updateInfrastructureLaneChangeInfo()
```
    Updates infrastructure lane change info of a lane. A set is returned as multiple points may force lane changes. Which point is considered most critical is a matter of driver interpretation and may change over time. This is shown below. Suppose vehicle A needs to take the off-ramp, and that behavior is that the minimum distance per required lane change determines how critical it is. First, 400m before the lane-drop, the off-ramp is critical. 300m downstream, the lane-drop is critical. Info is sorted by distance, closest first.
```
 _______
 _ _A_ _\_________
 _ _ _ _ _ _ _ _ _
 _________ _ _ ___
          \_______
     (-)        Lane-drop: 1 lane change  in 400m (400m per lane change)
     (--------) Off-ramp:  3 lane changes in 900m (300m per lane change, critical)
     
     (-)        Lane-drop: 1 lane change  in 100m (100m per lane change, critical)
     (--------) Off-ramp:  3 lane changes in 600m (200m per lane change)
 
```
    Specified by:
    
    updateInfrastructureLaneChangeInfo in interface LanePerception
  - updateSplitNumber
```
public void updateSplitNumber()
```
    Updates split numbers of infrastructure lane change info, 0 if it does not regard a split.
```
  ________________
  _ _ _ _ _ _ _ _____________
 A___.....____________.....__
     \______          \______ (destination of A)
                          ^
                          |
             This split provides the 1st 
      infrastructure info on the current lane. 
      It regards the 3rd split along the road.
                 split number = 3
 
```
    Specified by:
    
    updateSplitNumber in interface LanePerception
  - updateSpeedLimitProspect
```
public void updateSpeedLimitProspect()
```
    Updates the prospect for speed limits on a lane (dynamic speed limits may vary between lanes).
    
    Specified by:
    
    updateSpeedLimitProspect in interface LanePerception
  - updateLegalLaneChangePossibility
```
public void updateLegalLaneChangePossibility()
```
    Updates the distance over which a lane change remains legally possible.
    
    Specified by:
    
    updateLegalLaneChangePossibility in interface LanePerception
  - updatePhysicalLaneChangePossibility
```
public void updatePhysicalLaneChangePossibility()
```
    Updates the distance over which a lane change remains physically possible.
    
    Specified by:
    
    updatePhysicalLaneChangePossibility in interface LanePerception
  - updateCurrentCrossSection
```
public void updateCurrentCrossSection()
```
    Updates a set of relative lanes representing the current cross section. Lanes are sorted left to right.
    
    Specified by:
    
    updateCurrentCrossSection in interface LanePerception
  - updateTrafficLights
```
public void updateTrafficLights()
```
    Updates a set of traffic lights along the route. Traffic lights are sorted by headway value.
    
    Specified by:
    
    updateTrafficLights in interface LanePerception
  - updateIntersectionConflicts
```
public void updateIntersectionConflicts()
```
    Updates a set of intersection conflicts along the route. Conflicts are sorted by headway value.
    
    Specified by:
    
    updateIntersectionConflicts in interface LanePerception

Class AbstractLanePerception

Constructor Summary

Method Summary

Methods inherited from class org.opentrafficsim.core.gtu.perception.AbstractPerception

Methods inherited from class java.lang.Object

Methods inherited from interface org.opentrafficsim.core.gtu.perception.Perception

Constructor Detail

AbstractLanePerception

Method Detail

updateLanePathInfo

updateSpeedLimit

updateForwardHeadway

updateBackwardHeadway

updateAccessibleAdjacentLanesLeft

updateAccessibleAdjacentLanesRight

updateParallelHeadwaysLeft

updateParallelHeadwaysRight

updateLaneTrafficLeft

updateLaneTrafficRight

accessibleAdjacentLaneMap

getNeighboringHeadways

getParallelHeadways

bestAccessibleAdjacentLane

getGtu

getLanePathInfo

getForwardHeadway

getBackwardHeadway

getAccessibleAdjacentLanesLeft

getAccessibleAdjacentLanesRight

getNeighboringHeadwaysLeft

getNeighboringHeadwaysRight

getParallelHeadwaysLeft

getParallelHeadwaysRight

getSpeedLimit

getTimeStampedForwardHeadway

getTimeStampedBackwardHeadway

getTimeStampedAccessibleAdjacentLanesLeft

getTimeStampedAccessibleAdjacentLanesRight

getTimeStampedNeighboringHeadwaysLeft

getTimeStampedNeighboringHeadwaysRight

getTimeStampedParallelHeadwaysLeft

getTimeStampedParallelHeadwaysRight

getTimeStampedSpeedLimit

getFirstLeaders

getFirstFollowers

existsGtuAlongside

getLeaders

getFollowers

getInfrastructureLaneChangeInfo

getSplitNumber

getSpeedLimitProspect

getLegalLaneChangePossibility

getPhysicalLaneChangePossibility

getCurrentCrossSection

getTrafficLights

getIntersectionConflicts

getTimeStampedFirstLeaders

getTimeStampedFirstFollowers

existsGtuAlongsideTimeStamped

getTimeStampedLeaders

getTimeStampedFollowers

getTimeStampedInfrastructureLaneChangeInfo

getTimeStampedSplitNumber

getTimeStampedSpeedLimitProspect

getTimeStampedLegalLaneChangePossibility

getTimeStampedPhysicalLaneChangePossibility

getTimeStampedCurrentCrossSection

getTimeStampedTrafficLights

getTimeStampedIntersectionConflicts

updateFirstLeaders

updateFirstFollowers

updateGtuAlongside

updateLeaders

updateFollowers

updateInfrastructureLaneChangeInfo

updateSplitNumber

updateSpeedLimitProspect

updateLegalLaneChangePossibility

updatePhysicalLaneChangePossibility

updateCurrentCrossSection