Drake
Lane Class Referencefinal

Dragway's implementation of api::Lane. More...

#include <drake/automotive/maliput/dragway/lane.h>

Inheritance diagram for Lane:
[legend]
Collaboration diagram for Lane:
[legend]

Public Member Functions

 Lane (const Segment *segment, const api::LaneId &id, int index, double length, double y_offset, const api::RBounds &lane_bounds, const api::RBounds &driveable_bounds, const api::HBounds &elevation_bounds)
 Constructs a dragway Lane. More...
 
 ~Lane () final=default
 
double y_offset () const
 Returns the y-offset of this lane's frame relative to the world frame. More...
 
Does not allow copy, move, or assignment
 Lane (const Lane &)=delete
 
Laneoperator= (const Lane &)=delete
 
 Lane (Lane &&)=delete
 
Laneoperator= (Lane &&)=delete
 
Methods that set the lanes to the left and right of this lane.

The corresponding accessors are api::Lane::to_left() and api::Lane::to_right().

void set_lane_to_left (api::Lane *lane_to_left)
 
void set_lane_to_right (api::Lane *lane_to_right)
 
- Public Member Functions inherited from Lane
const LaneId id () const
 Returns the persistent identifier. More...
 
const Segmentsegment () const
 Returns the Segment to which this Lane belongs. More...
 
int index () const
 Returns the index of this Lane within the Segment which owns it. More...
 
const Laneto_left () const
 Returns a pointer to the adjacent Lane to the left of this Lane. More...
 
const Laneto_right () const
 Returns a pointer to the adjacent Lane to the right of this Lane. More...
 
double length () const
 Returns the arc-length of the Lane along its reference curve. More...
 
RBounds lane_bounds (double s) const
 Returns the nominal lateral (r) bounds for the lane as a function of s. More...
 
RBounds driveable_bounds (double s) const
 Returns the driveable lateral (r) bounds of the lane as a function of s. More...
 
HBounds elevation_bounds (double s, double r) const
 Returns the elevation (h) bounds of the lane as a function of (s, r). More...
 
GeoPosition ToGeoPosition (const LanePosition &lane_pos) const
 Returns the GeoPosition corresponding to the given LanePosition. More...
 
LanePosition ToLanePosition (const GeoPosition &geo_position, GeoPosition *nearest_point, double *distance) const
 Determines the LanePosition corresponding to GeoPosition geo_position. More...
 
Rotation GetOrientation (const LanePosition &lane_pos) const
 Returns the rotation which expresses the orientation of the Lane-frame basis at lane_pos with respect to the world frame basis. More...
 
LanePosition EvalMotionDerivatives (const LanePosition &position, const IsoLaneVelocity &velocity) const
 Computes derivatives of LanePosition given a velocity vector velocity. More...
 
const BranchPointGetBranchPoint (const LaneEnd::Which which_end) const
 Returns the lane's BranchPoint for the end specified by which_end. More...
 
const LaneEndSetGetConfluentBranches (const LaneEnd::Which which_end) const
 Returns the set of LaneEnd's which connect with this lane on the same side of the BranchPoint at which_end. More...
 
const LaneEndSetGetOngoingBranches (const LaneEnd::Which which_end) const
 Returns the set of LaneEnd's which continue onward from this lane at the BranchPoint at which_end. More...
 
std::unique_ptr< LaneEndGetDefaultBranch (const LaneEnd::Which which_end) const
 Returns the default ongoing LaneEnd connected at which_end. More...
 
 Lane (const Lane &)=delete
 
Laneoperator= (const Lane &)=delete
 
 Lane (Lane &&)=delete
 
Laneoperator= (Lane &&)=delete
 

Additional Inherited Members

- Protected Member Functions inherited from Lane
 Lane ()=default
 

Detailed Description

Dragway's implementation of api::Lane.

The lane is flat with a height of zero.

The following lane is implemented:

                    lane_bounds
       |<------------------------------->|
                driveable_bounds
   |<--------------------------------------->|
   -------------------------------------------  ———  s = length()
   |                    :                    |   ^
   |                    :                    |   |
   |                    :                    |   |
   |                    :                    |   |
   |                    :                    |   |
   |                    :                    |   |
   |                    :                    |   |
   |                    :                    |   |
   |                    :                    |   |
   |                    :                    |   |
   |                    :                    |   |
   |                    :                    |   |
   |                    :                    |   |
   |                    :                    |   |
   |                    :                    |   |           world
   |                    :                    |   |           frame:
   |                    :                    |   |
   |                    :                    |   |                X
   |                    :                    |   |                ^
   |                    :                    |   |                |
   |                    :                    |   v                |
   ---------------------o---------------------  ———  s = 0   Y <--o
           r_max                r_min
   |<-------------------|------------------->|
                                           y_offset
                        |<----------------------------------------|
 

The lane's frame is defined by three coordinates: (s, r, h). Coordinate s is between zero and length(). It specifies the longitudinal traversal of the lane. Coordinate r is a value between r_min and r_max. It specifies the lateral traversal at a particular s. Coordinate h specifies the height above the lane's surface at a particular s and r (the lane's surface itself is always at h = 0). Since Dragway lanes are flat and level, z = h for all values of s and r and, in the Dragway's case, z = 0 for the surface itself. The origin of the lane's frame is defined by the o along the above-shown s = 0 line.

Note: Each dagway lane has a teleportation feature at both ends: the (default) ongoing lane for LaneEnd::kFinish is LaneEnd::kStart of the same lane, and vice versa.

Constructor & Destructor Documentation

Lane ( const Lane )
delete
Lane ( Lane &&  )
delete
Lane ( const Segment segment,
const api::LaneId id,
int  index,
double  length,
double  y_offset,
const api::RBounds lane_bounds,
const api::RBounds driveable_bounds,
const api::HBounds elevation_bounds 
)

Constructs a dragway Lane.

Parameters
segmentThe Segment to which this lane belongs.
idthe lane ID. This can be any user-defined value.
indexThe index of the lane with its Segment.
lengthThe total length of the lane.
y_offsetThe vector from the world frame's origin to the lane's s = 0 and r = 0. This value is positive when the lane's s = 0 and r = 0 is to the left of the world frame's origin, and is negative otherwise.
lane_boundsnominal bounds of the lane, uniform along the entire reference path, which must be a subset of driveable_bounds.
driveable_boundsThe driveable bounds of the lane, uniform along the entire reference path.
elevation_boundsThe elevation bounds of the lane, uniform along the entire reference path.

Here is the call graph for this function:

~Lane ( )
finalvirtualdefault

Reimplemented from Lane.

Member Function Documentation

Lane& operator= ( const Lane )
delete
Lane& operator= ( Lane &&  )
delete
void set_lane_to_left ( api::Lane lane_to_left)

Here is the caller graph for this function:

void set_lane_to_right ( api::Lane lane_to_right)

Here is the call graph for this function:

Here is the caller graph for this function:

double y_offset ( ) const
inline

Returns the y-offset of this lane's frame relative to the world frame.

Here is the caller graph for this function:


The documentation for this class was generated from the following files: