Physical object actors examples
Example: use of physical object methods
OSC2 code: use of physical object methods
import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"
extend test_config:
set map = "$FTX_PACKAGES/maps/straight_long_road.xodr"
extend top.main:
group: common_plain_object_group
group_position_params: plain_object_group_position_params with:
keep(it.min_lat_offset == -2.1m)
keep(it.max_lat_offset == -1.8m)
keep(it.min_distance_between_objects == 5meter)
keep(it.max_distance_between_objects == 10meter)
top.plain_object_group_position_along_drive(group_position_params, group, sut_drive)
def get_object_attributes() is:
for obj in traffic.physical_objects:
logger.log_info("The object is $(obj.get_width()) wide and $(obj.get_length()) long")
do serial:
parallel(overlap:equal):
group_exists: group.group_exists(group_position_params)
sut_drive: sut.car.drive() with:
speed(speed: [40..80]kph)
duration([3..7]s)
call get_object_attributes()
Example: get_time_gap()
OSC2 code: get_time_gap()
import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"
extend test_config:
set implicits_kind = none
set test_drain_time = 0s
set map = "$FTX_PACKAGES/maps/M77_FTX_highway_straight_long_road.xodr"
set min_test_time = 0s
extend top.main:
r: odr_road
sutv: sut_vehicle
car1: vehicle
person1: person
var scenario_duration: time = 5s
var sutv_pos: msp_position
var sutv_lon_offset := 70m
sutv_par: position_along_road(sutv_pos, r, lon_offset: sutv_lon_offset)
car1_pos: msp_position
var car1_lon_offset := 50m
var car1_speed: speed = 10mps
car1_par: position_along_road(car1_pos, r, lon_offset: car1_lon_offset)
person1_pos1: msp_position
person1_pos2: msp_position
var person1_lon_offset := 150m
var person1_lat_offset:= 5m
person1_par1: position_along_road(person1_pos1, r, lon_offset: person1_lon_offset)
person1_par2: position_along_road(person1_pos2, r, lon_offset: person1_lon_offset, lat_offset: person1_lat_offset)
do parallel(overlap:equal, duration: scenario_duration):
sutv.drive() with:
along(r, start_offset: sutv_lon_offset, at: start)
lateral(0m, line: center)
lane(1)
car1.drive() with:
along(r, start_offset: car1_lon_offset, at: start)
lateral(0m, line: center)
speed(car1_speed, at: start)
lane(1)
person1.move(person1_pos2, duration: scenario_duration,
start_position: person1_pos1)
var time_gap_car1_sutv_at_end: time = sample(
car1.get_time_gap(sutv),@start)
record (time_gap_car1_sutv_at_end, unit: s, event: end,
text: "Time gap between car1 and sutv at end")
var time_gap_person1_sut_at_end: time = sample(
person1.get_time_gap(sutv),@start)
record (time_gap_person1_sut_at_end, unit: s, event: end,
text: "Time gap between person1 and sutv at end")
Example: get_time_headway()
OSC2 code: get_time_headway()
import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"
extend test_config:
set implicits_kind = none
set test_drain_time = 0s
set map = "$FTX_PACKAGES/maps/M77_FTX_highway_straight_long_road.xodr"
set min_test_time = 0s
extend top.main:
r: odr_road
sutv: sut_vehicle
car1: vehicle
person1: person
var scenario_duration: time = 5s
var sutv_pos: msp_position
var sutv_lon_offset := 70m
sutv_par: position_along_road(sutv_pos, r, lon_offset: sutv_lon_offset)
car1_pos: msp_position
var car1_lon_offset := 50m
var car1_speed: speed = 10mps
car1_par: position_along_road(car1_pos, r, lon_offset: car1_lon_offset)
person1_pos1: msp_position
person1_pos2: msp_position
var person1_lon_offset := 150m
var person1_lat_offset:= 5m
person1_par1: position_along_road(person1_pos1, r, lon_offset: person1_lon_offset)
person1_par2: position_along_road(person1_pos2, r, lon_offset: person1_lon_offset, lat_offset: person1_lat_offset)
do parallel(overlap:equal, duration: scenario_duration):
sutv.drive() with:
along(r, start_offset: sutv_lon_offset, at: start)
lateral(0m, line: center)
lane(1)
car1.drive() with:
along(r, start_offset: car1_lon_offset, at: start)
lateral(0m, line: center)
speed(car1_speed, at:start)
lane(1)
person1.move(person1_pos2, duration: scenario_duration,
start_position: person1_pos1, start_at_speed:true)
var time_headway_car1_sutv_at_end: time = sample(
car1.get_time_headway(sutv),@end)
record (time_headway_car1_sutv_at_end, unit: s, event: end,
text: "Time headway between car1 and sutv at end")
var time_headway_person1_sutv_at_end: time = sample(
person1.get_time_headway(sutv),@end)
record (time_headway_person1_sutv_at_end, unit: s, event: end,
text: "Time headway between person1 and sutv at end")
Example: cargo falls out of moving lead vehicle
OSC2 code: cargo falls out of moving lead vehicle
import "$FTX_BASIC/exe_platforms/model_ssp/config/model_carla_0_9_13_config.osc"
extend test_config:
set map = "$FTX_PACKAGES/maps/straight_long_road.xodr"
extend object_kind: [cargo]
actor cargo inherits plain_object(kind == cargo):
keep(is_supported_by_sim == true)
keep(default bbox.length in [0.1..5]m)
keep(default bbox.width in [0.1..5]m)
keep(default bbox.height in [0.1..5]m)
keep(default physical.passable == false)
extend top.main:
falling_cargo: cargo
lead_vehicle: vehicle
do parallel(overlap: any, start_to_start: 0s):
vehicles_drive: serial:
start_up_drive: parallel(overlap: equal):
sut.car.drive() with:
ss: speed([40..60]kph)
override(ss, run_mode: best_effort)
keep_lane()
lead_vehicle.drive() with:
position(time: [2..10]s, ahead_of: sut.car, at: start)
lane(same_as: sut.car, at: start)
keep_lane()
cargo_falls_drive: parallel(overlap: equal):
sut.car.drive() with:
sks: keep_speed()
override(sks, run_mode: best_effort)
keep_lane()
lvs: lead_vehicle.drive() with:
acceleration([-4..-2]mpsps)
ls: speed(speed: [0..2]kph, at: end)
override(ls, run_mode: best_effort)
with:
dur: duration([5..10]s)
override(dur, run_mode: best_effort)
# cargo waits for lead_vehicle to start slowing down
# phase to start and falls from the lead vehicle
cargo_falling: serial:
wait @lvs.start
falling_cargo.fall_behind(attach_to: lead_vehicle,
height: [0.1..2.5]m,
air_drag: [0.1..1]mpsps,
lon_offset: [1..1.5]m,
lat_offset: [-1.5..1.5]m,
rel_angle: [-20..20]degree,
ground_drag_time: [2..4]s,
ground_drag: [2..5]mpsps)
Example: plain_object_group.appear()
OSC2 code: plain_object_group.appear()
import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"
extend test_config:
set map = "$FTX_PACKAGES/maps/straight_long_road.xodr"
scenario sut.test_group_appear:
ped_group: person_group with:
keep(it.objects.size() in [3..5])
pg_start_pos: plain_object_group_position_params
top.plain_object_group_position_along_drive(pg_start_pos, ped_group, d2)
do parallel(overlap: any, start_to_start: 0s):
serial:
d1: sut.car.drive() with:
duration([2..5]sec)
d2: sut.car.drive() with:
duration([5..10]sec)
pg_behavior: serial:
wait elapsed(1s)
call ped_group.appear(pg_start_pos)
extend top.main:
do serial:
sut.test_group_appear()
Example: stationary_truck_with_mounted_attenuator
OSC2 code: stationary_truck_with_mounted_attenuator
import "$FTX/env/basic/exe_platforms/model_ssp/config/model_sumo_config.osc"
extend test_config:
set implicits_kind = none
set map = "$FTX_QA/odr_maps/highway.xodr"
scenario sut.stationary_truck_with_mounted_attenuator_ahead:
stationary_truck: stationary_truck_with_mounted_attenuator
road: one_way_road with:
keep(it.min_lanes >= 3)
arrow_type: truck_attenuator_kind with:
keep(it == stationary_truck.attenuator_kind)
truck_position: msp_position
truck_position_modifier: top.position_along_road(truck_position,
road: road,
lon_offset: [50..100]m)
do parallel(overlap: any, start_to_start: 0s):
sut_drive: sut.car.drive() with:
along(road, at: start, start_offset: [10..15]m)
speed([30..]kph, at: start)
lane(middle:true, at: start)
keep_lane(run_mode: best_effort)
truck_exists: stationary_truck.exists_at(truck_position)
on @start:
call logger.log_info("Started $(self). Truck arrow direction: $(stationary_truck.attenuator_kind)")
# Use conditional inheritance to ensure that in both cases (right or left arrow board)
# the truck is positioned along the corresponding lane
scenario sut.stationary_truck_with_right_arrow_ahead inherits \
stationary_truck_with_mounted_attenuator_ahead(arrow_type == right_arrow_board):
keep(truck_position_modifier.leftmost_lane == true)
scenario sut.stationary_truck_with_left_arrow_ahead inherits \
stationary_truck_with_mounted_attenuator_ahead(arrow_type == left_arrow_board):
keep(truck_position_modifier.rightmost_lane == true)
extend top.main:
do a: sut.stationary_truck_with_mounted_attenuator_ahead()
Example: oscdom_physical_object_actors_ex7_get_ttc_to_object
OSC2 code: oscdom_physical_object_actors_ex7_get_ttc_to_object
import "$FTX/env/basic/exe_platforms/model_ssp/config/model_sumo_config.osc"
extend test_config:
set implicits_kind = none
set test_drain_time = 0s
set map = "$FTX_PACKAGES/maps/M77_FTX_highway_straight_long_road.xodr"
set min_test_time = 0s
extend top.main:
r: odr_road
var scenario_duration: time = 1s
sut_pos: msp_position
var sut_lon_offset := 30m
var sut_speed: speed = 5.00mps
var sut_acc : acceleration = 0.1mpsps
npc1_ahead_vehicle: vehicle with:
keep(it.vehicle_category == sedan)
npc1_pos: msp_position
var npc1_lon_offset := 55m
npc1_par: position_along_road(npc1_pos, r, lon_offset: npc1_lon_offset)
do parallel(start_to_start:0second, overlap:any, duration: scenario_duration):
drive_sut: sut.car.drive() with:
along(r, start_offset: sut_lon_offset, at: start)
lane(1)
speed(sut_speed)
avoid_collisions(false)
lateral(0m, line: center)
npc1_ahead_vehicle.drive() with:
along(r, start_offset: npc1_lon_offset, at: start)
lane(1)
speed(0kph)
avoid_collisions(false)
lateral(0m, line: center)
var ttc_sut_npc1_at_start: time = sample(
sut.car.get_ttc_to_object(npc1_ahead_vehicle),@start)
record (ttc_sut_npc1_at_start, unit: s, event: start,
text: "Time to Collision (TTC) between SUT and npc1 at start")
min_ttc_stat: statistics(sample_type: time, measurement: minimum)
on @top.clk:
min_ttc_stat.add_sample(sut.car.get_ttc_to_object(npc1_ahead_vehicle))
record(min_sut_npc1_ttc, expression: min_ttc_stat.compute(), range: [0.5..6], every: 0.5, unit: s, text: "Minimum TTC between SUT and npc1")
on @end:
logger.log_info("Minimum TTC to npc1 ahead: $(min_ttc_stat.compute())")
Example: oscdom_physical_object_actors_ex8_get_mttc_to_object
OSC2 code: oscdom_physical_object_actors_ex8_get_mttc_to_object
import "$FTX/env/basic/exe_platforms/model_ssp/config/model_sumo_config.osc"
extend test_config:
set implicits_kind = none
set test_drain_time = 0s
set map = "$FTX_PACKAGES/maps/M77_FTX_highway_straight_long_road.xodr"
set min_test_time = 0s
extend top.main:
r: odr_road
var scenario_duration: time = 1s
sut_pos: msp_position
var sut_lon_offset := 30m
var sut_speed: speed = 5.00mps
var sut_acc : acceleration = 0.1mpsps
npc1_ahead_vehicle: vehicle with: keep(it.vehicle_category == sedan)
npc1_pos: msp_position
var npc1_lon_offset := 55m
npc1_par: position_along_road(npc1_pos, r, lon_offset: npc1_lon_offset)
do parallel(start_to_start:0second, overlap:any, duration: scenario_duration):
drive_sut: sut.car.drive() with:
along(r, start_offset: sut_lon_offset, at: start)
lane(1)
speed(sut_speed, at: start)
avoid_collisions(false)
lateral(0m, line: center)
acceleration(sut_acc)
npc1_ahead_vehicle.drive() with:
along(r, start_offset: npc1_lon_offset, at: start)
lane(1)
speed(0kph)
avoid_collisions(false)
lateral(0m, line: center)
var mttc_sut_npc1_at_end: time = sample(
sut.car.get_mttc_to_object(npc1_ahead_vehicle),@end)
record (mttc_sut_npc1_at_end, unit: s, event: end,
text: "Modified Time to Collision (TTC) between SUT and npc1 at end")
min_mttc_stat: statistics(sample_type: time, measurement: minimum)
on @top.clk:
min_mttc_stat.add_sample(sut.car.get_mttc_to_object(npc1_ahead_vehicle))
record(min_sut_npc1_mttc, expression: min_mttc_stat.compute(), range: [0.5..6], every: 0.5, unit: s, text: "Minimum mTTC between SUT and npc1")
on @end:
logger.log_info("Minimum mTTC to npc1 ahead: $(min_mttc_stat.compute())")
Example: oscdom_physical_object_actors_ex9_plain_object_group_along_road
OSC2 code: oscdom_physical_object_actors_ex9_plain_object_group_along_road
import "$FTX/env/basic/exe_platforms/model_ssp/config/model_sumo_config.osc"
extend top.main:
a_road: one_way_road
around_offset: length with: keep(it in [20..30]m)
group: plain_object_group with:
keep(it.objects.size() in [4..5])
group_params: plain_object_group_position_params with:
keep(it.min_distance_between_objects == 2m)
keep(it.max_distance_between_objects == 3m)
keep(it.min_lat_offset == -3m)
keep(it.max_lat_offset == -2.5m)
plain_object_group_position_along_road(position_params: group_params, group: group, road: a_road, lon_offset: around_offset, rightmost_lane: true)
do parallel(duration: [5..6]s, start_to_start: 0s):
sut.car.drive() with:
along(a_road, start_offset: around_offset, at: start)
lane(rightmost: true)
group.group_exists(group_params)
extend test_config:
set implicits_kind = none
set test_drain_time = 0s
set map = "$FTX_PACKAGES/maps/M77_FTX_highway_straight_long_road.xodr"
set min_test_time = 0s
Example: use of distance to point measurement methods
OSC2 code: use of distance to point measurement methods
import "$FTX/env/basic/exe_platforms/model_ssp/config/model_sumo_config.osc"
extend test_config:
set map = "$FTX_PACKAGES/maps/M77_FTX_highway_straight_long_road.xodr"
extend top.main:
road: odr_road with: keep(it.odr_id == 1 and it.sub_id == 1)
fixed_position: msp_coordinates with:
keep(it.x == -276.1m)
keep(it.y == -2.64m)
keep(it.z == 0m)
do sut.car.drive(duration: [5..10]s) with: along(road)
on @start:
var global_distance := sut.car.global_distance_to_global_coordinates(fixed_position, front_center)
logger.log_info("Global distance from the front of sut.car to fixed_position is $(global_distance)")
var local_lat_distance := sut.car.local_distance_to_global_coordinates(fixed_position, front_center, lat)
logger.log_info("Lateral distance in local coordinates from the front of sut.car to fixed_position is $(local_lat_distance)")
var road_lon_distance := sut.car.road_distance_to_global_coordinates(fixed_position, front_center, lon, lane)
logger.log_info("Longitudinal distance in road coordinates from the front of sut.car to fixed_position is $(road_lon_distance)")