org.opentrafficsim.road.gtu.lane.perception

Class AbstractLanePerception

java.lang.Object

org.opentrafficsim.road.gtu.lane.perception.AbstractLanePerception

All Implemented Interfaces:

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

Direct Known Subclasses:

LanePerceptionFull, LanePerceptionNone

public abstract class AbstractLanePerception
extends Object
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-2015 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

Field Summary

Fields

Modifier and Type	Field and Description
protected LaneBasedGTU	gtu The lane based GTU for which this perception module stores information.

Constructor Summary

Constructors

Constructor and Description
AbstractLanePerception() Create a new LanePerception module.

Method Summary

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.Rel 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.
Map<Lane,Set<Lane>>	getAccessibleAdjacentLanesLeft()
Map<Lane,Set<Lane>>	getAccessibleAdjacentLanesRight()
HeadwayGTU	getBackwardHeadwayGTU()
HeadwayGTU	getForwardHeadwayGTU()
LaneBasedGTU	getGTU()
Collection<HeadwayGTU>	getNeighboringGTUsLeft()
Collection<HeadwayGTU>	getNeighboringGTUsRight()
Set<LaneBasedGTU>	getParallelGTUsLeft()
Set<LaneBasedGTU>	getParallelGTUsRight()
Set<org.opentrafficsim.core.perception.PerceivedObject>	getPerceivedObjects()
org.djunits.value.vdouble.scalar.Speed	getSpeedLimit()
TimeStampedObject<Map<Lane,Set<Lane>>>	getTimeStampedAccessibleAdjacentLanesLeft()
TimeStampedObject<Map<Lane,Set<Lane>>>	getTimeStampedAccessibleAdjacentLanesRight()
TimeStampedObject<HeadwayGTU>	getTimeStampedBackwardHeadwayGTU()
TimeStampedObject<HeadwayGTU>	getTimeStampedForwardHeadwayGTU()
TimeStampedObject<Collection<HeadwayGTU>>	getTimeStampedNeighboringGTUsLeft()
TimeStampedObject<Collection<HeadwayGTU>>	getTimeStampedNeighboringGTUsRight()
TimeStampedObject<Set<LaneBasedGTU>>	getTimeStampedParallelGTUsLeft()
TimeStampedObject<Set<LaneBasedGTU>>	getTimeStampedParallelGTUsRight()
TimeStampedObject<Set<org.opentrafficsim.core.perception.PerceivedObject>>	getTimeStampedPerceivedObjects()
TimeStampedObject<org.djunits.value.vdouble.scalar.Speed>	getTimeStampedSpeedLimit()
Collection<HeadwayGTU>	neighboringGTUCollection(org.opentrafficsim.core.network.LateralDirectionality lateralDirection)
Set<LaneBasedGTU>	parallelGTUs(org.opentrafficsim.core.network.LateralDirectionality lateralDirection)
void	setGTU(LaneBasedGTU gtu) sets the GTU -- call this method before any call to the perceive() method!
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	updateBackwardHeadwayGTU() Update who's behind us and how far away the nearest GTU is.
void	updateForwardHeadwayGTU() Update who's in front of us and how far away the nearest GTU is.
void	updateLaneTrafficLeft() Update the information about the GTUs left of our GTU, and behind us or ahead on the left hand side.
void	updateLaneTrafficRight() Update the information about the GTUs right of our GTU, and behind us or ahead on the left hand side.
void	updateParallelGTUsLeft() Update the information about the GTUs parallel to our GTU on the left side.
void	updateParallelGTUsRight() Update the information about the GTUs parallel to our GTU on the right side.
void	updateSpeedLimit() Update the perceived speed limit.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

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

perceive

Field Detail

gtu

protected LaneBasedGTU gtu

The lane based GTU for which this perception module stores information.

Constructor Detail

AbstractLanePerception

public AbstractLanePerception()

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.

Method Detail

setGTU

public final void setGTU(LaneBasedGTU gtu)

sets the GTU -- call this method before any call to the perceive() method!

Specified by:

setGTU in interface LanePerception

Parameters:

