Movement-related modifiers examples

Example: placement of movement modifiers

OSC2 code: placement of movement modifiers

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial:
        car1.drive() with:
            speed([30..70]kph)

Example: absolute and relative movement modifiers

OSC2 code: absolute and relative movement modifiers

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do parallel(duration:[1.5..3]second, overlap:equal):
        sut.car.drive()
        car1.drive() with:
            position([10..20]meter, at: start) # Absolute distance from start of path
            speed([10..15]kph, faster_than: sut.car) # Relative
            lane(same_as: sut.car) # Relative)

Example: track actual movement of referenced vehicle

OSC2 code: track actual movement of referenced vehicle

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.scenario1()

scenario sut.scenario1:
    car1: vehicle


    do serial():
        phase1: parallel(duration:[1.5..3]second, overlap:equal):
            d1: sut.car.drive()
            d2: car1.drive()
        phase2: parallel(duration:[1.5..3]second, overlap:equal):
            d3: sut.car.drive()
            d4: car1.drive() with:
                l1: lane(side_of: sut.car, at: start)
                p1: position(time: [0.5..1]second, ahead_of: sut.car, at: start)
                l2: lane(same_as: sut.car, at: end)
                p2: position(time: [1.5..2]second, ahead_of: sut.car, at: end)

Example: track projected movement of referenced vehicle

OSC2 code: track projected movement of referenced vehicle

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle

    do serial():
        phase1: parallel(duration:[1.5..3]second, overlap:equal):
            d1: sut.car.drive()
            d2: car1.drive()
        phase2: parallel(duration:[1.5..3]second, overlap:equal):
            d3: sut.car.drive()
            d4: car1.drive() with:
                speed(speed: [30..200]kph)
                l1: lane(side_of: sut.car, at: start)
                p1: position(time: [0.5..1]second, ahead_of: sut.car, at: start)


                l2: lane(same_as: sut.car, at: end, track: projected)
                p2: position(time: [1.5..2]second, ahead_of: sut.car, at: end, track: projected)

Example: acceleration() modifier

OSC2 code: acceleration() modifier

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial:
        car1.drive() with:
            acceleration(5kphps)

Example: avoid_collisions()

OSC2 code: avoid_collisions()

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial:
        car1.drive() with:
            avoid_collisions(false)

Example: change_lane() example 1

OSC2 code: change_lane() example 1

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial:
        car1.drive() with:
            # Change lane one lane to the left
            change_lane(side: left)

Example: change_lane() example 2

OSC2 code: change_lane() example 2

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial:
        car1.drive() with:
            # Change the lane 1, 2 or 3 lanes to the right
            change_lane([1..3], right)

Example: change_speed()

OSC2 code: change_speed()

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial:
        car1.drive() with:
            change_speed([-20..20]kph)

Example: distance()

OSC2 code: distance()

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial():
        d1: car1.drive() with: distance([30..50]m)

Example: driver_controls()

OSC2 code: driver_controls()

import "$FTX/env/basic/adas_hlm_imps/ACC/acc_hlm_imp.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/M81_FTX_highway_straight_5km_3lane_oneway.xodr"
    set implicits_kind = none
    set test_drain_time = 0second

scenario sut.cancel_acc_with_cancel_button_press:

    # How much slower the ftx_driver should drive at after ACC cancellation
    # (verifying that controls have been passed back to ftx_driver properly).
    speed_delta_to_brake: speed with:
        keep(it == 5mps)

    # Desired cruise speed.
    ACC_cruise_speed: speed with:
        keep(default it == 11mps)

    # ACC actual speed should be, at the "steady state" phase, in the range of:
    # ACC_cruise_speed - ACC_tolerance < actual speed < ACC_cruise_speed + ACC_tolerance
    ACC_tolerance: speed with:
        keep(default it == 1mps)

    # "Grace" time for ACC to reach the target cruise speed.
    ACC_transition_drive_duration: time with:
        keep(default it == [2..4]second)

    # The duration of the "steady state" phase.
    ACC_cruise_speed_drive_duration: time with:
        keep(default it == [5..7]second)

    do serial():

        # Turn on ACC.
        sut.car.press_ACC_main_button()

        # Some intermediate drive.
        after_main_button_press: sut.car.drive(duration: [1..5]second) with:
            position(distance: 50meter, at: start)
            speed(speed:  ACC_cruise_speed, run_mode: best_effort)

        # Start ACC.
        sut.car.press_ACC_set_button(cruise_speed: ACC_cruise_speed)

        # Transitioning into ACC's cruise speed.
        transitioning_into_cruise_speed: sut.car.drive(duration: ACC_transition_drive_duration)

        # ACC "steady state" drive.
        acc_drive_with_cruise_speed: sut.car.drive(duration: ACC_cruise_speed_drive_duration)

        # Cancel ACC with cancel button press.
        sut.car.press_ACC_cancel_button()

        # Decelerating.
        decelerating_after_cancel: sut.car.drive(duration: [1..5]second) with:
            s: speed(ACC_cruise_speed - speed_delta_to_brake, at: end, run_mode: best_effort)

