The drawings on this page use left-hand traffic, as in Japan: vehicles drive on the left side of the road. For right-hand traffic, swap left and right. In the map drawings, a colored area is a Lanelet, and a line with dots is a Linestring and its points. --- ## Requirements ### vm-01-01 Lanelet basics #### Detail of requirements The road's Lanelets must comply with the following requirements. - *subtype:road* - *location:urban*, for public roads - Align the Lanelet's direction with the direction in which the vehicle moves. (You can show the Lanelet direction as arrows in [Vector Map Builder]().) - Set whether a lane change is permitted or not, according to [vm-01-02](<#vm-01-02-allowance-for-lane-changes>). - Set the Linestring IDs for the Lanelet's left\_bound and right\_bound. See [vm-01-03](<#vm-01-03-linestring-sharing>). - tag: *one\_way=yes*. Do not use *one\_way=no* on a road Lanelet. With *one\_way=no*, the Lanelet2 traffic rules let a vehicle drive the Lanelet in both directions, and the routing graph of Autoware can use it in the reverse direction. But the route of Autoware keeps only the ID of each Lanelet, not the direction, and Autoware plans the path along the direction of the Lanelet. For a narrow road on which the vehicle drives in both directions, see [vm-01-14](<#vm-01-14-roads-with-no-centerline-2>). - Connect the Lanelet to the next and the previous Lanelets, except at the start or the end of the road. Two Lanelets are connected when the end points of the left and right bounds of the first Lanelet are the start points of the bounds of the next Lanelet. - Position the points (x, y, z) of the Lanelet to align with the PCD Map, both laterally and in elevation. The height of a Point must be the ellipsoidal height (WGS84). Refer to [vm-07-04](<../category_others/#vm-07-04-ellipsoidal-height>). #### Preferred vector map A road Lanelet, its direction, and its left and right bounds. --- ### vm-01-02 Allowance for lane changes #### Detail of requirements Add a tag to the Lanelet's Linestring that permits or prohibits a lane change. - Permit *lane\_change=yes* - Prohibit *lane\_change=no* Set the Linestring *subtype* according to the type of line. - *solid* - *dashed* > [!NOTE] > > Lanelet2 reads the *lane\_change* tag first. If a Linestring has no *lane\_change* tag, Lanelet2 permits a lane change only across a Linestring with *type:line\_thin* or *type:line\_thick* and *subtype:dashed*. The subtypes *dashed\_solid* and *solid\_dashed* permit a lane change in one direction only. ##### Referenced from Japan's Road Traffic Law The tags of the drawing follow the legal background in Japan: - White dashed lines and white solid lines between lanes: the law does not prohibit a lane change across them. Set *lane\_change=yes*. - Yellow solid lines between lanes: this road marking prohibits a lane change. Set *lane\_change=no*. [Article 26-2, paragraph 3 of the Road Traffic Act]() prohibits a lane change across a road marking that prohibits a change of course. The [ministerial order on road signs and road markings]() gives this marking (number 102-2) the color yellow. For other countries, use the local traffic law. The three types of lane lines and the tags of their Linestrings. #### Related Autoware module - [Lane Change design - Autoware Universe Documentation]() - [Static Avoidance - Autoware Universe Documentation]() - [Dynamic Avoidance - Autoware Universe Documentation]() - [Out of lane design - Autoware Universe Documentation]() --- ### vm-01-03 Linestring sharing #### Detail of requirements When you create Lanelets that are physically next to each other, make them share the Linestring between them. ##### Behavior of Autoware Autoware finds the Lanelet next to the current Lanelet through the shared Linestring. If the two Lanelets share a Linestring, the following behaviors become possible: - The vehicle moves out of its lane to avoid obstacles. - The vehicle drives slightly out of its lane in a curve. - The vehicle changes lanes. A road with two lanes in each direction. #### Preferred vector map Each lane line is one Linestring that the two Lanelets next to it share. #### Incorrect vector map Each Lanelet has its own Linestrings, so two Linestrings lie at each lane line. #### Related Autoware module - [Lane Change design - Autoware Universe Documentation]() - [Static Avoidance - Autoware Universe Documentation]() - [Dynamic Avoidance - Autoware Universe Documentation]() - [Out of lane design - Autoware Universe Documentation]() --- ### vm-01-04 Sharing of the centerline of lanes for opposing traffic #### Detail of requirements When the vehicle's Lanelet and the opposite Lanelet physically touch, the two Lanelets must share the Linestring of the road center line. For that purpose, the two Lanelets must have the same length. ##### Behavior of Autoware The vehicle can avoid an obstacle through the opposite lane. Autoware finds the opposite Lanelet through the shared Linestring. The static obstacle avoidance module uses the opposite lane when its parameter `use_lane_type` is `opposite_direction_lane`. This value is the default. The vehicle moves into the opposite lane to pass a parked vehicle. #### Preferred vector map The two Lanelets share the Linestring of the road center line and have the same length. #### Incorrect vector map The two directions have separate Linestrings, and the Lanelets do not have the same length. --- ### vm-01-05 Lane geometry #### Detail of requirements The geometry of the road Lanelet must comply with the following: - The left and right Linestrings must follow the lane lines of the road. - The end of a Lanelet must meet the start of the next Lanelet in a straight line. - The outline must be smooth, not jagged or bumpy, except for L-shaped cranks. A curved road with one lane in each direction. #### Preferred vector map The bounds of the Lanelet follow the lane lines and are smooth. #### Incorrect vector map The end of the Lanelet is not straight, and its right bound is uneven and leaves the lane line. --- ### vm-01-06 Line position (1) #### Detail of requirements Put the Linestring of the road center line in the exact middle of the road marking. A road with one lane in each direction and a dashed road center line. #### Preferred vector map Close-up: the Linestring is in the middle of the marking. #### Incorrect vector map Close-up: the Linestring is at the edge of the marking. --- ### vm-01-07 Line position (2) #### Detail of requirements If the road has lines on its outer sides, put each Linestring in the middle of the line. A road with wide edge lines on both sides. #### Preferred vector map Each Linestring is in the middle of its edge line. #### Incorrect vector map None in particular. --- ### vm-01-08 Line position (3) #### Detail of requirements If the road has no lines on its outer sides, put the Linestring 0.5 m inside the road edge. A road with no lines on its outer sides. ##### Caution The width depends on the laws of your country. #### Preferred vector map Each outer Linestring is 0.5 m inside the road edge. #### Incorrect vector map None in particular. --- ### vm-01-09 Speed limits #### Detail of requirements In the following cases, add a speed limit (*tag:speed\_limit*) in km/h to the Lanelet (*subtype:road*) on which the vehicle drives. - A speed limit road sign exists. - You want a lower speed limit, for example on narrow roads. If a Lanelet has no *speed\_limit* tag, Lanelet2 uses a default speed limit from its *location* and *subtype*. For *location:urban* and *subtype:road*, the default is 50 km/h. Autoware settings and behaviors control the following. They do not need tags: - The maximum velocity of the vehicle - Slower speeds where they are necessary, for example in curves and on downhill roads A speed limit road sign. #### Preferred vector map The Lanelet next to the sign has speed\_limit 20. #### Incorrect vector map None in particular. --- ### vm-01-10 Centerline #### Detail of requirements By default, Autoware drives along the midpoints between the left and right Linestrings of a Lanelet. If the vehicle must drive to the left or right of this midpoint for a reason, add a centerline to the Lanelet. The centerline is a Linestring that the Lanelet refers to with the role *centerline*. Give the centerline a smooth shape that the vehicle can drive. By default, the map loader of Autoware (parameter `use_waypoints`, `true` by default) stores the centerline from the map as the *waypoints* of the Lanelet. Only the path planning of the ego vehicle uses these waypoints. Other modules, for example the prediction of other vehicles, use the midpoints between the bounds. The vehicle moves to the right for a short distance, then back. ##### Caution The centerline of a Lanelet is a different concept from the road center line (the line that divides the lanes of opposite directions). #### Preferred vector map The centerline moves to the right and back with smooth diagonal parts. #### Incorrect vector map The centerline moves in sharp steps that the vehicle cannot drive. --- ### vm-01-11 Centerline connection (1) #### Detail of requirements When you add centerlines to several Lanelets one after the other, connect the centerlines. The vehicle moves to the right and back two times on a long road. #### Preferred vector map The two centerlines meet at the same point on the Lanelet border. #### Incorrect vector map The two centerlines end at different points on the Lanelet border. --- ### vm-01-12 Centerline connection (2) #### Detail of requirements If a Lanelet with a centerline connects to Lanelets without one, put the start and end points of the centerline in the middle of the Lanelet. Give the centerline a smooth shape that the vehicle can drive. The vehicle moves to the right and back in the middle part of the road only. #### Preferred vector map The centerline starts and ends in the middle of the Lanelet. #### Incorrect vector map The centerline does not start and end in the middle of the Lanelet. --- ### vm-01-13 Roads with no centerline (1) #### Detail of requirements If a road has no road center line but is wide enough for the vehicle and an oncoming vehicle to pass each other, put two Lanelets side by side, with the shared Linestring in the middle of the road. A wide road without a road center line. #### Preferred vector map Two Lanelets side by side share one Linestring in the middle of the road. #### Incorrect vector map None in particular. --- ### vm-01-14 Roads with no centerline (2) #### Detail of requirements Apply this requirement if all the following conditions are satisfied: - The road is a single lane without a road center line, and it is too narrow for the vehicle and an oncoming vehicle to pass each other while both move. - If other vehicles use this road, an oncoming vehicle can pass the autonomous vehicle when the autonomous vehicle moves to the left side of the road and stops. If they cannot pass each other in this way (for example, when one vehicle must back up), other vehicles must not enter the road while the autonomous vehicle is on it. - The autonomous vehicle drives forth and back on this road. Requirement for Vector Map creation: - Put two Lanelets on top of each other. The two Lanelets use the same two Linestrings in opposite directions: the left bound of one Lanelet is the right bound of the other. ##### Supplementary information - Whether this case applies depends on the local operation policies and the vehicle specifications. Decide it with the map requestor. - The bidirectional traffic module of the behavior path planner finds such pairs of Lanelets. The Lanelets need no special tags. On these Lanelets, the module moves the path of the vehicle to the left of the road center. If it detects an oncoming vehicle, it moves the vehicle to the left side, stops it, and waits until the oncoming vehicle has passed. The default preset of `autoware_launch` enables this module. - The module always gives way in this way. It does not back up the vehicle, and it does not move the vehicle into a road shoulder to give way. It cannot handle cases in which the vehicles cannot pass each other this way. The vehicle drives outward on a narrow road and later comes back on it. #### Preferred vector map Two Lanelets in opposite directions lie on top of each other and use the same Linestrings. #### Incorrect vector map The road is split into a left part and a right part, with the Lanelets side by side. #### Related Autoware module - [Bidirectional Traffic - Autoware Universe Documentation]() --- ### vm-01-15 Road shoulder #### Detail of requirements If the road has a shoulder, put a Lanelet for the road shoulder (*subtype:road\_shoulder*) on it. You do not need to create this Lanelet inside intersections. The road shoulder's Lanelet and the sidewalk share the Linestring between them (*type:road\_border*). A road shoulder Lanelet must not be next to another road shoulder Lanelet. A road Lanelet must be next to the road shoulder Lanelet. ##### Behavior of Autoware - Autoware can start from the road shoulder and can also stop on the road shoulder at the goal. - The Autoware parameter `margin_from_boundary` of the goal planner sets the margin between the vehicle and the edge of the road shoulder at the goal. You do not need to consider it when you create the Vector Map. - The goal planner does not select a goal on the road shoulder Lanelet where the vehicle overlaps with any of the following: - A Polygon of a *no\_parking\_area* - A Polygon of a *no\_stopping\_area* - The goal planner and the start planner do not look for intersections or crosswalks. If the vehicle must not stop on the road shoulder near or in an intersection, or on a crosswalk, cover that place with a *no\_parking\_area* or a *no\_stopping\_area* Polygon. The road shoulder Lanelet must refer to its regulatory element. See [vm-06-02](<../category_area/#vm-06-02-no-parking-signs>) and [vm-06-03](<../category_area/#vm-06-03-no-stopping-signs>). This is a requirement for the map, not a check that Autoware does. The Linestring at the boundary of the road shoulder does not need *tag:lane\_change=yes*. A curved road with a road shoulder and a sidewalk on each side. #### Preferred vector map Road shoulder Lanelets, and road\_border Linestrings between the road shoulders and the sidewalks. #### Incorrect vector map Do not create a road shoulder Lanelet for a road without a road shoulder. A road shoulder Lanelet on a road that has a side strip, not a road shoulder. #### Related Autoware module - [Static Avoidance - Autoware Universe Documentation]() - [Dynamic Avoidance - Autoware Universe Documentation]() - [Start Planner design - Autoware Universe Documentation]() - [Goal Planner design - Autoware Universe Documentation]() --- ### vm-01-16 Road shoulder Linestring sharing #### Detail of requirements The Lanelets of the road shoulder and of the road next to it must share a Linestring. A curved road with a road shoulder and a sidewalk on each side. #### Preferred vector map Each road shoulder Lanelet shares the Linestring at the edge line with the road Lanelet next to it. #### Incorrect vector map None in particular. #### Related Autoware module - [Static Avoidance - Autoware Universe Documentation]() - [Dynamic Avoidance - Autoware Universe Documentation]() - [Goal Planner design - Autoware Universe Documentation]() --- ### vm-01-17 Side strip #### Detail of requirements Put a Lanelet (*subtype:pedestrian\_lane*) on the side strip. A side strip is the strip outside the edge line of a road that has no sidewalk. You do not need to create this Lanelet inside intersections. The outer Linestring of the side strip's Lanelet must have *type:road\_border*. A curved road with a side strip on each side and no sidewalk. #### Preferred vector map Pedestrian lane Lanelets on the side strips, with road\_border Linestrings on their outer sides. #### Incorrect vector map None in particular. --- ### vm-01-18 Side strip Linestring sharing #### Detail of requirements The Lanelet of the side strip and the road Lanelet next to it must share a Linestring. A curved road with a side strip on each side and no sidewalk. #### Preferred vector map Each side strip Lanelet shares the Linestring at the edge line with the road Lanelet next to it. #### Incorrect vector map None in particular. --- ### vm-01-19 Walkway #### Detail of requirements Put a sidewalk Lanelet (*subtype:walkway*) only where the path of the vehicle crosses a sidewalk, for example at the entrance of a private area. Do not put one where the vehicle does not cross the sidewalk. The Lanelet (*subtype:walkway*) must cover the part of the sidewalk that the vehicle crosses, plus 3 m before and 3 m after it. ##### Behavior of Autoware The walkway module stops the vehicle before a *walkway* Lanelet on its path. Then the vehicle continues. The vehicle crosses the sidewalk to enter a private area. #### Preferred vector map A walkway Lanelet covers the crossing and 3 m on each side of it. #### Incorrect vector map None in particular. #### Related Autoware module - [Intersection - Autoware Universe Documentation]() - [Walkway design - Autoware Universe Documentation]()