gtu - the GTU for which this is the perception module

updateSpeedLimit

public 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.

updateForwardHeadwayGTU

public void updateForwardHeadwayGTU()
                             throws org.opentrafficsim.core.gtu.GTUException,
                                    org.opentrafficsim.core.network.NetworkException

Update who's in front of us and how far away the nearest GTU is.

Specified by:

updateForwardHeadwayGTU 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.

updateBackwardHeadwayGTU

public void updateBackwardHeadwayGTU()
                              throws org.opentrafficsim.core.gtu.GTUException,
                                     org.opentrafficsim.core.network.NetworkException

Update who's behind us and how far away the nearest GTU is.

Specified by:

updateBackwardHeadwayGTU 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.

updateAccessibleAdjacentLanesLeft

public 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 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.

updateParallelGTUsLeft

public void updateParallelGTUsLeft()
                            throws org.opentrafficsim.core.gtu.GTUException

Update the information about the GTUs parallel to our GTU on the left side.

Specified by:

updateParallelGTUsLeft in interface LanePerception

Throws:

org.opentrafficsim.core.gtu.GTUException - when the GTU was not initialized yet.

updateParallelGTUsRight

public void updateParallelGTUsRight()
                             throws org.opentrafficsim.core.gtu.GTUException

Update the information about the GTUs parallel to our GTU on the right side.

Specified by:

updateParallelGTUsRight in interface LanePerception

Throws:

org.opentrafficsim.core.gtu.GTUException - when the GTU was not initialized yet.

updateLaneTrafficLeft

public void updateLaneTrafficLeft()
                           throws org.opentrafficsim.core.gtu.GTUException,
                                  org.opentrafficsim.core.network.NetworkException

Update the information about the 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

updateLaneTrafficRight

public void updateLaneTrafficRight()
                            throws org.opentrafficsim.core.gtu.GTUException,
                                   org.opentrafficsim.core.network.NetworkException

Update the information about the 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

accessibleAdjacentLaneMap

public 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

parallelGTUs

public Set<LaneBasedGTU> parallelGTUs(org.opentrafficsim.core.network.LateralDirectionality lateralDirection)

Specified by:

parallelGTUs in interface LanePerception

Parameters:

lateralDirection - the direction to return the parallel GTU map for

Returns:

the parallel GTU map for the given direction

neighboringGTUCollection

public Collection<HeadwayGTU> neighboringGTUCollection(org.opentrafficsim.core.network.LateralDirectionality lateralDirection)

Specified by:

neighboringGTUCollection in interface LanePerception

Parameters:

lateralDirection - the direction to return the neighboring GTU collection for

Returns:

the neighboring GTU collection for the given direction

bestAccessibleAdjacentLane