Example: duration()

OSC2 code: duration()

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/M36_FTX_suburban_4way_stops.xodr"


scenario top.my_drive:
  car1: vehicle

  duration([6..9]sec, tolerance: 1sec)

  do serial:
      car1.drive()
      log("start drive $(top.time)")
      car1.drive()  with:
        speed([50..70]kph)
        duration([3..5]sec, tolerance: 1sec)
      log("end drive $(top.time)")

extend top.main:
  do serial:
    log("start scenario $(top.time)")
    my_drive()
    log("end scenario $(top.time)")

Example: keep_lane()

OSC2 code: keep_lane()

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial:
        car1.drive() with:
            keep_lane()

Example: keep_position()

OSC2 code: keep_position()

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial:
        car1.drive() with:
            keep_position()

Example: keep_speed()

OSC2 code: keep_speed()

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial:
        car1.drive() with:
            speed([40..60]kph)
        car1.drive() with:
            keep_speed()

Example: lane() example 1

OSC2 code: lane() example 1

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial:
        car1.drive() with:
            # Drive in lane closest to the center of the road
            lane(1)

Example: lane() example 2

OSC2 code: lane() example 2

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial:
        car1.drive() with:
            # Drive in lane closest to the curb
            lane(1, from: curb)

Example: lane() example 3

OSC2 code: lane() example 3

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle
    car2: vehicle


    do parallel(overlap:equal):
        car2.drive()
        car1.drive() with:
            # Drive one lane left of car2
            lane(left_of: car2)

Example: lane() example 4

OSC2 code: lane() example 4

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle
    car2: vehicle


    do parallel(overlap:equal):
        car2.drive()
        car1.drive() with:
            # At the end of this phase, be either one or two lanes
            # to the right of car2
            lane([1..2], right_of: car2, at: end)

Example: lane() example 5

OSC2 code: lane() example 5

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle
    car2: vehicle


    do parallel(overlap:equal):
        car2.drive()
        car1.drive() with:
            # Be either one left, one right or the same as car2
            lane([-1..1], right_of: car2)

Example: lane() example 6

OSC2 code: lane() example 6

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle
    car2: vehicle


    do parallel(overlap:equal):
        car2.drive()
        car1.drive() with:
            # Be in the same lane as car2
            lane(same_as: car2)

Example: lateral()

OSC2 code: lateral()

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial:
        car1.drive() with:
            speed([40..60]kph)
        car1.drive() with:
            lateral(distance: 1.5meter, line: right, at: start)

Example: equivalent use of position() example 1

OSC2 code: equivalent use of position() example 1

import "$FTX/env/basic/exe_platforms/model_ssp/config/model_sumo_config"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.scenario1()

scenario sut.scenario1:
    car1: vehicle


    do parallel(overlap:equal):
        car1.drive() with:
            speed(speed: 30kph, at: end)
        sut.car.drive() with:
            position(time: 3second, behind: car1, at: end)

Example: equivalent use of position() example 2

OSC2 code: equivalent use of position() example 2

import "$FTX/env/basic/exe_platforms/model_ssp/config/model_sumo_config"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.scenario1()

scenario sut.scenario1:
    car1: vehicle


    do parallel(overlap:equal):
        car1.drive() with:
            position(time: 3second, ahead_of: sut.car, at: end)
        sut.car.drive() with:
            speed(speed: 40kph, at: end)

Example: position() example 1

OSC2 code: position() example 1

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial:
        car1.drive() with:
            # Absolute from the start of the path
            position([10..20]meter)

Example: position() example 2

OSC2 code: position() example 2

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle
    car2: vehicle


    do parallel(overlap:equal):
        car1.drive()
        car2.drive() with:
            # 40 meters ahead of car1 at end
            position(40meter, ahead_of: car1, at: end)

Example: position() example 3

OSC2 code: position() example 3

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle
    car2: vehicle


    do parallel(overlap:equal):
        car1.drive()
        car2.drive() with:
            # Behind car1 throughout
            position([20..30]meter, behind: car1)

Example: position() example 4

OSC2 code: position() example 4

import "$FTX/env/basic/exe_platforms/model_ssp/config/model_sumo_config"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.scenario1()

scenario sut.scenario1:
    car1: vehicle


    do parallel(overlap:equal):
        sut.car.drive()
        car1.drive() with:
            # Behind sut.car, measured by time
            position(time: [2..3]second, behind: sut.car)

