design driving scenarios, configure sensors, and generate synthetic data

description

the driving scenario designer app enables you to design synthetic driving scenarios for testing your autonomous driving systems.

using the app, you can:

create road and actor models using a drag-and-drop interface.
configure vision, radar, lidar, ins, and ultrasonic sensors mounted on the ego vehicle. you can use these sensors to generate actor and lane boundary detections, point cloud data, and inertial measurements.
load driving scenarios representing european new car assessment programme (euro ncap^®) test protocols [1][2][3] and other prebuilt scenarios.
import asam opendrive^® roads and lanes into a driving scenario. the app supports opendrive^® file versions 1.4 and 1.5, as well as asam opendrive file version 1.6.
import road data from openstreetmap^®, here hd live map ¹ , or zenrin japan map api 3.0 (itsumo navi api 3.0) ² web services into a driving scenario.
importing data from the zenrin japan map api 3.0 (itsumo navi api 3.0) service requires .
export the road network in a driving scenario to the asam opendrive file format. the app supports opendrive file versions 1.4 and 1.5, as well as asam opendrive file version 1.6.
export road network, actors, and trajectories in a driving scenario to the asam openscenario^® 1.0 file format.
export synthetic sensor detections to matlab^®.
generate matlab code of the scenario and sensors, and then programmatically modify the scenario and import it back into the app for further simulation.
generate a simulink^® model from the scenario and sensors, and use the generated models to test your sensor fusion or vehicle control algorithms.

to learn more about the app, see these videos:

open the driving scenario designer app

matlab toolstrip: on the apps tab, under automotive, click the app icon.
matlab command prompt: enter drivingscenariodesigner.

examples

create a driving scenario

create a driving scenario of a vehicle driving down a curved road, and export the road and vehicle models to the matlab workspace. for a more detailed example of creating a driving scenario, see .

open the driving scenario designer app.

drivingscenariodesigner

create a curved road. on the app toolstrip, click add road. click the bottom of the canvas, extend the road path to the middle of the canvas, and click the canvas again. extend the road path to the top of the canvas, and then double-click to create the road. to make the curve more complex, click and drag the road centers (open circles), double-click the road to add more road centers, or double-click an entry in the heading (°) column of the road centers table to specify a heading angle as a constraint to a road center point.

an animation of a road built by creating road centers

add lanes to the road. in the left pane, on the roads tab, expand the lanes section. set number of lanes to 2. by default, the road is one-way and has solid lane markings on either side to indicate the shoulder.

a two-lane road with a dashed white lane marking in the center

add a vehicle at one end of the road. on the app toolstrip, select add actor > car. then click the road to set the initial position of the car.

a blue car on the road but not aligned with the direction of the road

set the driving trajectory of the car. right-click the car, select add forward waypoints, and add waypoints for the car to pass through. after you add the last waypoint, press enter. the car autorotates in the direction of the first waypoint.

the car with a trajectory that follows the right lane of the road

adjust the speed of the car as it passes between waypoints. in the waypoints, speeds, wait times, and yaw table in the left pane, set the velocity, v (m/s), of the ego vehicle as it enters each waypoint segment. increase the speed of the car for the straight segments and decrease its speed for the curved segments. for example, the trajectory has six waypoints, set the v (m/s) cells to 30, 20, 15, 15, 20, and 30.

the v (m/s) values for the six waypoints specified in the table

run the scenario, and adjust settings as needed. then click save > roads & actors to save the road and car models to a mat file.

generate sensor data from scenario

generate lidar point cloud data from a prebuilt euro ncap driving scenario.

for more details on prebuilt scenarios available from the app, see .
for more details on available euro ncap scenarios, see .

load a euro ncap autonomous emergency braking (aeb) scenario of a collision with a pedestrian child. at collision time, the point of impact occurs 50% of the way across the width of the car.

path = fullfile(matlabroot,'toolbox','shared','drivingscenario', ...
    'prebuiltscenarios','euroncap');
addpath(genpath(path)) % add folder to path
drivingscenariodesigner('aeb_pedestrianchild_nearside_50width.mat')
rmpath(path) % remove folder from path

a driving scenario containing a moving car, two parked cars, and a pedestrian

add a lidar sensor to the ego vehicle. first click add lidar. then, on the sensor canvas, click the predefined sensor location at the roof center of the car. the lidar sensor appears in black at the predefined location. the gray color that surrounds the car is the coverage area of the sensor.

a car on the sensor canvas with a lidar on its roof center

run the scenario. inspect different aspects of the scenario by toggling between canvases and views. you can toggle between the sensor canvas and scenario canvas and between the bird's-eye plot and ego-centric view.

in the bird's-eye plot and ego-centric view, the actors are displayed as meshes instead of as cuboids. to change the display settings, use the display options on the app toolstrip.

the scenario displays with the sensor canvas on the left and the bird's-eye plot on the right.

export the sensor data to the matlab workspace. click export > export sensor data, enter a workspace variable name, and click ok.

import programmatic driving scenario and sensors

programmatically create a driving scenario, radar sensor, and camera sensor. then import the scenario and sensors into the app. for more details on working with programmatic driving scenarios and sensors, see .

