This example shows how to programmatically create a variety of road junctions with Automated Driving Toolbox™ functions. You can combine these junctions with other junctions to create complicated road networks. You can view the code for each plot and use it in your own project.

Alternatively, you can create road junctions interactively by using the Driving Scenario Designer app.

Roads of a fixed width can be defined by a series of points that define the locations of the center of the road. A straight road is very simple to describe by specifying its starting and stopping location. Here is an example of a road which starts at (0,0) and ends at (50,0) and has a width of 6 (meters).

```scenario = drivingScenario; roadCenters = [0 0; 50 0]; roadWidth = 6; road(scenario, roadCenters, roadWidth); plot(scenario,'RoadCenters','on','Centerline','on'); ```

As an alternative to specifying road widths, you can specify lanes by providing a lane specification. Here is an example of specifying a road with one lane on the left and two on the right.

```scenario = drivingScenario; roadCenters = [0 0; 50 0]; road(scenario, roadCenters, 'lanes', lanespec([1 2])); plot(scenario,'RoadCenters','on'); ```

### Intersections

Intersections are automatically generated wherever two roads meet. In this example, we add another 50 m section of road.

```roadCenters = [25 -25; 25 25]; road(scenario, roadCenters, 'lanes', lanespec([1 1])); ```

### Multiple Lane Specifications

You can also create roads with multiple road segments that have different lane specifications. This example creates a composite lane specification for a road to simulate lane drop.

```scenario = drivingScenario; roadCenters = [0 0; 50 0]; % Define an array of lane specifications for two one-way road segments. % Notice that one lane drops in the second road segment. lsArray = [lanespec(3) lanespec(2)]; % Define a road segment connector object. Specify position to drop a lane % and taper length. lc = laneSpecConnector('Position','Left','TaperLength',30); % Combine lane specifications of road segments. clspec = compositeLaneSpec(lsArray,'Connector',lc); road(scenario,roadCenters,'lanes',clspec); plot(scenario,'RoadCenters','on'); ```

Curved roads can be described by using three or more points. The more points you use, the more complex the curve you can create. In this example, we have a curve passing through three points:

```scenario = drivingScenario; roadCenters = [0 0; 10 0; 53 -20]; roadWidth = 6; road(scenario, roadCenters, roadWidth,'lanes',lanespec(2)); plot(scenario,'RoadCenters','on'); ```

When you specify the road centers, a piecewise clothoid curve is fit in between each segment, where curvature is preserved in between points. Clothoid curves are used extensively when designing roads, because they have a curvature that varies linearly with distance traveled along the road, which is very simple for drivers to navigate.

By default, roads built by the scenario will have no curvature at the endpoints. To make a road loop, repeat the first and last point.

In this example, we show a 4m wide circular road segment circumscribed about a 30 m square area. Adding roads that feed into the roundabout is a matter of specifying other straight or curved road segments:

```scenario = drivingScenario; roadCenters = [-15 -15 15 -15 15 15 -15 15 -15 -15]; road(scenario, roadCenters, 'lanes', lanespec(1)); % Define roundabout exits with two lanes each road(scenario, [-35 0; -20 0],'lanes', lanespec([1 1])); road(scenario, [ 20 0; 35 0],'lanes', lanespec([1 1])); road(scenario, [ 0 35; 0 20],'lanes', lanespec([1 1])); road(scenario, [ 0 -20; 0 -35],'lanes', lanespec([1 1])); plot(scenario,'RoadCenters','on'); ```

### Exit Lane

This example simulates a simple exit lane. We start with a simple straight road and then overlay a few points of another road so that it overlaps the original straight road:

```scenario = drivingScenario; ls = lanespec(2); laneWidth = ls.Width(1); % add straight road segment road(scenario, [0 0 0; 50 0 0], 'lanes', lanespec(2)); % define waypoints of lane exit roadCenters = [3.0 -laneWidth/2 3.1 -laneWidth/2 15.0 -laneWidth 45.0 -20]; % add the exit lane road(scenario, roadCenters, laneWidth); plot(scenario,'RoadCenters','on') ```

Roads can optionally have elevation information. This can be accomplished by including a third column in the waypoints.

```scenario = drivingScenario; roadCenters = [ 0 0 0 25 0 3 50 0 0]; road(scenario, roadCenters, 'lanes', lanespec(2)); plot(scenario,'RoadCenters','on'); view(30,24); ```

### Overpasses

Roads can cross each other without intersecting if they have differing elevation. The road surface of an overpass is typically 6 to 8 meters above the road.