Example: position() with tolerance

OSC2 code: position() with tolerance

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle
    car2:vehicle


    do car1.drive(duration: 5s) with:
        position(distance: [5..10]m, ahead_of: sut.car, tolerance: 2m)

Example: speed() example 1

OSC2 code: speed() example 1

import "$FTX/env/basic/exe_platforms/model_ssp/config/model_sumo_config"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.scenario1()

scenario sut.scenario1:

    do serial:
        sut.car.drive() with:
            # Absolute speed range
            speed([10..20]kph)

Example: speed() example 2

OSC2 code: speed() example 2

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle
    car2: vehicle


    do parallel(overlap:equal):
        car1.drive()
        car2.drive() with:
            # Faster than car1 by [1..5]kph
            speed([1..5]kph, faster_than: car1)

Example: speed() example 3

OSC2 code: speed() example 3

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle


    do serial:
        car1.drive() with:
            # Have that speed at end of the phase
            speed(5kph, at: end)

Example: speed() example 4

OSC2 code: speed() example 4

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle
    car2: vehicle


    do parallel(overlap:equal):
        car1.drive()
        car2.drive() with:
            # Really either slower or faster than car1
            speed([-20..20]kph, faster_than: car1)

Example: speed() with tolerance

OSC2 code: speed() with tolerance

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    car1: vehicle
    car2:vehicle


    do car1.drive(duration: 5s) with:
        speed([40..60]kph, tolerance: 5kph)

Example: define arc shape

OSC2 code: define arc shape

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"
import "$FTX/ext_modules/foretify_top/driver/behavior_layer/ftx_behaviors/shape/example_shapes/lane_change_shape.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

struct arc_shape inherits lane_change_shape:                                # line 1
    angle: angle with: keep(soft it == 0deg)                                # line 2
    radius: length with: keep(soft it == 0m)                                # line 3
    var time: time                                                          # line 4
    var request: shape_request                                              # line 5
                                                                            # line 6
    def duration()-> time is also:                                          # line 7
        return 5s                                                           # line 8
    def compute() is also:                                                  # line 9
        lon = 0.0m                                                          # line 10
        lat = 0.0m                                                          # line 11


scenario vehicle.drive_with_shape:
    c: arc_shape with (radius: 15m, angle: 10deg)

Example: continuity implemented in a scenario

OSC2 code: continuity implemented in a scenario

import "$FTX/env/basic/exe_platforms/model_ssp/config/model_sumo_config.osc"

extend test_config:
    set map = "$FTX/qa/odr_maps/straight_road_1040m_3x3.xodr"
    set implicits_kind = none

extend sut:
    keep (car.physical_drive == kinematic)

extend top.main:
    do sut.native_lane_change()


scenario sut.native_lane_change:
    init_lon_speed: speed with:
        keep(it == 20kph)
    init_lat_pos: length with:
        keep(it == 0m)

    lane_change: lane_change_shape with:
        keep(it.speed_lon == init_lon_speed)
        keep(it.total_duration == 10s)
        keep(it.lateral_distance == 3m)
        keep(it.lateral_acceleration == 0.5mpsps)
        keep(it.lane_change_direction == left)
        keep(it.transform == lane_relative)

    do serial:
        pre_shape: sut.car.drive(duration: 2s) with:
            speed(init_lon_speed, at: end)
            lateral(init_lat_pos, line: center, at: all)
        shape_drive: sut.car.drive() with:
            shape(quantity:position, request:both, shape_object: lane_change)

struct lane_change_shape inherits any_position_shape:
    speed_lon: speed with:
      keep (default speed_lon == 5mps)
    total_duration: time with:
      keep (default total_duration == 10s)
    lateral_distance: length with:
        keep(default lateral_distance == 3.5m)
    lateral_acceleration: acceleration with:
        keep(default lateral_acceleration == 0.5mpsps)
    lane_change_direction: av_side with:
        keep(default lane_change_direction == left)

    def duration()-> time is only:
        return total_duration

    def compute() is only:
        lon = speed_lon * t
        lat = 0m

        var acc_rl : float = lateral_acceleration/1millimeter_per_sec_sqr
        var lat_dist_rl :float = lateral_distance/1mm
        var t1 :=  math.sqrt(lat_dist_rl / acc_rl) * 1s

        if t > 0s:
            var tau : time
            if t > t1:
                tau = t1
            else:
                tau = t
            lat = lat + 0.5 * lateral_acceleration * tau * tau

        if t > t1:
            var tau : time
            if t > 2 * t1:
                tau = t1
            else:
                tau = t - t1
            var v_m := lateral_acceleration * t1
            lat = lat + v_m * tau - 0.5 * lateral_acceleration * tau * tau

        if lane_change_direction == right:
            lat = -lat