create a simple driving scenario by using a object. in this scenario, the ego vehicle travels straight on a 50-meter road segment at a constant speed of 30 meters per second. for the ego vehicle, specify a classid property of 1. this value corresponds to the app class id of 1, which refers to actors of class car. for more details on how the app defines classes, see the class parameter description in the actors parameter tab.

scenario = drivingscenario;
roadcenters = [0 0 0; 50 0 0];
road(scenario,roadcenters);
egovehicle = vehicle(scenario,'classid',1,'position',[5 0 0]);
waypoints = [5 0 0; 45 0 0];
speed = 30;
smoothtrajectory(egovehicle,waypoints,speed)

create a radar sensor by using a object, and create a camera sensor by using a object. place both sensors at the vehicle origin, with the radar facing forward and the camera facing backward.

radar = drivingradardatagenerator('mountinglocation',[0 0 0]);
camera = visiondetectiongenerator('sensorlocation',[0 0],'yaw',-180);

import the scenario, front-facing radar sensor, and rear-facing camera sensor into the app.

drivingscenariodesigner(scenario,{radar,camera})

a driving scenario of a car on a straight road

sensor view of vehicle. the vehicle contains two sensors mounted to the center of the rear axle. the radar sensor in red points forward and the camera sensor in blue points backward.

you can then run the scenario and modify the scenario and sensors. to generate new drivingscenario, drivingradardatagenerator, and visiondetectiongenerator objects, on the app toolstrip, select export > export matlab function, and then run the generated function.

generate simulink model of scenario and sensor

load a driving scenario containing a sensor and generate a simulink model from the scenario and sensor. for a more detailed example on generating simulink models from the app, see .

load a prebuilt driving scenario into the app. the scenario contains two vehicles crossing through an intersection. the ego vehicle travels north and contains a camera sensor. this sensor is configured to detect both objects and lanes.

path = fullfile(matlabroot,'toolbox','shared','drivingscenario','prebuiltscenarios');
addpath(genpath(path)) % add folder to path
drivingscenariodesigner('egovehiclegoesstraight_vehiclefromleftgoesstraight.mat')
rmpath(path) % remove folder from path

on the left, the scenario view of cars crossing at an intersection. on the right, a bird's-eye view of the scenario that displays detections and sensor coverage areas.

generate a simulink model of the scenario and sensor. on the app toolstrip, select export > export simulink model. if you are prompted, save the scenario file.

generated model containing a scenario reader block and a vision detection generator block

the block reads the road and actors from the scenario file. to update the scenario data in the model, update the scenario in the app and save the file.

the block recreates the camera sensor defined in the app. to update the sensor in the model, update the sensor in the app, select export > export sensor simulink model, and copy the newly generated sensor block into the model. if you updated any roads or actors while updating the sensors, then select export > export simulink model. in this case, the scenario reader block accurately reads the actor profile data and passes it to the sensor.

specify vehicle trajectories for 3d simulation

create a scenario with vehicle trajectories that you can later recreate in simulink for simulation in a 3d environment.

open one of the prebuilt scenarios that recreates a default scene available through the 3d environment. on the app toolstrip, select open > prebuilt scenario > simulation3d and select a scenario. for example, select the doublelanechange.mat scenario.

divided highway scene with traffic cones for completing a double lane change maneuver

specify a vehicle and its trajectory.

car driving to avoid traffic cone to complete the double lane change maneuver

update the dimensions of the vehicle to match the dimensions of the predefined vehicle types in the 3d simulation environment.

on the actors tab, select the 3d display type option you want.
on the app toolstrip, select 3d display > use 3d simulation actor dimensions. in the scenario canvas, the actor dimensions update to match the predefined dimensions of the actors in the 3d simulation environment.

preview how the scenario will look when you later recreate it in simulink. on the app toolstrip, select 3d display > view simulation in 3d display. after the 3d display window opens, click run.

on left, double lane change maneuver in driving scenario designer. on right, double lane change maneuver in 3d display.

modify the vehicle and trajectory as needed. avoid changing the road network or the actors that were predefined in the scenario. otherwise, the app scenario will not match the scenario that you later recreate in simulink. if you change the scenario, the 3d display window closes.

when you are done modifying the scenario, you can recreate it in a simulink model for use in the 3d simulation environment. for an example that shows how to set up such a model, see .

related examples

import asam opendrive roads into driving scenario

parameters

`roads` — road width, bank angle, heading angle, lane specifications, and road center locations
tab

to enable the roads parameters, add at least one road to the scenario. then, select a road from either the scenario canvas or the road parameter. the parameter values in the roads tab are based on the road you select.

