In the previous posts, we:<\/p>\n
- \n
- Established the foundation<\/a> for a MATLAB-based traffic swarm framework that generates randomized ambient traffic within a fixed region of interest (ROI).<\/li>\n
- Developed a scalable actor behavior model<\/a> in Simulink to fully leverage the Model-Based Design (MBD) workflow.<\/li>\n<\/ul>\n
While the ROI approach is effective for open roads, it often lacks the density and precision needed to stress-test intersection dynamics. This post explores the transition to intersection-centered traffic generation<\/strong>, which allows us to focus actor spawning on critical intersections. To support this, we also extend the actor behavior model to comply with traffic signals<\/strong>, ensuring a realistic and high-fidelity simulation environment.<\/p>\n
Create Urban Scenes in RoadRunner<\/h1>\n
We begin with a realistic, high-fidelity urban scene using the USCityBlockBidirectional.rrscene<\/span> in RoadRunner (refer to this example<\/a> for more details). This pre-built environment features 15 intersections with functioning traffic signals and four-lane bidirectional roads, providing the perfect playground for urban validation.<\/p>\n
![\"\"](\"https:\/\/blogs.mathworks.com\/autonomous-systems\/files\/2026\/01\/image1-2.png\")
<\/p>\nRoadRunner<\/a> facilitates the design of these complex scenes, ensuring that the physical and semantic layout\u2014including lane-level connectivity, complex junction geometries, and localized traffic signal placement\u2014aligns precisely with the rigorous requirements of urban autonomy testing.<\/p>\n
Create Scenarios in RoadRunner Scenario<\/h1>\n
To create scenarios in RoadRunner Scenario, we first add an ego vehicle and assign it a predefined route. This route serves as the \u201creference path\u201d<\/b> for our autonomous system\u2019s task. You can define this path through two primary methods:<\/p>\n
- \n
- Interactively:<\/strong> Manually draw a path by right-clicking the road surface to place waypoints. RoadRunner automatically snaps these points to lane centers, ensuring the path is lane-compliant and follows the road geometry.<\/li>\n
- Programmatically:<\/strong> Use automated path planning to generate the route. This involves building a navGraph<\/a> from the road network provided by the RoadRunner HD Map<\/a> and using a plannerAStar<\/a> object to calculate the optimal route between start and goal positions.\u00a0 A key advantage of the programmatic approach is the ability to perform replanning<\/b>\u2014the process of dynamically recalculating the vehicle\u2019s route during the simulation in response to environmental changes, such as a blocked lane or a revised destination. This capability is critical for urban autonomy, as it allows the ego vehicle to remain flexible and find the most efficient, legal route when the initial path is no longer viable.<\/li>\n<\/ul>\n
![\"\"](\"https:\/\/blogs.mathworks.com\/autonomous-systems\/files\/2026\/01\/image2-1.png\")
<\/p>\nBy defining the ego path first, we create the necessary foreground scenario. Then, we add background traffic to introduce the realism and unpredictability needed for validation.<\/p>\n
For more details about this workflow, please refer to the following resources:<\/p>\n
- \n
- Design Path Following Scenario<\/a><\/li>\n
- Lane-Level Path Planning with RoadRunner Scenario<\/a><\/li>\n<\/ul>\n
Add Randomized Ambient Traffic<\/h1>\n
To validate the path-following feature through intersections under realistic traffic conditions, we add randomized ambient traffic. This exposes the autonomous driving system to diverse, unpredictable interactions, ensuring robust and safe behavior across a wide range of scenarios.<\/p>\n
An earlier post<\/a> introduced a MATLAB-based traffic swarm framework that generates randomized ambient traffic within a fixed region of interest (ROI). However, the predefined ROI approach<\/strong> often lacks the density needed to stress-test specific junction dynamics. By transitioning to an Intersection-centered Traffic model<\/strong>, agents are positioned to interact with traffic signals and cross-traffic at targeted intersections. This setup enables rigorous stress-testing of perception and motion-planning systems in complex intersection scenarios.<\/p>\n
Configure Traffic Swarm Parameters<\/h2>\n
Compared to the predefined ROI approach<\/strong>, the key distinction of the Intersection-centered Traffic model<\/strong> is the introduction of a circular traffic swarm area defined between inner and outer radii and centered at intersections, as shown in the figure below.<\/p>\n
![\"\"](\"https:\/\/blogs.mathworks.com\/autonomous-systems\/files\/2026\/01\/image3-2.png\")
<\/p>\nWe introduce a spawn delay<\/strong> that defines the time between the simulation start and the spawning of the traffic swarm. This dynamic actor spawning<\/a> can be achieved by adding a \u201cWait<\/strong><\/a>\u201d action before the initial action phase.<\/p>\n
Ambient traffic is generated only when the ego vehicle enters the swarm area. This dynamic spawning strategy reduces unnecessary computation in unrelated regions of the simulation while focusing resources on the intersection under test.<\/p>\n
The following code snippet illustrates an example set of traffic swarm parameters used in the Intersection-centered Traffic model.<\/p>\n
%--- Define traffic swarm configuration<\/span>\r\ntrafficSwarmConfig.initialSpeedRange = [10, 15]; % Speed range [vmin, vmax] (m\/s)<\/span>\r\ntrafficSwarmConfig.TTC = 1.0;\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 % Safe distance between vehicles in Time-To-Contact (sec)<\/span>\r\ntrafficSwarmConfig.MinRouteLength = 239.9;\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 % Min route length (m)<\/span>\r\ntrafficSwarmConfig.JunctionId = 25; % Intersection id<\/span>\r\ntrafficSwarmConfig.Rmin = 27.3;\u00a0\u00a0\u00a0\u00a0 % Set the minimum radius for the traffic swarm (m)<\/span>\r\ntrafficSwarmConfig.Rmax = 74.7;\u00a0\u00a0\u00a0\u00a0 % Set the maximum radius for the traffic swarm (m)<\/span>\r\ntrafficSwarmConfig.SpawnDelay = 1.5; % Traffic spawning delay (sec)<\/span>\r\n\r\n%--- Define traffic distribution<\/span>\r\nactor(1).Asset = \"Sedan\"<\/span>;\r\nactor(1).NumOfActor = 6; % Set number of actors for Sedan<\/span>\r\nactor(2).Asset = \"SK_PickupTruck\"<\/span>;\r\nactor(2).NumOfActor = 3; % Set number of actors for Pickup Truck<\/span>\r\nactor(3).Asset = \"DeliveryVan\"<\/span>;\r\nactor(3).NumOfActor = 2; % Set number of actors for Delivery Van<\/span>\r\n\r\ntrafficSwarmConfig.TrafficDistribution = actor;\r\ntrafficSwarmConfig.NumberOfVehicles = sum([actor.NumOfActor]); % Total number of traffic swarm<\/span><\/pre>\nCreate the Traffic Swarm<\/h2>\n
After configuring the swarm parameters, we generate a randomized traffic swarm centered at intersections using the following MATLAB code snippet:<\/p>\n
rrApi = roadrunnerAPI(rrApp);\r\nAmbientTraffic = createTrafficSwarmAroundIntersection(mapInfo,trafficSwarmConfig,egoActor,rrApi);<\/pre>\n
The\u00a0createTrafficSwarmAroundIntersection()<\/span> function randomizes traffic poses centered at intersections while maintaining safe distances between vehicles according to the specified traffic swarm parameters (such as the Time-To-Contact).<\/p>\n
![\"\"](\"https:\/\/blogs.mathworks.com\/autonomous-systems\/files\/2026\/01\/image4-2.png\")
<\/p>\nIt is important to note that these traffic swarms execute randomized maneuvers and routes at the intersection, with randomized initial poses. Maneuvers at each intersection are selected at random based on lane-connection information from the V2X map<\/strong>. This ensures that even though the traffic is randomized, every vehicle follows a valid, navigable path through the intersection.<\/p>\n
![\"\"](\"https:\/\/blogs.mathworks.com\/autonomous-systems\/files\/2026\/01\/image5-2.png\")
<\/p>\nFor more details on generating V2X map messages from RoadRunner HD maps, please refer to the following resource:<\/p>\n
- \n
- Generate V2X MAP Message from RoadRunner<\/a><\/li>\n<\/ul>\n
Add Ambient Traffic to RoadRunner Scenario<\/h2>\n
We add the randomized traffic swarm to the RoadRunner Scenario using the RoadRunner Scenario Authoring APIs<\/a>. These MATLAB functions allow you to programmatically create and author scenarios in RoadRunner.<\/p>\n
The following MATLAB code demonstrates how to use MATLAB functions to define\u00a0actor assets<\/a>,\u00a0initial positions<\/a>,\u00a0routes<\/a>,\u00a0behavior model<\/a>, and\u00a0scenario logic<\/a>\u00a0for each ambient traffic vehicle.<\/p>\n
rrApp.newScenario(); % Create new scenario in RoadRunner Scenario<\/span>\r\nrrApi = roadrunnerAPI(rrApp); % Create RoadRunner authoring API object for the current RoadRunner session rrApp<\/span>\r\nprj = rrApi.Project; % get current RoadRunner project<\/span>\r\nrrs = rrApi.Scenario; % get current RoadRunner scenario<\/span>\r\nphaseLogic = rrs.PhaseLogic; % Logic for scenario<\/span>\r\n\r\nnumActors = height(AmbientTraffic); % trafficSwarmConfig.NumberOfVehicles;<\/span>\r\ncolors = lines(numActors);\r\ncolors(:,4) = 1; % Alpha (opacity) = 1: no transparency<\/span>\r\nactors = cell(numActors,1);\r\n\r\nbuiltInBehavior = getAsset(prj,\"Behaviors\/TrafficFollower.rrbehavior\"<\/span>,\"BehaviorAsset\"<\/span>);\r\n\r\nfor<\/span> i = 1:numActors\r\n assetPath = getAssetPath(AmbientTraffic.ActorType(i));\r\n actorAsset = getAsset(prj,assetPath, \"VehicleAsset\"<\/span>); % extract vehicle asset<\/span>\r\n actors{i} = rrs.addActor(actorAsset, AmbientTraffic.InitPosition(i,:)); % add actor to RoadRunner Scenario<\/span>\r\n actors{i}.ActorID = AmbientTraffic.ActorId(i); % assign actor ID<\/span>\r\n if<\/span> actors{i}.ActorID==EgoActor.ActorId % actor is ego?<\/span>\r\n actors{i}.Name = string(EgoActor.Name);\r\n end<\/span>\r\n\r\n actors{i}.Color = colors(i,:); % assign actor color, RGBA<\/span>\r\n actors{i}.BehaviorAsset = builtInBehavior; % assign builtInBehavior<\/span>\r\n actors{i}.InitialPoint.autoAnchor(); % Anchor point (initial position) to nearest road<\/span>\r\n\r\n % Set initial speed to an absolute value<\/span>\r\n initPhase = phaseLogic.initialPhaseForActor(actors{i});\r\n initSpeedAction = initPhase.findActions(\"ChangeSpeedAction\"<\/span>);\r\n initSpeedAction.Speed = AmbientTraffic.Speed(i);\r\n initSpeedAction.SpeedReference = \"absolute\"<\/span>;\r\n\r\n if<\/span> actors{i}.ActorID~=EgoActor.ActorId % actor is not ego?<\/span>\r\n % Add Serial Phase before initial phase for spawning actor<\/span>\r\n spawnPhase = addPhaseInSerial(phaseLogic,initPhase,\"SystemActionPhase\"<\/span>,Insertion=\"before\"<\/span>);\r\n addAction(spawnPhase,\"WaitAction\"<\/span>);\r\n durCondition = setEndCondition(spawnPhase,\"DurationCondition\"<\/span>);\r\n durCondition.Duration = trafficSwarmConfig.SpawnDelay; % Set spawn delay time<\/span>\r\n end<\/span>\r\nend\r\n<\/span><\/pre>\nAssign Actor Behaviors to the Ambient Traffic Vehicles<\/h2>\n
Each ambient traffic vehicle is assigned a behavior model that enables it to follow a designated route while complying with traffic signals and avoiding collisions using Adaptive Cruise Control (ACC). To fully leverage the Model-Based Design (MBD) workflow, this behavior model is implemented in Simulink, as shown below, and incorporates the following controllers:<\/p>\n
- \n
- Trajectory Follower:<\/strong> Ensures the vehicle accurately tracks the randomized path generated at the intersection.<\/li>\n
- Adaptive Cruise Control (ACC):<\/strong> Manages longitudinal speed to maintain safe distances from other vehicles.<\/li>\n
- Traffic Signal Follower:<\/strong> Allows the vehicle to perceive and respond to the state of traffic signals at the intersection.<\/li>\n<\/ul>\n
![\"\"](\"https:\/\/blogs.mathworks.com\/autonomous-systems\/files\/2026\/01\/Simulink-1.png\")
\r\n<\/span><\/pre>\nIn this implementation, the lead vehicle<\/strong> in the same lane as the ego vehicle is identified by localizing each vehicle\u2019s pose on the V2X map<\/strong>. We chose this approach\u00a0rather than using an\u00a0ideal ground truth<\/a><\/span>\u00a0sensor<\/a> to demonstrate an alternative implementation method\u2014comparing map-based vs. sensor-based logic.<\/p>\n
For more details on the implementation of ACC<\/strong> and the Trajectory Follower<\/strong>, see my previous post<\/a>. Please note a key architectural detail: the predefined reference path is assigned directly to the Trajectory Follower <\/strong>block within the Simulink model, rather than being fed from the Path Following Action<\/a> of the RoadRunner Scenario Reader. This provides another design alternative, allowing future flexibility in adopting online replanning.<\/p>\n
The Traffic Signal Follower<\/strong> is implemented by accessing the traffic signal controller runtime<\/a> and traffic signal runtime<\/a> APIs in RoadRunner Scenario. For more details about the Traffic Signal Follower, please refer to the following resource:<\/p>\n
- \n
- Traffic Signal Follower with RoadRunner Scenario<\/a><\/li>\n<\/ul>\n
Publishing Ready-to-Run Actor Behaviors<\/h2>\n
To assign the same Simulink actor behavior to multiple actors in RoadRunner, you can publish a ready-to-run package from your Simulink behavior model. This approach enables RoadRunner to execute the compiled behavior directly, without rebuilding the Simulink model at runtime, and allows the same package to be reused by many actors.<\/p>\n
Use the following command to generate the package:<\/p>\n
Simulink.publish.publishActor('TrafficFollowerSL'<\/span>,PackageType='ReadyToRun'<\/span>)<\/pre>\nFor further details on Ready-to-Run Actor Behaviors, see my earlier post<\/a> and the following link:<\/p>\n
- Adaptive Cruise Control (ACC):<\/strong> Manages longitudinal speed to maintain safe distances from other vehicles.<\/li>\n
- Trajectory Follower:<\/strong> Ensures the vehicle accurately tracks the randomized path generated at the intersection.<\/li>\n
- Lane-Level Path Planning with RoadRunner Scenario<\/a><\/li>\n<\/ul>\n
- Programmatically:<\/strong> Use automated path planning to generate the route. This involves building a navGraph<\/a> from the road network provided by the RoadRunner HD Map<\/a> and using a plannerAStar<\/a> object to calculate the optimal route between start and goal positions.\u00a0 A key advantage of the programmatic approach is the ability to perform replanning<\/b>\u2014the process of dynamically recalculating the vehicle\u2019s route during the simulation in response to environmental changes, such as a blocked lane or a revised destination. This capability is critical for urban autonomy, as it allows the ego vehicle to remain flexible and find the most efficient, legal route when the initial path is no longer viable.<\/li>\n<\/ul>\n
- Developed a scalable actor behavior model<\/a> in Simulink to fully leverage the Model-Based Design (MBD) workflow.<\/li>\n<\/ul>\n