planning/laneplanner/docs/usecase3.md

Go to the documentation of this file.

# Copyright (c) 2019-2020, NVIDIA CORPORATION.  All rights reserved.

@page laneplanner_usecase3 Lane Plan

@note SW Release Applicability: This tutorial is applicable to modules in **NVIDIA DRIVE Software** releases.

A Lane Plan is described by the `dwLanePlan` struct:

```{.cpp}
    typedef struct dwLanePlan
    {
        // List of segments along the lane plan.
        const dwLanePlanSegment* segments;

        // Number segments in lane plan.
        uint32_t segmentCount;          
    } dwLanePlan;
```

To access the dwLanePlan struct, call:

```{.cpp}
    dwStatus dwLanePlan_get(
        dwLanePlan* lanePlan,
        dwConstLanePlanHandle_t lanePlanHandle);
```

The dwLanePlan struct is a list of Lane Plan Segments. Each Lane Plan Segment has a list of Lane Plan Lanes that describe the current lane change situation at that segment:

```{.cpp}
    typedef struct dwLanePlanSegment
    {
        // List of lanes. The first lane in the list is the lane
        // where the lane plan segment is entered, the last one
        // is where the lane plan segment is exited. If there is
        // more than one lane, lane changes must be done from the
        // first to the last lane, traversing all in-between
        // lanes in order.
        const dwLanePlanLane* lanes;

        // Number of lanes in this segment. If there are more than
        // one, it is a lane change segment.
        uint32_t laneCount;

        // Left, right, none
        dwMapsSide laneChangeSide;
    } dwLanePlanSegment;
```

A Lane Plan Lane is a polyline, together with pointers to the original dwMapsLane for each point:

```{.cpp}
    typedef struct dwLanePlanLane
    {
        // Polyline point array
        const dwMapsGeoPoint* points;

        // Pointers to the corresponding lane (per point)
        const dwMapsLane** pointLanes;

        // Estimated time of arrival (per point)
        // relative to beginning of first lane of the lane plan,
        // computed based on lane speed limits. 50 km/h is assumed
        // if no speed limit is defined for a lane.
        const dwTime_t* times;

        // number of points
        uint32_t pointCount;
    } dwLanePlanLane;
```

If the segment has only one Lane Plan Lane, then that lane must be followed. If there is more than one lane, the last lane of the list is the target lane that must be reached to follow the Lane Plan.

Each point on a Lane Plan can be accessed through dwLanePlanIndex:

```{.cpp}
    typedef struct dwLanePlanIndex
    {
        uint32_t segmentIndex; //!< index of a the lane plan point
        uint32_t laneIndex;    //!< index of lane in the segment
        uint32_t pointIndex;   //!< index of a point in the lane
                               // plan lane
    } dwLanePlanIndex;
```

`dwLanePlanIndex` provides a reference into the Lane Plan defined by the segment index, the lane index on the segment, and the point index on the lane.

The example image below shows a small Lane Plan with three segments. The first segment has two Lane Plan Lanes, the second segment has three Lane Plan Lanes due to a lane split at the end of the target lane of the first segment. The third segment shows the lane that must be followed to reach the target point (indicated by the red box). So, the first two segments describe where and how many lane changes must be executed to reach the target.

![](lane_plan.png)