```scenario = drivingScenario; roadCenters = [ 0 0 0 20 -20 0 20 20 8 -20 -20 8 -20 20 0 0 0 0]; road(scenario, roadCenters, 'lanes',lanespec([1 2])); plot(scenario,'RoadCenters','on'); view(30,24) ```

Roads can be banked, where bank angles can be defined for each waypoint. The following is an oval racetrack with 9 degree banked curves.

```scenario = drivingScenario; % transpose waypoints so they visually align with bank angles below roadCenters = ... [ 0 40 49 50 100 50 49 40 -40 -49 -50 -100 -50 -49 -40 0 -50 -50 -50 -50 0 50 50 50 50 50 50 0 -50 -50 -50 -50 0 0 .45 .45 .45 .45 .45 0 0 .45 .45 .45 .45 .45 0 0]'; bankAngles = ... [ 0 0 9 9 9 9 9 0 0 9 9 9 9 9 0 0]; road(scenario, roadCenters, bankAngles, 'lanes', lanespec(2)); plot(scenario,'RoadCenters','on'); view(-60,20) ```

```scenario = drivingScenario; % Add a long loop road segment roadCenters = [2023 2362; -2504 -2141; -2036 -2634; 2444 1870; 2023 2362]; % Specify the heading angles as a constraint to the road center points slope = roadCenters(2,:) - roadCenters(1,:); hdAngl = atand(slope(2)/slope(1)); roadHeadings = [hdAngl+180; hdAngl+180; hdAngl; hdAngl; hdAngl+180]; % Add the heading angles into the driving scenario road(scenario,roadCenters,'Heading',roadHeadings); plot(scenario,'RoadCenters','on') ```

### Diamond Interchange

Highways and expressways typically are comprised of two parallel roads, each going in the opposing direction. An economical interchange between a highway and a local road is a diamond interchange, which typically consists of a local road overpass and four ramps.

```scenario = drivingScenario; % Highways road(scenario, [-200 -8 0; 200 -8 0], 'lanes',lanespec(3)); % north road(scenario, [ 200 8 0;-200 8 0], 'lanes',lanespec(3)); % south % Local Road road(scenario, [-0 -200 8; 0 200 8], 'lanes',lanespec([1 1])); % Access ramps rampNE = [ 3 -20 8; 10 -20 7.8; 126 -20 .2; 130 -20 0; 200 -13.5 0]; road(scenario, [ 1 1 1] .* rampNE, 'lanes',lanespec(1)); road(scenario, [ 1 -1 1] .* flipud(rampNE), 'lanes',lanespec(1)); road(scenario, [-1 -1 1] .* rampNE, 'lanes',lanespec(1)); road(scenario, [-1 1 1] .* flipud(rampNE), 'lanes',lanespec(1)); plot(scenario); view(-60,30) ```

### Cloverleaf Interchange

A popular interchange between two highways is the cloverleaf interchange. The cloverleaf interchange consists of four inner and four outer ramps.

A limitation of the driving scenario is that road information is removed in the vicinity of a road junction.

```scenario = drivingScenario; % Highways road(scenario, [-300 -8 0; 300 -8 0], 15); % north road(scenario, [-300 8 0; 300 8 0], 15); % south road(scenario, [-8 -300 8; -8 300 8], 15); % east road(scenario, [ 8 -300 8; 8 300 8], 15); % west % Inner ramps rampNE = [0 -18 0; 20 -18 0; 120 -120 4; 18 -20 8; 18 0 8]; rampNW = [ 1 -1 1] .* rampNE(end:-1:1,:); rampSW = [-1 -1 1] .* rampNE; rampSE = [ 1 -1 1] .* rampSW(end:-1:1,:); innerRamps = [rampNE(1:end-1,:) rampNW(1:end-1,:) rampSW(1:end-1,:) rampSE]; road(scenario, innerRamps, 5.4); % Outer ramps roadCenters = [13.5 -300 8; 15 -260 8; 125 -125 4; 260 -15 0; 300 -13.5 0]; road(scenario, [ 1 1 1] .* roadCenters, 5.4); road(scenario, [ 1 -1 1] .* roadCenters, 5.4); road(scenario, [-1 -1 1] .* roadCenters, 5.4); road(scenario, [-1 1 1] .* roadCenters, 5.4); plot(scenario,'RoadCenters','on'); view(-60,30); ```

### Next Steps

This example showed how to create a variety of road junctions using a `drivingScenario` object. To add actors and trajectories to these roads using Automated Driving Toolbox functions, see Create Actor and Vehicle Trajectories Programmatically. Alternatively, you can add actors and trajectories interactively by loading the `drivingScenario` object into the Driving Scenario Designer app:

```drivingScenarioDesigner(scenario) ```