Main Content


Create driving scenario


The drivingScenario object represents a 3-D arena containing roads, vehicles, pedestrians, and other aspects of a driving scenario. Use this object to model realistic traffic scenarios and to generate synthetic detections for testing controllers or sensor fusion algorithms.

  • To add roads, use the road function. To specify lanes in the roads, create a lanespec object. You can also import roads from a third-party road network by using the roadNetwork function.

  • To add actors (cars, pedestrians, bicycles, and so on), use the actor function. To add actors with properties designed specifically for vehicles, use the vehicle function. To add barriers, use the barrier function. All actors, including vehicles and barriers, are modeled as cuboids (box shapes).

  • To simulate a scenario, call the advance function in a loop, which advances the simulation one time step at a time.

You can also create driving scenarios interactively by using the Driving Scenario Designer app. In addition, you can export drivingScenario objects from the app to produce scenario variations for use in either the app or in Simulink®. For more details, see Create Driving Scenario Variations Programmatically.




scenario = drivingScenario creates an empty driving scenario.


scenario = drivingScenario(Name,Value) sets the SampleTime, StopTime, and GeoReference properties using name-value pairs. For example, drivingScenario('GeoReference',[42.3 -71.0 0]) sets the geographic origin of the scene to a latitude-longitude coordinate of (42.3, –71.0) and an altitude of 0.


expand all

Time interval between scenario simulation steps, specified as a positive real scalar. Units are in seconds.

Example: 1.5

End time of simulation, specified as a positive real scalar. Units are in seconds. The default StopTime of Inf causes the simulation to end when the first actor reaches the end of its trajectory.

Example: 60.0

This property is read-only.

Current time of the simulation, specified as a positive real scalar. To reset the time to zero, call the restart function. Units are in seconds.

This property is read-only.

Simulation state, specified as true or false. If the simulation is running, IsRunning is true.

This property is read-only.

Actors and vehicles contained in the scenario, specified as a heterogeneous array of Actor and Vehicle objects. To add actors and vehicles to a driving scenario, use the actor and vehicle functions.

Barriers contained in the scenario, specified as a heterogeneous array of Barrier objects. To add barriers to a driving scenario, use the barrier function.

This property is read-only.

Geographic coordinates of the road network origin, specified as a three-element numeric row vector of the form [lat, lon, alt], where:

  • lat is the latitude of the coordinate in degrees.

  • lon is the longitude of the coordinate in degrees.

  • alt is the altitude of the coordinate in meters.

These values are with respect to the WGS84 reference ellipsoid, which is a standard ellipsoid used by GPS data.

You can set GeoReference when you create the driving scenario. The roadNetwork function also sets this property when you import roads into an empty driving scenario.

  • If you import roads by specifying coordinates, then the roadNetwork function sets GeoReference to the first (or only) specified coordinate.

  • If you import roads by specifying a region or map file, then the roadNetwork sets GeoReference to the center point of the region or map.

The roadNetwork function overrides any previously set GeoReference value.

In the Driving Scenario Designer app, when you import map data and export a drivingScenario object, the GeoReference property of that object is set to the geographic reference of the app scenario.

By specifying these coordinates as the origin in the latlon2local function, you can the convert geographic coordinates of a driving route into the local coordinates of a driving scenario. Then, you can specify this converted route as a vehicle trajectory in the scenario.

If your driving scenario does not use geographic coordinates, then GeoReference is an empty array, [].

Object Functions

expand all

