The drawings on this page use left-hand traffic, as in Japan: vehicles drive on the left side of the road, and a right turn crosses the opposing lane. For right-hand traffic, swap left and right. --- ## Requirements ### vm-03-01 Intersection criteria #### Detail of requirements Essential criteria for the construction of an intersection: - Encircle the drivable area at the intersection with a Polygon (*type:intersection\_area*). - Add *turn\_direction* to all Lanelets in the intersection. - Ensure that all lanelets in the intersection are tagged: - *key:intersection\_area* - *value: Polygon's ID* - Attach *right\_of\_way* to the necessary Lanelets. - Also, it is necessary to appropriately create traffic lights, crosswalks, and stop lines. For detailed information, refer to the respective requirements on this page. ##### Autoware modules - The intersection module uses *turn\_direction* and *right\_of\_way*. It plans the velocity to avoid collisions with other vehicles, and it takes the traffic lights into account. The blind spot module uses *turn\_direction* to check for bicycles and pedestrians on the side of a turning vehicle. - The static obstacle avoidance module uses the *intersection\_area* tag. It can plan a path that leaves the lane inside the intersection area (parameter `use_intersection_areas`, `true` by default). The lane change module also reads the *intersection\_area* tag. The intersection module can use the intersection area to detect vehicles outside the lanelets (parameter `use_intersection_area`, `false` by default). #### Preferred vector map None in particular. #### Incorrect vector map None in particular. #### Related Autoware module - [Intersection - Autoware Universe Documentation]() - [Blind Spot design - Autoware Universe Documentation]() - [Static Avoidance - Autoware Universe Documentation]() - [Lane Change - Autoware Universe Documentation]() --- ### vm-03-02 Lanelet's turn direction and virtual linestring #### Detail of requirements Add the following tag to the Lanelets in the intersection: - turn\_direction : straight - turn\_direction : left - turn\_direction : right Also, if the left or right Linestrings of Lanelets at the intersection lack road paintings, designate these as *type:virtual*. ##### Behavior of Autoware Autoware turns on the turn signal (blinker) before a Lanelet with *turn\_direction* left or right. By default, the turn signal starts when the distance to the start of that Lanelet is less than 30 m plus the distance that the vehicle drives in 3 s at its current speed. The parameters are `turn_signal_intersection_search_distance` and `turn_signal_search_time` of the behavior path planner. To change the distance for one Lanelet, add the following tag to it. This value then replaces the whole default distance. - key: *turn\_signal\_distance* - value: numerical value (m) A T-junction. A second road joins the main road from the south. #### Preferred vector map The lanelets in the junction have turn\_direction. The unpainted bound of the left turn is a virtual linestring. #### Incorrect vector map None in particular. #### Related Autoware module - [Intersection - Autoware Universe Documentation]() - [Blind Spot design - Autoware Universe Documentation]() - [Turn signal design - Autoware Universe Documentation]() --- ### vm-03-03 Lanelet width in the intersection #### Detail of requirements Lanelets in the intersection should have a consistent width. Additionally, draw Linestrings with smooth curves. The shape of this curve must be determined by the Vector Map creator. The ego vehicle turns right at an intersection with traffic lights. #### Preferred vector map Correct: the lanelet has a constant width and smooth linestrings. #### Incorrect vector map Incorrect: the width changes, and the linestrings are not smooth. --- ### vm-03-04 Lanelet creation in the intersection #### Detail of requirements Create all Lanelets in the intersection, including lanelets not driven by the vehicle. Additionally, link stop lines and traffic lights to the Lanelets appropriately. Refer also to the creation scope [vm-07-01](<../category_others/#vm-07-01-vector-map-creation-range>) ##### Behavior of Autoware Autoware uses lanelets to predict the movements of other vehicles and plan the vehicle's velocity accordingly. Therefore, it is necessary to create all lanelets in the intersection. The map has a lanelet for every lane and every turn. The ego vehicle turns left. #### Preferred vector map Correct: all lanelets in the intersection exist. #### Incorrect vector map Incorrect: only the lanelets of the ego vehicle exist. #### Related Autoware module - [Intersection - Autoware Universe Documentation]() --- ### vm-03-05 Lanelet division in the intersection #### Detail of requirements Create the Lanelets in the intersection as a single object without dividing them. The ego vehicle turns right at an intersection with traffic lights. #### Preferred vector map Correct: one lanelet goes from the entrance to the exit. #### Incorrect vector map Incorrect: the turn is divided into two lanelets. #### Related Autoware module - [Intersection - Autoware Universe Documentation]() --- ### vm-03-06 Guide lines in the intersection #### Detail of requirements If there are guide lines in the intersection, draw the Lanelet following them. In cases where the Lanelets branches off, begin the branching at the end of the guide line. However, it is not necessary to share points or linestrings between Lanelets. A guide line is a road painting. Give the Linestring along a dashed guide line *type:line\_thin* and *subtype:dashed*, not *type:virtual*. Use *type:virtual* only for the bounds without road paintings, as in [vm-03-02](<#vm-03-02-lanelets-turn-direction-and-virtual-linestring>). [Lanelet2]() defines *virtual* as a non-physical lane boundary. Camera-based localization (YabLoc) uses *line\_thin* Linestrings as road markings, but not *virtual* Linestrings. Lanelet2 permits a lane change across a *line\_thin* *dashed* Linestring. To prohibit it, add *lane\_change=no* (see [vm-01-02](<../category_lane/#vm-01-02-allowance-for-lane-changes>)). Guide lines for a right turn. On the right, the lane branches into two lanes. #### Preferred vector map The lanelets follow the guide lines. The branch starts at the end of the guide lines. #### Incorrect vector map None in particular. #### Related Autoware module - [Intersection - Autoware Universe Documentation]() --- ### vm-03-07 Multiple lanelets in the intersection #### Detail of requirements When connecting multiple lanes with Lanelets at an intersection, those Lanelets should be made adjacent to each other without crossing. Two vehicles turn right side by side. #### Preferred vector map Correct: the lanelets are next to each other and do not cross. #### Incorrect vector map Incorrect: the lanelets cross each other. #### Related Autoware module - [Intersection - Autoware Universe Documentation]() --- ### vm-03-08 Intersection area range #### Detail of requirements Encircle the intersection's drivable area with a Polygon (*type:intersection\_area*). The boundary of this intersection's Polygon should be defined by the objects below. - Linestrings (*type:road\_border*) - Straight lines at the connection points of lanelets in the intersection. #### Preferred vector map The intersection\_area polygon follows the road borders and the lanelet connection boundaries. #### Incorrect vector map None in particular. #### Related Autoware module - [Intersection - Autoware Universe Documentation]() - [Static Avoidance - Autoware Universe Documentation]() - [Lane Change - Autoware Universe Documentation]() --- ### vm-03-09 Range of Lanelet in the intersection #### Detail of requirements Determine the start and end positions of lanelets in the intersection (henceforth the boundaries of lanelet connections) based on the stop line's position. - For cases with a painted stop line: - The stop line's linestring (*type:stop\_line*) position must align with the lanelet's start. - Extend the lanelet's end to where the opposing lane's stop line would be. - Without a painted stop line: - Use a drawn linestring (*type:stop\_line*) to establish positions as if there were a painted stop line. #### Preferred vector map Each lanelet starts at its stop line and ends at the extended line of the opposite stop line. #### Incorrect vector map None in particular. #### Related Autoware module - [Intersection - Autoware Universe Documentation]() --- ### vm-03-10 Right of way (with signal) #### Detail of requirements Set the regulatory element 'right\_of\_way' for Lanelets that meet all of the following criteria: - Lanelets in the intersection with a *turn\_direction* of *right* or *left*. - Lanelets that intersect with the vehicle's lanelet. - There are traffic lights at the intersection. Set to *yield* those lanelets in the intersection that intersect the vehicle's lanelet, and set to *yield* those lanelets that do not share the same signal change timing with the vehicle. Also, if the vehicle is turning left, set the opposing vehicle's right-turn lane to *yield*. There is no need to set *yield* for lanelets where the vehicle goes straight (*turn\_direction:straight*). The ego vehicle turns left (left) or right (right) at an intersection with traffic lights. #### Preferred vector map ##### The vehicle turns left Left turn: the crossing lane of the other signal phase and the opposing right turn are yield lanes. ##### The vehicle turns right Right turn: the crossing lanes of the other signal phase are yield lanes. #### Incorrect vector map None in particular. #### Related Autoware module - [Intersection - Autoware Universe Documentation]() - [How to set the RightOfWay tag - Autoware Universe Documentation]() --- ### vm-03-11 Right of way (without signal) #### Detail of requirements Set the regulatory element 'right\_of\_way' for Lanelets that meet all of the following criteria: - Lanelets in the intersection with a *turn\_direction* of *right* or *left*. A lanelet with *turn\_direction* *straight* also needs it in the cases below. - Lanelets that intersect with the vehicle's lanelet. - There are **no** traffic lights at the intersection. Case 1: the ego vehicle is on the priority road. Case 2: it is on the non-priority road. #### Preferred vector map ##### Case 1: the vehicle is on the priority lane Case 1: the crossing lanes and the opposing right turn are yield lanes. ##### Case 2: the vehicle is on the non-priority lane A regulatory element is not necessary. However, when the vehicle goes straight, it has relative priority over other vehicles turning right from the opposing non-priority road. Therefore, settings for *right\_of\_way* and *yield* are required in this case. Case 2: the opposing right turn is the yield lane. #### Incorrect vector map None in particular. #### Related Autoware module - [Intersection - Autoware Universe Documentation]() - [How to set the RightOfWay tag - Autoware Universe Documentation]() --- ### vm-03-12 Right of way supplements #### Detail of requirements ##### Why it's necessary to configure 'right\_of\_way' Without the 'right\_of\_way' setting, Autoware interprets other lanes intersecting its path as having priority. Therefore, as long as there are other vehicles in the crossing lane, Autoware cannot enter the intersection regardless of signal indications. An example of a problem: Even when our signal allows proceeding, our vehicle waits beforehand if other vehicles are waiting at a red light where the opposing lane intersects with a right-turn lane. #### Preferred vector map None in particular. #### Incorrect vector map None in particular. #### Related Autoware module - [Intersection - Autoware Universe Documentation]() --- ### vm-03-13 Merging from private area, sidewalk #### Detail of requirements Set *location=private* for Lanelets within private property. Give the private Lanelet that joins the public road a *turn\_direction* tag, as in [vm-03-02](<#vm-03-02-lanelets-turn-direction-and-virtual-linestring>). Without this tag, the intersection module does not stop the vehicle before the public road. When a road, which enters or exits private property, intersects with a sidewalk, create a Lanelet for that sidewalk (*subtype:walkway*). ##### Behavior of Autoware - The vehicle stops temporarily before entering the sidewalk. The walkway module does this for a *subtype:walkway* Lanelet. - The vehicle comes to a stop before merging onto the public road. The intersection module does this ("merge from private") for a Lanelet on the path that has *location=private* and a *turn\_direction* tag, when the next Lanelet on the path is not private. Vehicles enter and leave a private area across the sidewalk. #### Preferred vector map Private lanelets have location=private, and the crossed sidewalk is a walkway lanelet. #### Incorrect vector map None in particular. #### Related Autoware module - [Merge from private - Autoware Universe Documentation]() - [Walkway - Autoware Universe Documentation]() --- ### vm-03-14 Road marking #### Detail of requirements If there is a stop line ahead of the guide lines in the intersection, ensure the following: - Create a Lanelet for the guide lines. - The Lanelet for the guide lines references a Regulatory Element (*subtype:road\_marking*). - The Regulatory Element refers to the *stop\_line*'s Linestring. The intersection module uses this stop line as the default stop line of the Lanelet. Refer to [Web.Auto Documentation - Creation of Regulatory Element]() for the method of creation in Vector Map Builder. A stop line at the end of the guide lines for a right turn. #### Preferred vector map The lanelet refers to a road\_marking regulatory element, which refers to the stop line. #### Incorrect vector map None in particular. #### Related Autoware module - [Intersection - Autoware Universe Documentation]() --- ### vm-03-15 Exclusive bicycle lane #### Detail of requirements If an exclusive bicycle lane exists, create a Lanelet with *subtype:bicycle\_lane* for it. The bicycle lane and the road Lanelet next to it must share a Linestring. In left-hand traffic, the bicycle lane is on the left side of the road Lanelet. In right-hand traffic, it is on the right side. A bicycle lane connects only to other bicycle lanes. Autoware supports *subtype:bicycle\_lane* in maps with *format\_version* 2 or later. See [Bicycle lane in the autoware\_lanelet2\_extension documentation](). Older maps model the bicycle lane as a Lanelet with *subtype:road*. In that case, set *lane\_change = no* on the Linestring that the bicycle lane shares with the road. For bicycle lanes at intersections, assign a *yield* designation beneath the *right\_of\_way* for lanes that intersect with the vehicle's left-turn lane. (Refer to [vm-03-10](<../category_intersection/#vm-03-10-right-of-way-with-signal>) and [vm-03-11](<../category_intersection/#vm-03-11-right-of-way-without-signal>) for right\_of\_way). ##### Behavior of Autoware The blind spot module checks the side of a turning vehicle for bicycles and pedestrians. It uses the *road\_shoulder* or *bicycle\_lane* Lanelet next to the outermost road Lanelet on the turning side. If there is none, it uses the outermost road Lanelet. The road sign for an exclusive bicycle lane in Japan. A road with an exclusive bicycle lane on each side. #### Preferred vector map Each bicycle lane is a bicycle\_lane lanelet that shares a linestring with the road lanelet. #### Incorrect vector map None in particular. #### Related Autoware module - [Blind Spot design - Autoware Universe Documentation]()