def scenario_root(scenario_parent_path):
# TODO: We may want to consider referencing to concrete scenarios in our tests
# rather than generating them. The benefit of generting however is that
# we can change the test criteria and scenario code in unison.
scenario = Path(scenario_parent_path) / "cycles"
scenario.mkdir()
shutil.copyfile(
Path(__file__).parent / "maps/6lane.net.xml", scenario / "map.net.xml")
generate_glb_from_sumo_network(str(scenario / "map.net.xml"),
str(scenario / "map.glb"))
actors = [
SocialAgentActor(
name=f"non-interactive-agent-{speed}-v0",
agent_locator="zoo.policies:non-interactive-agent-v0",
policy_kwargs={"speed": speed},
) for speed in [10, 30, 80]
]
for name, (edge_start, edge_end) in [
("group-1", ("edge-north-NS", "edge-south-NS")),
("group-2", ("edge-west-WE", "edge-east-WE")),
("group-3", ("edge-east-EW", "edge-west-EW")),
("group-4", ("edge-south-SN", "edge-north-SN")),
]:
route = Route(begin=("edge-north-NS", 1, 0),
end=("edge-south-NS", 1, "max"))
missions = [Mission(route=route)] * 2 # double up
gen_social_agent_missions(
scenario,
social_agent_actor=actors,
name=name,
missions=missions,
)
gen_missions(
scenario,
missions=[
Mission(
Route(begin=("edge-west-WE", 0, 0),
end=("edge-east-WE", 0, "max")))
],
)
return scenario
def scenario_root():
# TODO: We may want to consider referencing to concrete scenarios in our tests
# rather than generating them. The benefit of generting however is that
# we can change the test criteria and scenario code in unison.
with temp_scenario(name="cycles",
map="maps/6lane.net.xml") as scenario_root:
actors = [
SocialAgentActor(
name=f"non-interactive-agent-{speed}-v0",
agent_locator="zoo.policies:non-interactive-agent-v0",
policy_kwargs={"speed": speed},
) for speed in [10, 30, 80]
]
for name, (edge_start, edge_end) in [
("group-1", ("edge-north-NS", "edge-south-NS")),
("group-2", ("edge-west-WE", "edge-east-WE")),
("group-3", ("edge-east-EW", "edge-west-EW")),
("group-4", ("edge-south-SN", "edge-north-SN")),
]:
route = Route(begin=("edge-north-NS", 1, 0),
end=("edge-south-NS", 1, "max"))
missions = [Mission(route=route)] * 2 # double up
gen_social_agent_missions(
scenario_root,
social_agent_actor=actors,
name=name,
missions=missions,
)
gen_missions(
scenario_root,
missions=[
Mission(
Route(begin=("edge-west-WE", 0, 0),
end=("edge-east-WE", 0, "max")))
],
)
yield scenario_root
JunctionModel,
)
scenario_path = str(Path(__file__).parent)
sv_num = 30
seed = 42
# generate agent missions
gen_missions(
scenario_path,
[
# start line and end line should be the same
t.LapMission(
t.Route(
begin=("edge1", 0, 10), via=("edge0",), end=("edge1", (0, 1, 2), 10)
),
num_laps=1,
),
],
overwrite=True,
)
print(f"generate lap mission finished")
# generate social agent routes
impatient_car = TrafficActor(
name="car",
speed=Distribution(sigma=0.2, mean=0.5),
lane_changing_model=LaneChangingModel(impatience=1, cooperative=0.25),
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"))),
],
)
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,
)
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)
JunctionModel,
)
scenario_path = str(Path(__file__).parent)
sv_num = 30
seed = 42
# generate agent missions
gen_missions(
scenario_path,
[
t.LapMission(
t.Route(
begin=("gneE14", 0, 10),
via=("edge-east-EN", "gneE48"),
end=("gneE14", (0, 1), 10),
),
num_laps=1,
),
],
overwrite=True,
)
print(f"generate lap mission finished")
# generate social agent routes
impatient_car = TrafficActor(
name="car",
speed=Distribution(sigma=0.2, mean=0.5),
lane_changing_model=LaneChangingModel(impatience=1, cooperative=0.25),
import os
import pickle
from smarts.sstudio import gen_missions, gen_social_agent_missions
from smarts.sstudio import types as t
scenario = os.path.dirname(os.path.realpath(__file__))
with open(os.environ["SOCIAL_AGENT_PATH"], "rb") as f:
social_agent = pickle.load(f)
gen_social_agent_missions(
scenario,
social_agent_actor=social_agent,
name=f"s-agent-{social_agent.name}",
missions=[t.Mission(t.Route(begin=("E35-3", 2, 90), end=("E3-3s", 0, 30))),],
)
gen_missions(
scenario, [t.Mission(t.Route(begin=("E3l-3", 1, 200), end=("E3-35", 1, 50))),],
)
gen_missions(
scenario,
[
Mission(
Route(begin=("edge-west-WE", 0, 10), end=("edge-south-NS", 0, 40)),
entry_tactic=TrapEntryTactic(
wait_to_hijack_limit_s=3,
zone=MapZone(
start=("edge-west-WE", 0, 5),
length=30,
n_lanes=1,
),
),
),
Mission(
Route(begin=("edge-west-WE", 0, 10), end=("edge-west-WE", 0, 25)),
entry_tactic=TrapEntryTactic(
wait_to_hijack_limit_s=3,
zone=MapZone(
start=("edge-west-WE", 0, 5),
length=30,
n_lanes=1,
),
),
),
Mission(
Route(begin=("edge-south-SN", 0, 30), end=("edge-west-EW", 0, 50)),
entry_tactic=TrapEntryTactic(
wait_to_hijack_limit_s=3,
zone=MapZone(
start=("edge-south-SN", 0, 5),
length=30,
n_lanes=1,
),
),
),
],
)
gen_social_agent_missions(
scenario,
social_agent_actor=social_agent2,
name=f"s-agent-{social_agent2.name}",
missions=[Mission(RandomRoute())],
)
gen_social_agent_missions(
scenario,
social_agent_actor=social_agent1,
name=f"s-agent-{social_agent1.name}",
missions=[
EndlessMission(begin=("edge-south-SN", 0, 30)),
Mission(
Route(begin=("edge-west-WE", 0, 10), end=("edge-east-WE", 0, 10))),
],
)
# Agent Missions
gen_missions(
scenario=scenario,
missions=[
Mission(
Route(begin=("edge-east-EW", 0, 10),
end=("edge-south-NS", 0, 10))),
Mission(
Route(begin=("edge-south-SN", 0, 10),
end=("edge-east-WE", 0, 10))),
],
)
JunctionModel,
)
scenario_path = str(Path(__file__).parent)
sv_num = 13
seed = 345
# generate agent missions
gen_missions(
scenario_path,
[
t.LapMission(
t.Route(
begin=("gneE9", 0, 10),
via=("gneE5", "gneE7.141"),
end=("gneE9", (0, 1), 10),
),
num_laps=1,
),
],
overwrite=True,
)
print(f"generate lap mission finished")
# generate social agent routes
impatient_car = TrafficActor(
name="patient_car",
speed=Distribution(sigma=0.2, mean=0.5),
lane_changing_model=LaneChangingModel(impatience=1, cooperative=0.25),
JunctionModel,
)
scenario_path = str(Path(__file__).parent)
sv_num = 30
seed = 42
# generate agent missions
gen_missions(
scenario_path,
[
t.LapMission(
t.Route(
begin=("edge1", 0, 50),
via=("edge0", ),
end=("edge1", (0, 1, 2), 50),
),
num_laps=1,
),
],
overwrite=True,
)
print(f"generate lap mission finished")
# generate social agent routes
impatient_car = TrafficActor(
name="car",
speed=Distribution(sigma=0.2, mean=0.5),
lane_changing_model=LaneChangingModel(impatience=1, cooperative=0.25),
JunctionModel,
)
scenario_path = str(Path(__file__).parent)
sv_num = 30
seed = 42
# generate agent missions
gen_missions(
scenario_path,
[
t.LapMission(
t.Route(
begin=("gneE92", 0, 10),
via=("edge-south-SE", "gneE82", "gneE93"),
end=("gneE92", (0,), 10),
),
num_laps=1,
),
],
overwrite=True,
)
print(f"generate lap mission finished")
# generate social agent routes
impatient_car = TrafficActor(
name="car",
speed=Distribution(sigma=0.2, mean=0.5),
print("generate social agent missions finished")
#########################################
# generate agent missions
#########################################
# generate agent Missions so agents will born in the same position after env reset()
# Otherwise, no defined agent mission will lead to agent born in different place after env reset()
for scenario, starting_edge in zip(scenario_paths, starting_edges):
gen_missions(
scenario=scenario,
missions=[
# edge_id, lane_index, offset
EndlessMission(begin=(starting_edge, 0, 0),),
# Mission(Route(begin=("edge-east", 0, 0), end=("edge-east", 0, -5))),
],
overwrite=True,
)
print("generate ego agent missions finished")
#########################################
# generate social vehicles
#########################################
sv_nums = [60, 60, 60, 60]
seed = 45
JunctionModel,
)
scenario_path = str(Path(__file__).parent)
sv_num = 18
seed = 675
# generate agent missions
gen_missions(
scenario_path,
[
t.LapMission(
t.Route(
begin=("gneE78", 0, 10),
via=("edge-west-WS", "gneE61"),
end=("gneE78", (0, 1), 10),
),
num_laps=1,
),
],
overwrite=True,
)
print(f"generate lap mission finished")
# generate social agent routes
impatient_car = TrafficActor(
name="patient_car",
speed=Distribution(sigma=0.2, mean=0.5),
lane_changing_model=LaneChangingModel(impatience=1, cooperative=0.25),
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)
Traffic,
Flow,
Route,
RandomRoute,
TrafficActor,
Mission,
)
scenario = os.path.dirname(os.path.realpath(__file__))
gen_missions(
scenario,
[
Mission(
Route(begin=("edge-west-WE", 0, 10),
end=("edge-south-NS", 0, 40))),
Mission(
Route(begin=("edge-west-WE", 1, 10),
end=("edge-south-NS", 0, 40))),
],
)
gen_traffic(
scenario,
Traffic(flows=[
Flow(
route=RandomRoute(),
rate=3600,
actors={TrafficActor(name="car"): 1.0},
)
]),