advanceAdvance driving scenario simulation by one time step
plotCreate driving scenario plot
recordRun driving scenario and record actor states
restartRestart driving scenario simulation from beginning
updatePlotsUpdate driving scenario plots
exportExport driving scenario to OpenDRIVE or ASAM OpenSCENARIO file
actorAdd actor to driving scenario
actorPosesPositions, velocities, and orientations of actors in driving scenario
actorProfilesPhysical and radar characteristics of actors in driving scenario
vehicleAdd vehicle to driving scenario
barrierAdd a barrier to a driving scenario
chasePlotEgo-centric projective perspective plot
trajectoryCreate actor or vehicle trajectory in driving scenario
smoothTrajectoryCreate smooth, jerk-limited actor trajectory in driving scenario
targetPosesTarget positions and orientations relative to ego vehicle
targetOutlinesOutlines of targets viewed by actor
driving.scenario.targetsToEgoConvert target poses from scenario to ego coordinates
driving.scenario.targetsToScenarioConvert target poses from ego to scenario coordinates
roadAdd road to driving scenario or road group
roadNetworkAdd road network to driving scenario
roadBoundariesGet road boundaries
driving.scenario.roadBoundariesToEgoConvert road boundaries to ego vehicle coordinates
currentLaneGet current lane of actor
lanespecCreate road lane specifications
laneMarkingCreate road lane marking object
laneMarkingVerticesLane marking vertices and faces in driving scenario
laneBoundariesGet lane boundaries of actor lane
clothoidLaneBoundaryClothoid-shaped lane boundary model
computeBoundaryModelCompute lane boundary points from clothoid lane boundary model
laneTypeCreate road lane type object


collapse all

Create a driving scenario containing a curved road, two straight roads, and two actors: a car and a bicycle. Both actors move along the road for 60 seconds.

Create the driving scenario object.