parameter	description
road	road to modify, specified as a list of the roads in the scenario.
name	name of the road. the name of an imported road depends on the map service. for example, when you generate a road using openstreetmap data, the app uses the name of the road when it is available. otherwise, the app uses the road id specified by the openstreetmap data.
width (m)	width of the road, in meters, specified as a decimal scalar in the range (0, 50]. if the curvature of the road is too sharp to accommodate the specified road width, the app does not generate the road. default: `6`
number of road segments	number of road segments, specified as a positive integer. use this parameter to enable composite lane specification by dividing the road into road segments. each road segment represents a part of the road with a distinct lane specification. lane specifications differ from one road segment to another. for more information on composite lane specifications, see . default: `1`
segment range	normalized range for each road segment, specified as a row vector of values in the range (0, 1). the length of the vector must be equal to the number of road segments parameter value. the sum of the vector must be equal to `1`. by default, the range of each road segment is the inverse of the number of road segments. dependencies to enable this parameter, specify a number of road segments parameter value greater than `1`.
road segment	select a road segment from the list to specify its lanes parameters. dependencies to enable this parameter, specify a number of road segments parameter value greater than `1`.

`lanes` — lane specifications, such as lane types and lane markings
tab section

use these parameters to specify lane information, such as lane types and lane markings. when the value of the number of road segments parameter is greater than 1, these parameters apply to the selected road segment.

parameter description

number of lanes

number of lanes in the road, specified as one of these values:

integer, m, in the range [1, 30] — creates an m-lane road whose default lane markings indicate that the road is one-way.
two-element vector, [m n], where m and n are positive integers whose sum must be in the range [2, 30] — creates a road with (m n) lanes. the default lane markings of this road indicate that it is two-way. the first m lanes travel in one direction. the next n lanes travel in the opposite direction.

if you increase the number of lanes, the added lanes are of the width specified in the lane width (m) parameter. if lane width (m) is a vector of differing lane widths, then the added lanes are of the width specified in the last vector element.

lane width (m)

width of each lane in the road, in meters, specified as one of these values:

decimal scalar in the range (0, 50] — the same width applies to all lanes.
n-element vector of decimal values in the range (0, 50] — a different width applies to each lane, where n is the total number of lanes specified in the number of lanes parameter.

the width of each lane must be greater than the width of the lane markings it contains. these lane markings are specified by the marking > width (m) parameter.

lane types lanes in the road, specified as a list of the lane types in the selected road. to modify one or more lane parameters that include lane type, color, and strength, select the desired lane from the drop-down list.

lane types > type

type of lane, specified as one of these values:

'driving' — lanes for driving.
'border' — lanes at the road borders.
'restricted' — lanes reserved for high occupancy vehicles.
'shoulder' — lanes reserved for emergency stopping.
'parking'— lanes alongside driving lanes, intended for parking vehicles.

default: 'driving'

lane types > color

color of lane, specified as an rgb triplet with default values as:

type	color (default values)
`'driving'`	`[0.8 0.8 0.8]`
`'border'`	`[0.72 0.72 0.72]`
`'restricted'`	`[0.59 0.56 0.62]`
`'shoulder'`	`[0.59 00.59 0.59]`
`'parking'`	`[0.28 0.28 0.28]`

alternatively, you can also specify some common colors as an rgb triplet, hexadecimal color code, color name, or short color name. for more information, see color specifications for lanes and markings.

lane types > strength

saturation strength of lane color, specified as a decimal scalar in the range [0, 1].

a value of 0 specifies that the lane color is fully unsaturated, resulting in a gray colored lane.
a value of 1 specifies that the lane color is fully saturated, resulting in a true colored lane.

default: 1

lane markings

lane markings, specified as a list of the lane markings in the selected road. to modify one or more lane marking parameters which include marking type, color, and strength, select the desired lane marking from the drop-down list.

a road with n lanes has (n 1) lane markings.

lane markings > specify multiple marker types along a lane

select this parameter to define composite lane markings. a composite lane marking comprises multiple marker types along a lane. the portion of the lane marking that contains each marker type is referred as a marker segment. for more information on composite lane markings, see .

lane markings > number of marker segments

number of marker segments in a composite lane marking, specified as an integer greater than or equal to 2. a composite lane marking must have at least two marker segments. the app supports a maximum of 10 marker segments for every 1 meter of road length. for example, when you specify composite lane marking for a 10-meter road segment, the number of marker segments must be less than or equal to 100.

default: 2

dependencies

to enable this parameter, select the specify multiple marker types along a lane parameter.

lane markings > segment range

normalized range for each marker segment in a composite lane marking, specified as a row vector of values in the range [0, 1]. the length of the vector must be equal to the number of marker segments parameter value.

default: [0.5 0.5]

dependencies

to enable this parameter, select the specify multiple marker types along a lane parameter.

lane markings > marker segment

marker segments, specified as a list of marker types in the selected lane marking. to modify one or more marker segment parameters that include marking type, color, and strength, select the desired marker segment from the drop-down list.

dependencies

to enable this parameter, select the specify multiple marker types along a lane parameter.

lane markings > type

type of lane marking, specified as one of these values:

unmarked — no lane marking
solid — solid line
dashed — dashed line
doublesolid — two solid lines
doubledashed — two dashed lines
soliddashed — solid line on left, dashed line on right
dashedsolid — dashed line on left, solid line on right

by default, for a one-way road, the leftmost lane marking is a solid yellow line, the rightmost lane marking is a solid white line, and the markings for the inner lanes are dashed white lines. for two-way roads, the default outermost lane markings are both solid white lines and the dividing lane marking is two solid yellow lines.