public final Lane bestAccessibleAdjacentLane(Lane currentLane,
                                             org.opentrafficsim.core.network.LateralDirectionality lateralDirection,
                                             org.djunits.value.vdouble.scalar.Length.Rel 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.Rel; 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 LanePerception

Returns:

the gtu for which this is the perception

getForwardHeadwayGTU

public final HeadwayGTU getForwardHeadwayGTU()

Specified by:

getForwardHeadwayGTU in interface LanePerception

Returns:

forwardHeadwayGTU, the forward headway and first GTU in front

getBackwardHeadwayGTU

public final HeadwayGTU getBackwardHeadwayGTU()

Specified by:

getBackwardHeadwayGTU in interface LanePerception

Returns:

backwardHeadwayGTU, the backward headway and first 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

getNeighboringGTUsLeft

public final Collection<HeadwayGTU> getNeighboringGTUsLeft()

Specified by:

getNeighboringGTUsLeft in interface LanePerception

Returns:

neighboringGTUsLeft, the GTUs in parallel, in front and behind on the left neighboring lane, with their headway relative to our GTU

getNeighboringGTUsRight

public final Collection<HeadwayGTU> getNeighboringGTUsRight()

Specified by:

getNeighboringGTUsRight in interface LanePerception

Returns:

neighboringGTUsRight, the GTUs in parallel, in front and behind on the right neighboring lane, with their headway relative to our GTU

getParallelGTUsLeft

public final Set<LaneBasedGTU> getParallelGTUsLeft()

Specified by:

getParallelGTUsLeft in interface LanePerception

Returns:

parallelGTUsLeft, the parallel GTUs on the left

getParallelGTUsRight

public final Set<LaneBasedGTU> getParallelGTUsRight()

Specified by:

getParallelGTUsRight in interface LanePerception

Returns:

parallelGTUsRight, the parallel GTUs on the right

getSpeedLimit

public final org.djunits.value.vdouble.scalar.Speed getSpeedLimit()

Specified by:

getSpeedLimit in interface LanePerception

Returns:

speedLimit

getPerceivedObjects

public Set<org.opentrafficsim.core.perception.PerceivedObject> getPerceivedObjects()

Specified by:

getPerceivedObjects in interface org.opentrafficsim.core.gtu.perception.Perception

getTimeStampedForwardHeadwayGTU

public final TimeStampedObject<HeadwayGTU> getTimeStampedForwardHeadwayGTU()

Specified by:

getTimeStampedForwardHeadwayGTU in interface LanePerception

Returns:

TimeStamped forwardHeadwayGTU, the forward headway and first GTU in front

getTimeStampedBackwardHeadwayGTU

public final TimeStampedObject<HeadwayGTU> getTimeStampedBackwardHeadwayGTU()

Specified by:

getTimeStampedBackwardHeadwayGTU in interface LanePerception

Returns:

TimeStamped backwardHeadwayGTU, the backward headway and first GTU behind

getTimeStampedAccessibleAdjacentLanesLeft

public final 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 TimeStampedObject<Map<Lane,Set<Lane>>> getTimeStampedAccessibleAdjacentLanesRight()

Specified by:

getTimeStampedAccessibleAdjacentLanesRight in interface LanePerception

Returns:

TimeStamped accessibleAdjacentLanesRight, the accessible adjacent lanes on the right

getTimeStampedNeighboringGTUsLeft

public final TimeStampedObject<Collection<HeadwayGTU>> getTimeStampedNeighboringGTUsLeft()

Specified by:

getTimeStampedNeighboringGTUsLeft in interface LanePerception

Returns:

TimeStamped neighboringGTUsLeft, the GTUs in parallel, in front and behind on the left neighboring lane, with their headway relative to our GTU

getTimeStampedNeighboringGTUsRight

public final TimeStampedObject<Collection<HeadwayGTU>> getTimeStampedNeighboringGTUsRight()

Specified by:

getTimeStampedNeighboringGTUsRight in interface LanePerception

Returns:

TimeStamped neighboringGTUsRight, the GTUs in parallel, in front and behind on the right neighboring lane, with their headway relative to our GTU

getTimeStampedParallelGTUsLeft

public final TimeStampedObject<Set<LaneBasedGTU>> getTimeStampedParallelGTUsLeft()

Specified by:

getTimeStampedParallelGTUsLeft in interface LanePerception

Returns:

TimeStamped parallelGTUsLeft, the parallel GTUs on the left

getTimeStampedParallelGTUsRight

public final TimeStampedObject<Set<LaneBasedGTU>> getTimeStampedParallelGTUsRight()

Specified by:

getTimeStampedParallelGTUsRight in interface LanePerception

Returns:

TimeStamped parallelGTUsRight, the parallel GTUs on the right

getTimeStampedSpeedLimit

public final TimeStampedObject<org.djunits.value.vdouble.scalar.Speed> getTimeStampedSpeedLimit()

Specified by:

getTimeStampedSpeedLimit in interface LanePerception

Returns:

TimeStamped speedLimit

getTimeStampedPerceivedObjects

public TimeStampedObject<Set<org.opentrafficsim.core.perception.PerceivedObject>> getTimeStampedPerceivedObjects()
                                                                                                          throws org.opentrafficsim.core.gtu.GTUException

Specified by:

getTimeStampedPerceivedObjects in interface LanePerception

Returns:

TimeStamped perceived objects

Throws:

org.opentrafficsim.core.gtu.GTUException - when GTU was not initialized