scenario = drivingScenario('SampleTime',0.1','StopTime',60);

Create the curved road using road center points following the arc of a circle with an 800-meter radius. The arc starts at 0°, ends at 90°, and is sampled at 5° increments.

angs = [0:5:90]';
R = 800;
roadcenters = R*[cosd(angs) sind(angs) zeros(size(angs))];
roadwidth = 10;

Add two straight roads with the default width, using road center points at each end.

roadcenters = [700 0 0; 100 0 0];
ans = 
  Road with properties:

           Name: ""
         RoadID: 2
    RoadCenters: [2x3 double]
      RoadWidth: 6
      BankAngle: [2x1 double]

roadcenters = [400 400 0; 0 0 0];
ans = 
  Road with properties:

           Name: ""
         RoadID: 3
    RoadCenters: [2x3 double]
      RoadWidth: 6
      BankAngle: [2x1 double]

Get the road boundaries.

rbdry = roadBoundaries(scenario);

Add a car and a bicycle to the scenario. Position the car at the beginning of the first straight road.

car = vehicle(scenario,'ClassID',1,'Position',[700 0 0], ...

Position the bicycle farther down the road.

bicycle = actor(scenario,'ClassID',3,'Position',[706 376 0]', ...

Plot the scenario.


Figure contains an axes. The axes with title Scenario contains 1219 objects of type patch, line.

Display the actor poses and profiles.

poses = actorPoses(scenario)
poses=2×1 struct array with fields:

profiles = actorProfiles(scenario)
profiles=2×1 struct array with fields:

Create a driving scenario and show how target outlines change as the simulation advances.

Create a driving scenario consisting of two intersecting straight roads. The first road segment is 45 meters long. The second straight road is 32 meters long with jersey barriers along both its edges, and intersects the first road. A car traveling at 12.0 meters per second along the first road approaches a running pedestrian crossing the intersection at 2.0 meters per second.

scenario = drivingScenario('SampleTime',0.1,'StopTime',1);
road1 = road(scenario,[-10 0 0; 45 -20 0]);
road2 = road(scenario,[-10 -10 0; 35 10 0]);
ped = actor(scenario,'ClassID',4,'Length',0.4,'Width',0.6,'Height',1.7);
car = vehicle(scenario,'ClassID',1);
pedspeed = 2.0;
carspeed = 12.0;
smoothTrajectory(ped,[15 -3 0; 15 3 0],pedspeed);
smoothTrajectory(car,[-10 -10 0; 35 10 0],carspeed);

Create an ego-centric chase plot for the vehicle.


Create an empty bird's-eye plot and add an outline plotter and lane boundary plotter. Then, run the simulation. At each simulation step:

  • Update the chase plot to display the road boundaries and target outlines.

  • Update the bird's-eye plot to display the updated road boundaries and target outlines. The plot perspective is always with respect to the ego vehicle.

bepPlot = birdsEyePlot('XLim',[-50 50],'YLim',[-40 40]);
outlineplotter = outlinePlotter(bepPlot);
laneplotter = laneBoundaryPlotter(bepPlot);

while advance(scenario)
    rb = roadBoundaries(car);
    [position,yaw,length,width,originOffset,color] = targetOutlines(car);
    [bposition,byaw,blength,bwidth,boriginOffset,bcolor,barrierSegments] = targetOutlines(car,'Barriers');
    plotOutline(outlineplotter,position,yaw,length,width, ...
    plotBarrierOutline(outlineplotter,barrierSegments,bposition,byaw,blength,bwidth, ...

Figure contains an axes. The axes is empty.

Create a driving scenario containing an ego vehicle and a target vehicle traveling along a three-lane road. Detect the lane boundaries by using a vision detection generator.

scenario = drivingScenario;

Create a three-lane road by using lane specifications.

roadCenters = [0 0 0; 60 0 0; 120 30 0];
lspc = lanespec(3);

Specify that the ego vehicle follows the center lane at 30 m/s.

egovehicle = vehicle(scenario,'ClassID',1);
egopath = [1.5 0 0; 60 0 0; 111 25 0];
egospeed = 30;

Specify that the target vehicle travels ahead of the ego vehicle at 40 m/s and changes lanes close to the ego vehicle.

targetcar = vehicle(scenario,'ClassID',1);
targetpath = [8 2; 60 -3.2; 120 33];
targetspeed = 40;

Display a chase plot for a 3-D view of the scenario from behind the ego vehicle.


Create a vision detection generator that detects lanes and objects. The pitch of the sensor points one degree downward.

visionSensor = visionDetectionGenerator('Pitch',1.0);
visionSensor.DetectorOutput = 'Lanes and objects';
visionSensor.ActorProfiles = actorProfiles(scenario);

Run the simulation.

  1. Create a bird's-eye plot and the associated plotters.

  2. Display the sensor coverage area.

  3. Display the lane markings.

  4. Obtain ground truth poses of targets on the road.

  5. Obtain ideal lane boundary points up to 60 m ahead.

  6. Generate detections from the ideal target poses and lane boundaries.

  7. Display the outline of the target.

  8. Display object detections when the object detection is valid.

  9. Display the lane boundary when the lane detection is valid.

bep = birdsEyePlot('XLim',[0 60],'YLim',[-35 35]);
caPlotter = coverageAreaPlotter(bep,'DisplayName','Coverage area', ...
detPlotter = detectionPlotter(bep,'DisplayName','Object detections');
lmPlotter = laneMarkingPlotter(bep,'DisplayName','Lane markings');
lbPlotter = laneBoundaryPlotter(bep,'DisplayName', ...
    'Lane boundary detections','Color','red');
olPlotter = outlinePlotter(bep);
    visionSensor.MaxRange,visionSensor.Yaw, ...
while advance(scenario)
    [lmv,lmf] = laneMarkingVertices(egovehicle);
    tgtpose = targetPoses(egovehicle);
    lookaheadDistance = 0:0.5:60;
    lb = laneBoundaries(egovehicle,'XDistance',lookaheadDistance,'LocationType','inner');
    [obdets,nobdets,obValid,lb_dets,nlb_dets,lbValid] = ...
    [objposition,objyaw,objlength,objwidth,objoriginOffset,color] = targetOutlines(egovehicle);
    plotOutline(olPlotter,objposition,objyaw,objlength,objwidth, ...
    if obValid
        detPos = cellfun(@(d)d.Measurement(1:2),obdets,'UniformOutput',false);
        detPos = vertcat(zeros(0,2),cell2mat(detPos')');
    if lbValid


expand all

Introduced in R2017a