def missions() -> Sequence[Mission]: return [ Mission( Route(begin=("edge-west-WE", 0, 0), end=("edge-south-NS", 0, 0))), Mission( Route(begin=("edge-south-SN", 0, 30), end=("edge-west-EW", 0, 0))), ]
def traffic() -> Traffic: car1 = TrafficActor( name="car", speed=Distribution(sigma=0.2, mean=1.0), ) car2 = TrafficActor( name="car", speed=Distribution(sigma=0.2, mean=0.8), lane_changing_model=LaneChangingModel(impatience=1, cooperative=0.25), junction_model=JunctionModel(drive_after_yellow_time=1.0, impatience=0.5), ) return Traffic( flows=[ Flow( route=Route( begin=(f"edge-{r[0]}", 0, 30), end=(f"edge-{r[1]}", 0, -30) ), rate=1.0, actors={ car1: 0.5, car2: 0.5, }, ) for r in [("west-WE", "east-WE"), ("east-EW", "west-EW")] ] )
def create_scenario(): 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] ] 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 gen_social_agent_missions( scenario_root, social_agent_actor=actors, name=name, missions=missions, ) yield scenario_root
def generate_stopwatcher(stopwatcher_behavior, stopwatcher_route, start_lane_id, end_lane_id, begin_time=None): # this is a vehicle with aggressive behavior that records the number of steps to finishe a left-turn behavior = replace( get_social_vehicle_behavior(stopwatcher_behavior), name=f"stopwatcher_{stopwatcher_behavior}", ) begin_time = ( begin_time if begin_time is not None else random.randint(10, 15) ) # slight delay to wait for trafficne_id return Flow( begin=begin_time, end=begin_time + 3600, # 1 hour route=Route( begin=( f"edge-{stopwatcher_route[0]}", start_lane_id, "base", ), end=( f"edge-{stopwatcher_route[1]}", end_lane_id, "max", ), ), rate=1, actors={behavior: 1.0}, )
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 ego_mission_config_to_route( ego_mission_config: Dict[str, Any], route_lanes: Dict[str, int], stopwatcher_behavior: bool, ) -> Route: """Creates a Route from an ego mission config dictionary. Args: ego_mission_config: A dictionary describing the ego mission. route_lanes: A dictionary of routes (edges) as keys and the number of lanes in each route as values. stopwatcher_behavior: A boolean value describing the presence of stopwatchers. Returns: Route: The route object created from the ego mission config. """ if stopwatcher_behavior: # Put the ego vehicle(s) on the side road. mission_start = "edge-south-side" mission_end = "edge-dead-end" mission_start_lane_index = 0 mission_end_lane_index = 0 mission_start_offset = 100 mission_end_offset = 5 else: mission_start = "edge-{}".format(ego_mission_config["start"]) mission_end = "edge-{}".format(ego_mission_config["end"]) mission_start_lane_index = route_lanes[ego_mission_config["start"]] - 1 mission_end_lane_index = route_lanes[ego_mission_config["end"]] - 1 mission_start_offset = ( random.randint( ego_mission_config["start_offset"][0], ego_mission_config["start_offset"][1], ) if "start_offset" in ego_mission_config else random.randint(50, 120) # The default range of the offset. ) mission_end_offset = ( random.randint( ego_mission_config["end_offset"][0], ego_mission_config["end_offset"][1] ) if "end_offset" in ego_mission_config else random.randint(50, 120) # The default range of the offset. ) route = Route( begin=( mission_start, mission_start_lane_index, mission_start_offset, ), end=( mission_end, mission_end_lane_index, mission_end_offset, ), ) return route
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
def ego_mission_to_route(ego_mission, route_lanes, stopwatcher_behavior=False): if stopwatcher_behavior: # Put the ego vehicle(s) on the side road. mission_start = "edge-south-side" mission_end = "edge-dead-end" mission_start_lane_index = 0 mission_end_lane_index = 0 mission_start_offset = 100 mission_end_offset = 5 else: mission_start = "edge-{}".format(ego_mission["start"]) mission_end = "edge-{}".format(ego_mission["end"]) mission_start_lane_index = route_lanes[ego_mission["start"]] - 1 mission_end_lane_index = route_lanes[ego_mission["end"]] - 1 mission_start_offset = ( random.randint(ego_mission["start_offset"][0], ego_mission["start_offset"][1]) if "start_offset" in ego_mission else random.randint( 50, 120) # The default range of the offset. ) mission_end_offset = ( random.randint(ego_mission["end_offset"][0], ego_mission["end_offset"][1]) if "end_offset" in ego_mission else random.randint( 50, 120) # The default range of the offset. ) route = Route( begin=( mission_start, mission_start_lane_index, mission_start_offset, ), end=( mission_end, mission_end_lane_index, mission_end_offset, ), ) return route
# # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. from pathlib import Path from smarts.sstudio import gen_scenario from smarts.sstudio.types import ( Route, Mission, Scenario, ) missions = [ Mission(Route(begin=("gneE17", 0, 10), end=("gneE5", 1, 100))), Mission(Route(begin=("gneE22", 0, 10), end=("gneE5", 0, 100))), Mission(Route(begin=("gneE17", 0, 25), end=("gneE5", 0, 100))), Mission(Route(begin=("gneE22", 0, 25), end=("gneE5", 1, 100))), ] gen_scenario( Scenario(ego_missions=missions), output_dir=Path(__file__).parent, )
CutIn, EndlessMission, Flow, JunctionEdgeIDResolver, Mission, RandomRoute, Route, Scenario, Traffic, TrafficActor, Via, ) ego_missions = [ Mission( route=Route(begin=("edge-south-SN", 1, 10), end=("edge-west-EW", 1, "max")), task=CutIn(complete_on_edge_id=JunctionEdgeIDResolver( "edge-south-SN", 1, "edge-west-EW", 0)), ), EndlessMission( begin=("edge-south-SN", 1, 10), via=( Via( "edge-south-SN", lane_offset=30, lane_index=1, required_speed=4, ), Via( JunctionEdgeIDResolver("edge-south-SN", 1, "edge-west-EW", 0), lane_offset=10,
from smarts.sstudio.types import ( Distribution, Flow, LaneChangingModel, Mission, RandomRoute, Route, Scenario, Traffic, TrafficActor, ) social_vehicle_num = 100 ego_missions = [ Mission(route=Route(begin=("edge-south-SN", 0, 10), end=("edge-east-WE", 0, 8)), ), ] right_traffic_actor = TrafficActor( name="car", speed=Distribution(sigma=0.2, mean=1), lane_changing_model=LaneChangingModel(impatience=0), ) scenario = Scenario( traffic={ "basic": Traffic(flows=[ Flow( route=RandomRoute(), rate=1, actors={right_traffic_actor: 1.0},
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)
import os from smarts.sstudio import gen_traffic, gen_missions from smarts.sstudio.types import ( Traffic, Flow, Route, RandomRoute, TrafficActor, Mission, ) scenario = os.path.dirname(os.path.realpath(__file__)) agent_missions = [ Mission(Route(begin=("left_top", 0, 30), end=("right_bottom", (0, ), 40))), Mission(Route(begin=("left_bottom", 0, 30), end=("right_top", (0, ), 40))), Mission(Route(begin=("left_top", 0, 10), end=("right_top", (0, ), 30))), Mission(Route(begin=("left_bottom", 0, 10), end=("right_top", (0, ), 40))), ] gen_missions(scenario, agent_missions, overwrite=True) gen_traffic( scenario, Traffic(flows=[ Flow( route=RandomRoute(), rate=3600, actors={TrafficActor(name="car"): 1.0}, )
name="aggressive_car", speed=Distribution(sigma=0.2, mean=1.0), lane_changing_model=LaneChangingModel(impatience=1, cooperative=0.1), ) horizontal_routes = [("west-WE", "east-WE"), ("east-EW", "west-EW")] turn_left_routes = [("east-EW", "south-NS")] turn_right_routes = [("west-WE", "south-NS")] for name, routes in { "horizontal": horizontal_routes, "turns": 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, "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,
laner_agent = SocialAgentActor( name="laner-agent", agent_locator= "scenarios.intersections.2lane_circle.agent_prefabs:laner-agent-v0", ) buddha_agent = SocialAgentActor( name="buddha-agent", agent_locator= "scenarios.intersections.2lane_circle.agent_prefabs:buddha-agent-v0", ) gen_social_agent_missions( scenario, social_agent_actor=laner_agent, name=f"s-agent-{laner_agent.name}", missions=[ Mission(Route(begin=("edge-east-EW", 0, 5), end=("edge-west-EW", 0, 5))) ], ) gen_social_agent_missions( scenario, social_agent_actor=buddha_agent, name=f"s-agent-{buddha_agent.name}", missions=[ Mission(Route(begin=("edge-west-WE", 0, 5), end=("edge-east-WE", 0, 5))) ], )
def to_mission(start_edge, end_edge): route = Route(begin=(start_edge, 1, 0), end=(end_edge, 1, "max")) return Mission(route=route)
from smarts.sstudio.types import ( 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}, ) ]),
Distribution, Flow, LaneChangingModel, Mission, RandomRoute, Route, Scenario, Traffic, TrafficActor, ) social_vehicle_num = 100 ego_missions = [ Mission( route=Route(begin=("edge-south-SN", 1, 10), end=("edge-west-EW", 1, 8)), # begin 45.6 ), ] left_traffic_actor = TrafficActor( name="car", speed=Distribution(sigma=0.2, mean=1), lane_changing_model=LaneChangingModel(impatience=0), # junction_model=JunctionModel( # drive_after_yellow_time=1.0, impatience=0) ) scenario = Scenario( traffic={ "basic": Traffic(flows=[ Flow(
from pathlib import Path from smarts.sstudio import gen_scenario from smarts.sstudio.types import ( Route, Mission, Scenario, ) missions = [ Mission(Route(begin=("edge-south-SN", 1, 40), end=("edge-west-EW", 0, 60))), Mission(Route(begin=("edge-west-WE", 1, 50), end=("edge-east-WE", 0, 60))), Mission(Route(begin=("edge-north-NS", 0, 40), end=("edge-south-NS", 1, 40))), Mission(Route(begin=("edge-east-EW", 0, 50), end=("edge-west-EW", 1, 40))), ] gen_scenario( Scenario(ego_missions=missions), output_dir=Path(__file__).parent, )
Flow, JunctionModel, LaneChangingModel, Mission, RandomRoute, Route, Scenario, Traffic, TrafficActor, ) social_vehicle_num = 100 ego_missions = [ Mission( route=Route(begin=("edge-south-SN", 1, 10), end=("edge-north-SN", 1, 8)), ), ] stright_traffic_actor = TrafficActor( name="car", speed=Distribution(sigma=0.2, mean=1), lane_changing_model=LaneChangingModel(impatience=0), junction_model=JunctionModel( drive_after_red_time=1.5, drive_after_yellow_time=1.0, impatience=0.5 ), ) scenario = Scenario( traffic={ "basic": Traffic( flows=[
TrafficActor, Distribution, LaneChangingModel, JunctionModel, Mission, TrapEntryTactic, MapZone, ) 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)), 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),
] 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)
def generate_social_vehicles( ego_start_lane, route_distribution, start_end_on_different_lanes_probability, num_vehicles, route_direction, route_lanes, route_has_turn, stopwatcher_info, begin_time_init=None, deadlock_optimization=True, ): flows = [] behaviors = [] log_info = { "num_vehicles": 0, "route_distribution": None, "start_end_on_different_lanes_probability": 0.0, } stopwatcher_added = False # populate random routes based on their probability start_lane, end_lane = route_direction if stopwatcher_info and route_direction == stopwatcher_info["direction"]: if stopwatcher_info["behavior"] not in behaviors: behaviors.append(f'stopwatcher_{stopwatcher_info["behavior"]}') num_vehicles = max(0, num_vehicles - 1) # used 1 for stopwatcher stopwatcher_added = True behaviors.extend( random.choices( list(route_distribution.keys()), weights=list(route_distribution.values()), k=num_vehicles, )) random.shuffle(behaviors) # because stopwatcher is always at the beginning if begin_time_init is None: begin_time_init_func = basic_begin_time_init_func begin_time_init_params = {"probability": 0.0} else: begin_time_init_func = begin_time_init["func"] begin_time_init_params = begin_time_init["params"] begin_time_init_params = ({} if begin_time_init_params is None else begin_time_init_params) begin_times = begin_time_init_func(route_lanes[start_lane], len(behaviors), **begin_time_init_params) begin_time_idx = [0 for _ in range(route_lanes[start_lane])] for behavior_idx in behaviors: if behavior_idx not in log_info: log_info[behavior_idx] = { "count": 0, "start_end_different_lanes": 0 } if deadlock_optimization and route_has_turn: # if route has a turn, start on the left-most lane start_lane_id = route_lanes[start_lane] - 1 lane_changing_options = [ lane_id for lane_id in range(route_lanes[end_lane]) ] if (len(lane_changing_options) > 0 or random.uniform(0, 1) < start_end_on_different_lanes_probability): end_lane_id = random.choice(lane_changing_options) else: end_lane_id = start_lane_id else: start_lane_id = random.randint(0, route_lanes[start_lane] - 1) end_lane_id = random.randint(0, route_lanes[end_lane] - 1) # set begin/end time begin_time = begin_times[start_lane_id][begin_time_idx[start_lane_id]] begin_time_idx[start_lane_id] += 1 end_time = begin_time + 3600 # 1 hour if "stopwatcher" in behavior_idx: start_lane_id = route_lanes[stopwatcher_info["direction"][0]] - 1 end_lane_id = route_lanes[stopwatcher_info["direction"][1]] - 1 flows.append( generate_stopwatcher( stopwatcher_behavior=stopwatcher_info["behavior"], stopwatcher_route=stopwatcher_info["direction"], begin_time=begin_time, start_lane_id=start_lane_id, end_lane_id=end_lane_id, )) else: behavior = get_social_vehicle_behavior(behavior_idx) flows.append( Flow( begin=begin_time, end=end_time, route=Route( begin=(f"edge-{start_lane}", start_lane_id, "base"), end=(f"edge-{end_lane}", end_lane_id, "max"), ), rate=1, actors={behavior: 1.0}, )) log_info[behavior_idx]["count"] += 1 log_info["route_distribution"] = route_distribution log_info["num_vehicles"] = (num_vehicles + 1 if stopwatcher_added else num_vehicles) log_info[ "start_end_on_different_lanes_probability"] = start_end_on_different_lanes_probability log_info[behavior_idx]["start_end_different_lanes"] += ( 1 if start_lane_id != end_lane_id else 0) return flows, log_info
from pathlib import Path from smarts.sstudio import types as t from smarts.sstudio.types import Mission, Route from smarts.sstudio import gen_traffic, gen_missions scenario = str(Path(__file__).parent) agent_missions = [ Mission( Route(begin=("edge-west-WE", 0, 80), end=("edge-east-WE", (1, ), 40))), Mission( Route(begin=("edge-east-EW", 0, 80), end=("edge-south-NS", (1, ), 40))), Mission( 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, },
from pathlib import Path from smarts.sstudio.genscenario import gen_scenario from smarts.sstudio.types import ( CutIn, Flow, Mission, Route, Scenario, Traffic, TrafficActor, ) ego_missions = [ Mission( route=Route(begin=("edge-west-WE", 0, 10), end=("edge-west-WE", 0, "max")), task=CutIn(), ), ] scenario = Scenario( traffic={ "basic": Traffic(flows=[ Flow( route=Route(begin=("edge-west-WE", 1, 10), end=("edge-west-WE", 1, "max")), rate=400, actors={TrafficActor(name="car"): 1.0}, ) ])
from pathlib import Path from smarts.sstudio import gen_scenario from smarts.sstudio.types import ( Route, Mission, Scenario, ) missions = [ Mission(Route(begin=("edge-south-SN", 1, 40), end=("edge-west-EW", 0, 60))) ] gen_scenario( Scenario(ego_missions=missions), output_dir=Path(__file__).parent, )
import os from smarts.sstudio import gen_traffic, gen_missions from smarts.sstudio.types import (Traffic, Flow, Route, RandomRoute, TrafficActor, Mission, Distribution, LaneChangingModel, JunctionModel) scenario = os.path.dirname(os.path.realpath(__file__)) agent_missions = [ Mission( Route(begin=("edge-west-WE", 0, 100), end=("edge-east-WE", (1, ), 40))), Mission( Route(begin=("edge-south-SN", 0, 50), end=("edge-west-EW", (0, ), 40))), Mission( Route(begin=("edge-east-EW", 0, 50), end=("edge-west-EW", (1, ), 40))), Mission( Route(begin=("edge-north-NS", 0, 50), end=("edge-south-NS", (1, ), 30))) ] gen_missions(scenario, agent_missions, overwrite=True) impatient_car = TrafficActor( name="car", speed=Distribution(sigma=0.2, mean=0.5), lane_changing_model=LaneChangingModel(impatience=1, cooperative=0.25), junction_model=JunctionModel(drive_after_red_time=1.5, drive_after_yellow_time=1.0,
from smarts.sstudio import gen_traffic, gen_missions from smarts.sstudio.types import ( Traffic, Flow, Route, RandomRoute, TrafficActor, Mission, ) scenario = os.path.dirname(os.path.realpath(__file__)) agent_missions = [ Mission( Route(begin=("edge-north-NS", 0, 10), end=("edge-south-NS", (0, ), 10))), Mission( Route(begin=("edge-north-WN", 0, 40), end=("edge-north-SN", (0, ), 10))), Mission( Route(begin=("edge-east-EN", 0, 20), end=("edge-north-SN", (0, ), 10))), ] gen_missions(scenario, agent_missions, overwrite=True) gen_traffic( scenario, Traffic(flows=[ Flow( route=RandomRoute(),
import os from smarts.sstudio import gen_traffic, gen_missions from smarts.sstudio.types import ( Traffic, 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}, )
from pathlib import Path from smarts.sstudio.genscenario import gen_scenario from smarts.sstudio.types import ( Flow, Mission, Route, Scenario, Traffic, TrafficActor, UTurn, ) ego_missions = [ Mission( route=Route(begin=("edge-west-WE", 1, 30), end=("edge-west-EW", 0, 100)), task=UTurn(initial_speed=20), ), ] scenario = Scenario( traffic={ "basic": Traffic(flows=[ Flow( route=Route(begin=("edge-west-EW", 0, 20), end=("edge-west-EW", 1, "max")), rate=400, actors={TrafficActor(name="car"): 1.0}, ) ])