def test_generate_traffic(traffic: Traffic): with tempfile.TemporaryDirectory() as temp_dir: gen_traffic( "scenarios/intersections/4lane_t", traffic, output_dir=temp_dir, name="generated", ) with open("smarts/sstudio/tests/baseline.rou.xml") as f: items = [x.items() for x in ElementTree(file=f).iter()] with open(os.path.join(temp_dir, "traffic", "generated.rou.xml")) as f: generated_items = [x.items() for x in ElementTree(file=f).iter()] print(sorted(items)) print(sorted(generated_items)) assert sorted(items) == sorted(generated_items)
) car_type = patient_car car_name = "patient_car" traffic = Traffic( flows=[ Flow( route=RandomRoute(), begin=0, end=1 * 60 * 60, # make sure end time is larger than the time of one episode rate=30, actors={car_type: 1}, ) for i in range(sv_num) ] ) print(f"generate flow with {sv_num} social {car_name} vehicles in {scenario_path} ") gen_traffic( scenario_path, traffic, name=f"{sv_num}_{car_name}", output_dir=scenario_path, seed=seed, overwrite=True, )
Flow, Route, RandomRoute, TrafficActor, Mission, ) scenario = os.path.dirname(os.path.realpath(__file__)) agent_missions = [ Mission(Route(begin=("left_in", 0, 80), end=("merged", (0, ), 40))), Mission(Route(begin=("left_in", 0, 50), end=("merged", (0, ), 40))), Mission(Route(begin=("ramp_in", 0, 80), end=("merged", (0, ), 60))), Mission(Route(begin=("ramp_in", 0, 50), end=("merged", (0, ), 60))), ] gen_missions(scenario, agent_missions, overwrite=True) gen_traffic( scenario, Traffic(flows=[ Flow( route=RandomRoute(), rate=3600, actors={TrafficActor(name="car"): 1.0}, ) ]), name="random", overwrite=True, )
("west-WE", "south-NS"), ("north-NS", "west-EW"), ("east-EW", "north-SN"), ] for name, routes in { "vertical": vertical_routes, "horizontal": horizontal_routes, "unprotected_left": turn_left_routes, "turns": turn_left_routes + turn_right_routes, "all": vertical_routes + horizontal_routes + turn_left_routes + turn_right_routes, }.items(): traffic = Traffic(flows=[ Flow( route=Route( begin=(f"edge-{r[0]}", 0, "random"), end=(f"edge-{r[1]}", 0, "random"), ), rate=1, actors={patient_car: 1.0}, ) for r in routes ]) gen_traffic(scenario, traffic, name=name, overwrite=True)
] for name, routes in { "vertical": vertical_routes, "horizontal": horizontal_routes, "unprotected_left": turn_left_routes, "turns": turn_left_routes + turn_right_routes, "all": vertical_routes + horizontal_routes + turn_left_routes + turn_right_routes, }.items(): traffic = Traffic(flows=[ Flow( route=Route( begin=(f"edge-{r[0]}", 0, "random"), end=(f"edge-{r[1]}", 0, "random"), ), rate=1, actors={ impatient_car: 0.5, patient_car: 0.5 }, ) for r in routes ]) gen_traffic(scenario, traffic, name=name)
from smarts.sstudio import gen_traffic, gen_bubbles, gen_missions scenario = str(Path(__file__).parent) # Definition of a traffic flow traffic = t.Traffic( flows=[ t.Flow( route=t.Route( begin=("west", lane_idx, 10), end=("east", lane_idx, -10), ), rate=50, actors={ t.TrafficActor("car"): 1, }, ) for lane_idx in range(3) ] ) # The call to generate traffic gen_traffic(scenario, traffic, name="basic") gen_missions( scenario, [ t.Mission(t.Route(begin=("west", 0, 0), end=("east", 0, "max"))), ], )
def generate_left_turn_missions( mission, route_distributions, route_lanes, speed, map_dir, level_name, save_dir, stopwatcher_behavior, stopwatcher_route, seed, intersection_name, traffic_density, ): # dont worry about these seeds, theyre used by sumo sumo_seed = random.choice([0, 1, 2, 3, 4]) stopwatcher_info = None stopwatcher_added = False if stopwatcher_behavior: stopwatcher_info = { "behavior": stopwatcher_behavior, "direction": get_direction(stopwatcher_route), } random.seed(seed) np.random.seed(seed) all_flows = [] metadata = {"routes": {}, "total_vehicles": 0, "stopwatcher": None} scenario = save_dir + f"-flow-{seed}" # Remove old traffic route if it exists(otherwise, won't update to new flows) if os.path.exists(f"{scenario}/traffic/all.rou.xml"): shutil.rmtree(scenario) for route_key, route_info in route_distributions["routes"].items(): # to skip None if route_info: if stopwatcher_behavior: # put the ego on the side road ego_start_lane, ego_end_lane = 0, 0 mission_start, mission_end = "south-side", "dead-end" ego_start_pos, ego_end_pos = 100, 5 ego_num_lanes = 1 else: mission_start, mission_end = mission["start"], mission["end"] ego_start_lane, ego_end_lane = ( route_lanes[mission_start] - 1, route_lanes[mission_end] - 1, ) ego_start_pos, ego_end_pos = ( random.randint(50, 120), random.randint(50, 150), ) ego_num_lanes = route_lanes[mission_start] ego_route = Route( begin=(f"edge-{mission_start}", ego_start_lane, ego_start_pos), end=(f"edge-{mission_end}", ego_end_lane, ego_end_pos), ) flows, vehicles_log_info = generate_social_vehicles( ego_start_lane=ego_start_lane, route_distribution=route_info["distribution"], begin_time_init=route_info["begin_time_init"], num_vehicles=route_info["vehicles"], route_direction=get_direction(route_key), route_lanes=route_lanes, route_has_turn=route_info["has_turn"], start_end_on_different_lanes_probability=route_info[ "start_end_on_different_lanes_probability"], deadlock_optimization=route_info["deadlock_optimization"], stopwatcher_info=stopwatcher_info, ) if (stopwatcher_behavior and len(flows) > 0 and get_direction(route_key) == stopwatcher_info["direction"]): stopwatcher_added = True print( f'stop watcher added to {get_direction(route_key)} flows among {route_info["vehicles"]} vehicles!' ) all_flows.extend(flows) metadata["routes"][route_key] = vehicles_log_info scenario = save_dir + f"-flow-{seed}" if stopwatcher_behavior: if not stopwatcher_added and level_name != "no-traffic": print( f'There was no matching flows for stopwatcher, adding it to {stopwatcher_info["direction"]}.' ) # vehicles_log_info[f'stopwatcher_{stopwatcher_info["behavior"]}']["count"] += 1 all_flows.append( generate_stopwatcher( stopwatcher_behavior=stopwatcher_info["behavior"], stopwatcher_route=stopwatcher_info["direction"], start_lane_id=0, end_lane_id=0, )) scenario += f"-stopwatcher-{stopwatcher_info['behavior']}" copy_map_files(scenario, map_dir, speed) if stopwatcher_behavior or "ego_hijacking_params" not in route_distributions: gen_missions(scenario, [Mission(ego_route)]) else: speed_m_per_s = float("".join(filter(str.isdigit, speed))) * 5.0 / 18.0 hijacking_params = route_distributions["ego_hijacking_params"] zone_range = hijacking_params["zone_range"] waiting_time = hijacking_params["wait_to_hijack_limit_s"] start_time = hijacking_params["start_time"] if start_time == "default": start_time = random.randint((LANE_LENGTH // speed_m_per_s), 60) gen_missions( scenario, [ Mission( ego_route, # optional: control hijacking time, place, and emission. start_time= start_time, # when to start hijacking (might start later) entry_tactic=TrapEntryTactic( wait_to_hijack_limit_s= waiting_time, # when to give up on hijacking and start emitting a social vehicle instead zone=MapZone( start=( f'edge-{mission["start"]}', 0, ego_start_pos + zone_range[0], ), length=zone_range[1], n_lanes=route_lanes[mission["start"]], ), # area to hijack exclusion_prefixes=tuple( ), # vehicles to be excluded (check vehicle ids) ), ), ], ) traffic = Traffic(flows=all_flows) gen_traffic(scenario, traffic, name=f"all", seed=sumo_seed) # patch: remove route files from traffic folder to make intersection empty if traffic_density == "no-traffic": os.remove(f"{scenario}/traffic/all.rou.xml") if stopwatcher_behavior: metadata["stopwatcher"] = { "direction": stopwatcher_info["direction"], "behavior": stopwatcher_info["behavior"], } metadata["intersection"] = { "type": intersection_name[-1], "name": intersection_name, } metadata["total_vehicles"] = len(all_flows) metadata["seed"] = seed metadata["flow_id"] = f"flow_{seed}" with open(f"{scenario}/metadata.json", "w") as log: json.dump(metadata, log)
car_type_impatient = impatient_car car_type_impatient_ratio = 0.5 car_name_impatient = "impatient_car" traffic = Traffic(flows=[ Flow( route=RandomRoute(), begin=0, end=1 * 60 * 60, # make sure end time is larger than the time of one episode rate=30, actors={ car_type_patient: car_type_patient_ratio, car_type_impatient: car_type_impatient_ratio }, ) for i in range(sv_num) ]) print( f"generate flow with {sv_num} social {car_name_patient, car_name_impatient} vehicles in {scenario_path} " ) gen_traffic( scenario_path, traffic, name= f"{sv_num * 2}_{car_name_patient}_{car_type_patient_ratio}_{car_name_impatient}_{car_type_impatient_ratio}", output_dir=scenario_path, seed=seed, overwrite=True, )
traffic_actor = TrafficActor(name="car", speed=Distribution(sigma=0.1, mean=0.3),) for scenario_path, sv_num in zip(scenario_paths, sv_nums): traffic = Traffic( flows=[ Flow( route=RandomRoute(), begin=0, end=1 * 60 * 60, # make sure end time is larger than the time of one episode rate=60, actors={traffic_actor: 1}, ) for i in range(sv_num) ] ) print(f"generate flow with {sv_num} social vehicles in {scenario_path.name} ") gen_traffic( scenario_path, traffic, name="all", output_dir=scenario_path, seed=seed, overwrite=True, ) print("generate social vehicle flows finished")
from pathlib import Path from typing import Any, Tuple import smarts.sstudio.types as types from smarts.sstudio import gen_missions, gen_traffic scenario = str(Path(__file__).parent) patient_car = types.TrafficActor(name="car", ) shared_route = types.Route( begin=("edge-east", 0, 20), end=("edge-west", 0, 0), ) traffic = types.Traffic( flows=[types.Flow( route=shared_route, rate=1, actors={patient_car: 1}, )]) gen_missions( scenario, missions=[ types.Mission(shared_route), ], ) gen_traffic(scenario, traffic, "traffic")
def generate_left_turn_missions( missions, shuffle_missions, route_distributions, route_lanes, speed, map_dir, level_name, save_dir, stopwatcher_behavior, stopwatcher_route, seed, stops, bubbles, intersection_name, traffic_density, ): # dont worry about these seeds, theyre used by sumo sumo_seed = random.choice([0, 1, 2, 3, 4]) stopwatcher_info = None stopwatcher_added = False if stopwatcher_behavior: stopwatcher_info = { "behavior": stopwatcher_behavior, "direction": get_direction(stopwatcher_route), } random.seed(seed) np.random.seed(seed) all_flows = [] metadata = {"routes": {}, "total_vehicles": 0, "stopwatcher": None} scenario = save_dir + f"-flow-{seed}" # Remove old traffic route if it exists(otherwise, won't update to new flows) if os.path.exists(f"{scenario}/traffic/all.rou.xml"): shutil.rmtree(scenario) for route_key, route_info in route_distributions["routes"].items(): # to skip None if route_info: ego_routes = [ ego_mission_config_to_route( ego_mission_config=ego_mission_config, route_lanes=route_lanes, stopwatcher_behavior=stopwatcher_behavior, ) for ego_mission_config in missions ] # Not all routes need to have a custom start/end offset if "pos_offsets" in route_info: pos_offsets = route_info["pos_offsets"] else: pos_offsets = None flows, vehicles_log_info = generate_social_vehicles( route_distribution=route_info["distribution"], begin_time_init=route_info["begin_time_init"], num_vehicles=route_info["vehicles"], route_direction=get_direction(route_key), route_lanes=route_lanes, route_has_turn=route_info["has_turn"], start_end_on_different_lanes_probability=route_info[ "start_end_on_different_lanes_probability" ], stops=stops, deadlock_optimization=route_info["deadlock_optimization"], pos_offsets=pos_offsets, stopwatcher_info=stopwatcher_info, traffic_params={"speed": speed, "traffic_density": traffic_density}, ) if ( stopwatcher_behavior and len(flows) > 0 and get_direction(route_key) == stopwatcher_info["direction"] ): stopwatcher_added = True print( f'stop watcher added to {get_direction(route_key)} flows among {route_info["vehicles"]} vehicles!' ) all_flows.extend(flows) metadata["routes"][route_key] = vehicles_log_info scenario = save_dir + f"-flow-{seed}" if stopwatcher_behavior: if not stopwatcher_added and level_name != "no-traffic": print( f'There was no matching flows for stopwatcher, adding it to {stopwatcher_info["direction"]}.' ) # vehicles_log_info[f'stopwatcher_{stopwatcher_info["behavior"]}']["count"] += 1 all_flows.append( generate_stopwatcher( stopwatcher_behavior=stopwatcher_info["behavior"], stopwatcher_route=stopwatcher_info["direction"], start_lane_id=0, end_lane_id=0, ) ) scenario += f"-stopwatcher-{stopwatcher_info['behavior']}" copy_map_files(scenario, map_dir, speed) vehicles_to_not_hijack = [] traffic = Traffic(flows=all_flows) try: gen_traffic(scenario, traffic, name=f"all", seed=sumo_seed) if stops: add_stops_to_traffic(scenario, stops, vehicles_to_not_hijack) except Exception as exception: print(exception) # Patch: Remove route files from traffic folder to make intersection empty. if traffic_density == "no-traffic": os.remove(f"{scenario}/traffic/all.rou.xml") if stopwatcher_behavior or "ego_hijacking_params" not in route_distributions: mission_objects = [Mission(ego_route) for ego_route in ego_routes] else: speed_m_per_s = float("".join(filter(str.isdigit, speed))) * 5.0 / 18.0 hijacking_params = route_distributions["ego_hijacking_params"] zone_range = hijacking_params["zone_range"] waiting_time = hijacking_params["wait_to_hijack_limit_s"] start_time = ( hijacking_params["start_time"] if hijacking_params["start_time"] != "default" else random.randint((LANE_LENGTH // speed_m_per_s), 60) ) mission_objects = [ Mission( ego_route, # Optional: control hijacking time, place, and emission. start_time=start_time, # When to start hijacking (might start later). entry_tactic=TrapEntryTactic( wait_to_hijack_limit_s=waiting_time, # When to give up hijacking. zone=MapZone( start=( ego_route.begin[0], 0, ego_route.begin[2] + zone_range[0], ), length=zone_range[1], n_lanes=(ego_route.begin[1] + 1), ), # Area to hijack. exclusion_prefixes=vehicles_to_not_hijack, # Don't hijack these. ), ) for ego_route in ego_routes ] # Shuffle the missions so agents don't do the same route all the time. if shuffle_missions: random.shuffle(mission_objects) gen_missions(scenario, mission_objects) if bubbles: bubble_objects = [ bubble_config_to_bubble_object( scenario, bubble_config, vehicles_to_not_hijack ) for bubble_config in bubbles ] gen_bubbles(scenario, bubble_objects) if stopwatcher_behavior: metadata["stopwatcher"] = { "direction": stopwatcher_info["direction"], "behavior": stopwatcher_info["behavior"], } metadata["intersection"] = { "type": intersection_name[-1], "name": intersection_name, } metadata["total_vehicles"] = len(all_flows) metadata["seed"] = seed metadata["flow_id"] = f"flow_{seed}" with open(f"{scenario}/metadata.json", "w") as log: json.dump(metadata, log)
Route(begin=("edge-south-SN", 0, 80), end=("edge-west-EW", (1, ), 40))), ] gen_missions(scenario, missions=agent_missions, overwrite=True) traffic = t.Traffic(flows=[ t.Flow( route=t.Route( begin=("edge-west-WE", 0, 10), end=("edge-east-WE", 0, -10), ), rate=400, actors={ t.TrafficActor("car"): 1, }, ), t.Flow( route=t.Route( begin=("edge-east-EW", 0, 10), end=("edge-west-EW", 0, -10), ), rate=400, actors={ t.TrafficActor("car"): 1, }, ), ]) gen_traffic(scenario, traffic, name="basic", overwrite=True)
Flow( route=Route(begin=(f"edge-{r[0]}", 0, "random"), end=(f"edge-{r[1]}", 0, "max")), rate=random.randint(50, 100), actors={ cooperative_car: 0.35, car: 0.20, aggressive_car: 0.45 }, ) for r in routes ]) for seed in [0, 5]: gen_traffic( scenario, traffic, name=f"{name}-{seed}", seed=seed, ) # Social Agents # # N.B. You need to have the agent_locator in a location where the left side can be resolved # as a module in form: # "this.resolved.module:attribute" # In your own project you would place the prefabs script where python can reach it social_agent1 = SocialAgentActor( name="zoo-car1", agent_locator="scenarios.zoo_intersection.agent_prefabs:zoo-agent2-v0", initial_speed=20, ) social_agent2 = SocialAgentActor(