min_vel=5., max_vel=5., ds_min=5., ds_max=10., s_min=15., s_max=30.)) scenarios = \ ConfigWithEase(num_scenarios=3, map_file_name="modules/runtime/tests/data/threeway_intersection.xodr", random_seed=0, params=param_server, lane_corridor_configs=lane_corridors) # viewer viewer = MPViewer(params=param_server, use_world_bounds=True) # viewer = Panda3dViewer(params=param_server, # x_range=[-40, 40], # y_range=[-40, 40], # follow_agent_id=agent3.id) # World Simulation sim_step_time = param_server["simulation"]["step_time", "Step-time used in simulation", 0.2] sim_real_time_factor = param_server["simulation"]["real_time_factor", "execution in real-time or faster", 1.] # viewer = VideoRenderer(renderer=viewer, # world_step_time=sim_step_time,
xodr_parser = XodrParser("modules/runtime/tests/data/" + map_name + ".xodr") if not os.path.exists(output_dir): os.makedirs(output_dir) # World Definition params = ParameterServer() world = World(params) map_interface = MapInterface() map_interface.set_open_drive_map(xodr_parser.map) world.set_map(map_interface) open_drive_map = world.map.get_open_drive_map() viewer = MPViewer(params=params, use_world_bounds=True) viewer.drawWorld(world) viewer.saveFig(output_dir + "/" + "world_plain.png") color_triplet_gray = (0.7, 0.7, 0.7) # Open Drive Elements (Roads, Lane Sections, Lanes) for idx_r, road in open_drive_map.get_roads().items(): viewer.drawWorld(world) viewer.drawRoad(road) viewer.saveFig(output_dir + "/" + "open_drive_map_road_" + str(idx_r) + ".png") viewer.clear() for idx_r, road in open_drive_map.get_roads().items(): for idx_ls, lane_section in enumerate(road.lane_sections):
def test_road_corridor_forward(self): xodr_parser = XodrParser( "modules/runtime/tests/data/road_corridor_test.xodr") # World Definition params = ParameterServer() world = World(params) map_interface = MapInterface() map_interface.SetOpenDriveMap(xodr_parser.map) world.SetMap(map_interface) open_drive_map = world.map.GetOpenDriveMap() viewer = MPViewer(params=params, use_world_bounds=True) # Draw map viewer.drawWorld(world) viewer.show(block=False) # Generate RoadCorridor roads = [0, 1, 2] driving_direction = XodrDrivingDirection.forward map_interface.GenerateRoadCorridor(roads, driving_direction) road_corridor = map_interface.GetRoadCorridor(roads, driving_direction) # Assert road corridor # Assert: 3 roads self.assertEqual(len(road_corridor.roads), 3) # Assert: road1: 2 lanes, road2: 1 lane, road3: 1 lane self.assertEqual(len(road_corridor.GetRoad(0).lanes), 3) self.assertEqual(len(road_corridor.GetRoad(1).lanes), 2) self.assertEqual(len(road_corridor.GetRoad(2).lanes), 3) # Assert: next road self.assertEqual(road_corridor.GetRoad(0).next_road.road_id, 1) self.assertEqual(road_corridor.GetRoad(1).next_road.road_id, 2) # Assert: lane links self.assertEqual( road_corridor.GetRoad(0).GetLane(3).next_lane.lane_id, 5) self.assertEqual( road_corridor.GetRoad(1).GetLane(5).next_lane.lane_id, 8) # Assert: LaneCorridor self.assertEqual(len(road_corridor.lane_corridors), 3) colors = ["blue", "red", "green"] count = 0 for lane_corridor in road_corridor.lane_corridors: viewer.drawPolygon2d(lane_corridor.polygon, color=colors[count], alpha=0.5) viewer.drawLine2d(lane_corridor.left_boundary, color="red") viewer.drawLine2d(lane_corridor.right_boundary, color="blue") viewer.drawLine2d(lane_corridor.center_line, color="black") viewer.show(block=False) plt.pause(2.) count += 1
from modules.runtime.scenario.scenario_generation.uniform_vehicle_distribution import UniformVehicleDistribution from modules.runtime.commons.parameters import ParameterServer from modules.runtime.runtime import Runtime from modules.runtime.viewer.matplotlib_viewer import MPViewer from modules.runtime.viewer.video_renderer import VideoRenderer import os scenario_param_file = "highway_merging.json" # must be within examples params folder param_server = ParameterServer( filename=os.path.join("examples/params/", scenario_param_file)) scenario_generation = UniformVehicleDistribution(num_scenarios=10, random_seed=0, params=param_server) viewer = MPViewer(params=param_server, x_range=[5060, 5160], y_range=[5070, 5150]) sim_step_time = param_server["simulation"]["step_time", "Step-time used in simulation", 0.2] sim_real_time_factor = param_server["simulation"][ "real_time_factor", "execution in real-time or faster", 1] scenario, idx = scenario_generation.get_next_scenario() # Rendering WITHOUT intermediate steps video_renderer = VideoRenderer(renderer=viewer, world_step_time=sim_step_time) env = Runtime(0.2, video_renderer, scenario_generation, render=True) env.reset() for _ in range(0, 5): env.step() video_renderer.export_video(filename="examples/scenarios/test_video_step")
def test_uct_single_agent(self): try: from bark.models.behavior import BehaviorUCTSingleAgentMacroActions except: print("Rerun with --define planner_uct=true") return # World Definition scenario_param_file = "macro_actions_test.json" # must be within examples params folder params = ParameterServer(filename=os.path.join( "modules/world/tests/params/", scenario_param_file)) world = World(params) # Model Definitions behavior_model = BehaviorUCTSingleAgentMacroActions(params) execution_model = ExecutionModelInterpolate(params) dynamic_model = SingleTrackModel(params) behavior_model2 = BehaviorConstantVelocity(params) execution_model2 = ExecutionModelInterpolate(params) dynamic_model2 = SingleTrackModel(params) # Map Definition map_interface = MapInterface() xodr_map = MakeXodrMapOneRoadTwoLanes() map_interface.SetOpenDriveMap(xodr_map) world.SetMap(map_interface) # agent_2d_shape = CarLimousine() agent_2d_shape = CarRectangle() init_state = np.array([0, 3, -5.25, 0, 20]) agent_params = params.AddChild("agent1") # goal_polygon = Polygon2d( # [1, 1, 0], [Point2d(0, 0), Point2d(0, 2), Point2d(2, 2), Point2d(2, 0)]) # goal_definition = GoalDefinitionPolygon(goal_polygon) # goal_polygon = goal_polygon.Translate(Point2d(90, -2)) center_line = Line2d() center_line.AddPoint(Point2d(0.0, -1.75)) center_line.AddPoint(Point2d(100.0, -1.75)) max_lateral_dist = (0.4, 0.5) max_orientation_diff = (0.08, 0.1) velocity_range = (5.0, 20.0) goal_definition = GoalDefinitionStateLimitsFrenet( center_line, max_lateral_dist, max_orientation_diff, velocity_range) agent = Agent(init_state, behavior_model, dynamic_model, execution_model, agent_2d_shape, agent_params, goal_definition, map_interface) world.AddAgent(agent) init_state2 = np.array([0, 25, -5.25, 0, 0]) agent2 = Agent(init_state2, behavior_model2, dynamic_model2, execution_model2, agent_2d_shape, agent_params, goal_definition, map_interface) world.AddAgent(agent2) # viewer viewer = MPViewer(params=params, use_world_bounds=True) # World Simulation sim_step_time = params["simulation"]["step_time", "Step-time in simulation", 0.2] sim_real_time_factor = params["simulation"][ "real_time_factor", "execution in real-time or faster", 1] # Draw map video_renderer = VideoRenderer(renderer=viewer, world_step_time=sim_step_time) for _ in range(0, 5): world.Step(sim_step_time) viewer.clear() video_renderer.drawWorld(world) video_renderer.drawGoalDefinition(goal_definition) time.sleep(sim_step_time / sim_real_time_factor) video_renderer.export_video(filename="./test_video_intermediate", remove_image_dir=True)
Point2d(1, -1)]) goal_polygon = goal_polygon.Translate(Point2d(-191.789, -50.1725)) agent = Agent( init_state, behavior_model, dynamic_model, execution_model, agent_2d_shape, agent_params, GoalDefinitionPolygon(goal_polygon), # goal_lane_id map_interface) world.AddAgent(agent) # viewer viewer = MPViewer(params=param_server, use_world_bounds=True) # World Simulation sim_step_time = param_server["simulation"]["step_time", "Step-time in simulation", 0.05] sim_real_time_factor = param_server["simulation"][ "real_time_factor", "execution in real-time or faster", 100] for _ in range(0, 10): viewer.clear() world.Step(sim_step_time) viewer.drawWorld(world) viewer.drawRoadCorridor(agent.road_corridor) viewer.show(block=False) time.sleep(sim_step_time / sim_real_time_factor)
execution_model, agent_2d_shape, agent_params, 2, # goal_lane_id map_interface) world.add_agent(agent) # viewer """ viewer = PygameViewer(params=param_server, x_range=[-50, 50], y_range=[-50, 50], follow_agent_id=agent.id, screen_dims=[500, 500]) """ viewer = MPViewer(params=param_server) # World Simulation sim_step_time = param_server["simulation"]["step_time", "Step-time in simulation", 0.05] sim_real_time_factor = param_server["simulation"][ "real_time_factor", "execution in real-time or faster", 100] for _ in range(0, 100): viewer.clear() world.step(sim_step_time) viewer.drawWorld(world) viewer.show(block=False) time.sleep(sim_step_time / sim_real_time_factor) param_server.save(
agent_params = param_server.addChild("agent1") agent1 = Agent(init_state, behavior_model, dynamic_model, execution_model, agent_2d_shape, agent_params, GoalDefinitionPolygon(goal_polygon), map_interface) world.AddAgent(agent1) agent_2d_shape2 = CarLimousine() init_state2 = np.array([0, -15, -13, 3.14 * 3.0 / 4.0, 5.2]) agent_params2 = param_server.addChild("agent2") agent2 = Agent(init_state2, behavior_model2, dynamic_model2, execution_model2, agent_2d_shape2, agent_params2, GoalDefinitionPolygon(goal_polygon), map_interface) world.AddAgent(agent2) # viewer viewer = MPViewer(params=param_server, use_world_bounds=True) # World Simulation sim_step_time = param_server["simulation"]["step_time", "Step-time used in simulation", 1] sim_real_time_factor = param_server["simulation"][ "real_time_factor", "execution in real-time or faster", 1] for _ in range(0, 10): world.Step(sim_step_time) viewer.drawWorld(world) viewer.show(block=False) time.sleep(sim_step_time / sim_real_time_factor) param_server.save( os.path.join(os.path.dirname(os.path.abspath(__file__)), "params",
def test_two_roads_one_lane(self): xodr_map = MakeXodrMapOneRoadTwoLanes() # World Definition params = ParameterServer() world = World(params) map_interface = MapInterface() map_interface.SetOpenDriveMap(xodr_map) world.SetMap(map_interface) open_drive_map = world.map.GetOpenDriveMap() viewer = MPViewer(params=params, use_world_bounds=True) # Draw map viewer.drawWorld(world) viewer.show(block=False) # Generate RoadCorridor roads = [100] driving_direction = XodrDrivingDirection.forward map_interface.GenerateRoadCorridor(roads, driving_direction) road_corridor = map_interface.GetRoadCorridor(roads, driving_direction) # Assert road corridor # Assert: 1 road self.assertEqual(len(road_corridor.roads), 1) # Assert: road1: 2 lanes self.assertEqual(len(road_corridor.GetRoad(roads[0]).lanes), 3) colors = ["blue", "red", "green"] count = 0 for lane_corridor in road_corridor.lane_corridors: viewer.drawPolygon2d(lane_corridor.polygon, color=colors[count], alpha=0.5) viewer.drawLine2d(lane_corridor.left_boundary, color="red") viewer.drawLine2d(lane_corridor.right_boundary, color="blue") viewer.drawLine2d(lane_corridor.center_line, color="black") viewer.show(block=False) plt.pause(2.) count += 1 viewer.show(block=True)
def test_road_corridor_intersection(self): xodr_parser = XodrParser( "modules/runtime/tests/data/road_corridor_test.xodr") # World Definition params = ParameterServer() world = World(params) map_interface = MapInterface() map_interface.SetOpenDriveMap(xodr_parser.map) world.SetMap(map_interface) open_drive_map = world.map.GetOpenDriveMap() viewer = MPViewer(params=params, use_world_bounds=True) # Draw map viewer.drawWorld(world) viewer.show(block=False) # Generate RoadCorridor roads = [0, 1, 2] driving_direction = XodrDrivingDirection.forward map_interface.GenerateRoadCorridor(roads, driving_direction) road_corridor = map_interface.GetRoadCorridor(roads, driving_direction) colors = ["blue", "red", "green", "yellow"] count = 0 for road_id, road in road_corridor.roads.items(): for lane_id, lane in road.lanes.items(): print(road_id, lane_id, lane.driving_direction) for lane_corridor in road_corridor.lane_corridors: viewer.drawPolygon2d(lane_corridor.polygon, color=colors[count], alpha=0.5) viewer.drawLine2d(lane_corridor.left_boundary, color="red") viewer.drawLine2d(lane_corridor.right_boundary, color="blue") viewer.drawLine2d(lane_corridor.center_line, color="black") viewer.show(block=False) plt.pause(0.5) count += 1 viewer.show(block=True)
xodr_parser = XodrParser("modules/runtime/tests/data/" + map_name + ".xodr") if not os.path.exists(output_dir): os.makedirs(output_dir) # World Definition params = ParameterServer() world = World(params) map_interface = MapInterface() map_interface.SetOpenDriveMap(xodr_parser.map) world.SetMap(map_interface) open_drive_map = world.map.GetOpenDriveMap() viewer = MPViewer(params=params, use_world_bounds=True) viewer.drawWorld(world) viewer.saveFig(output_dir + "/" + "world_plain.png") color_triplet_gray = (0.7,0.7,0.7) # Open Drive Elements (XodrRoads, XodrLane Sections, XodrLanes) # for idx_r, road in open_drive_map.GetRoads().items(): # viewer.drawWorld(world) # viewer.drawXodrRoad(road) # viewer.saveFig(output_dir + "/" + "open_drive_map_road_" + str(idx_r) + ".png") # viewer.show(block=True) # viewer.clear() # for idx_r, road in open_drive_map.GetRoads().items(): # for idx_ls, lane_section in enumerate(road.lane_sections):
# https://opensource.org/licenses/MIT # ffmpeg must be installed from modules.runtime.scenario.scenario_generation.drone_challenge import DroneChallengeScenarioGeneration from modules.runtime.commons.parameters import ParameterServer from modules.runtime.viewer.matplotlib_viewer import MPViewer from modules.runtime.viewer.video_renderer import VideoRenderer import os param_server = ParameterServer() scenario_generation = DroneChallengeScenarioGeneration(num_scenarios=1, random_seed=0, params=param_server) viewer = MPViewer(params=param_server, x_range=[-30, 30], y_range=[-30, 30]) sim_step_time = param_server["simulation"]["step_time", "Step-time used in simulation", 0.2] sim_real_time_factor = param_server["simulation"][ "real_time_factor", "execution in real-time or faster", 1] scenario, idx = scenario_generation.get_next_scenario() # Rendering WITHOUT intermediate steps video_renderer = VideoRenderer(renderer=viewer, world_step_time=sim_step_time) for _ in range(0, 10): # run 5 scenarios in a row, repeating after 3 scenario, idx = scenario_generation.get_next_scenario() world_state = scenario.get_world_state() for _ in range(0, 5): video_renderer.drawWorld(world_state, scenario._eval_agent_ids, idx) world_state.step(sim_step_time)
# This software is released under the MIT License. # https://opensource.org/licenses/MIT # ffmpeg must be installed from modules.runtime.scenario.scenario_generation.drone_challenge import DroneChallengeScenarioGeneration from modules.runtime.commons.parameters import ParameterServer from modules.runtime.viewer.matplotlib_viewer import MPViewer from modules.runtime.viewer.video_renderer import VideoRenderer import os param_server = ParameterServer() scenario_generation = DroneChallengeScenarioGeneration(num_scenarios=3, random_seed=0, params=param_server) viewer = MPViewer(params=param_server, x_range=[-30, 30], y_range=[-30, 30]) sim_step_time = param_server["simulation"]["step_time", "Step-time used in simulation", 0.2] sim_real_time_factor = param_server["simulation"][ "real_time_factor", "execution in real-time or faster", 1] scenario, idx = scenario_generation.get_next_scenario() for _ in range(0, 5): # run 5 scenarios in a row, repeating after 3 scenario, idx = scenario_generation.get_next_scenario() world = scenario.get_world_state() # 20 steps for _ in range(0, 20): world.step(sim_step_time) viewer.drawWorld(world)
def test_find_lane(self): xodr_parser = XodrParser("modules/runtime/tests/data/urban_road.xodr") params = ParameterServer() world = World(params) map_interface = MapInterface() map_interface.set_open_drive_map(xodr_parser.map) world.set_map(map_interface) lane_sw = map_interface.find_lane(Point2d(46, 180)) assert lane_sw.lane_type == LaneType.sidewalk lane_rl = map_interface.find_lane(Point2d(52, 130)) assert lane_rl.lane_type == LaneType.driving lane_no_lane = map_interface.find_lane(Point2d(120, 140)) assert lane_no_lane == None xodr_parser = XodrParser("modules/runtime/tests/data/city_highway_straight.xodr") np.set_printoptions(precision=8) params = ParameterServer() world = World(params) map_interface = MapInterface() map_interface.set_open_drive_map(xodr_parser.map) world.set_map(map_interface) point = Point2d(5111, 5072) viewer = MPViewer(params=params, use_world_bounds=True) viewer.drawWorld(world) polygon = world.map.get_roadgraph().get_lane_polygon_by_id(241) polygon2 = world.map.get_roadgraph().get_lane_polygon_by_id(242) viewer.drawPolygon2d(polygon, 'blue', 1.0) viewer.drawPolygon2d(polygon2, 'green', 1.0) viewer.drawPoint2d(point, 'red', 1.0) viewer.show(block=True) time.sleep(0.1) lane_sw = map_interface.find_lane(point) self.assertIsNotNone(lane_sw, "This point is clearly on a lane!")
try: from bark.models.behavior import BehaviorUCTSingleAgent except RuntimeError: RuntimeError( "BehaviorUCTSingleAgent not available, using ConstantVelocityModel") scenario_param_file = "uct_planner.json" # must be within examples params folder param_server = ParameterServer( filename=os.path.join("examples/params/", scenario_param_file)) scenario_generation = UniformVehicleDistribution(num_scenarios=1, random_seed=0, params=param_server) viewer = MPViewer(params=param_server, x_range=[-16, 16], y_range=[-2, 30], follow_agent_id=True) sim_step_time = param_server["simulation"]["step_time", "Step-time used in simulation", 0.2] sim_real_time_factor = param_server["simulation"][ "real_time_factor", "execution in real-time or faster", 1] scenario, idx = scenario_generation.get_next_scenario() world_state = scenario.get_world_state() world_state.agents[scenario._eval_agent_ids[ 0]].behavior_model = BehaviorUCTSingleAgent(param_server) param_server.save("examples/params/mcts_params_written.json") # world_state.agents[scenario._eval_agent_ids[0]].behavior_model video_renderer = VideoRenderer(renderer=viewer,
# Copyright (c) 2019 fortiss GmbH # # This software is released under the MIT License. # https://opensource.org/licenses/MIT from load.benchmark_database import BenchmarkDatabase from modules.runtime.viewer.matplotlib_viewer import MPViewer from modules.runtime.commons.parameters import ParameterServer import time db = BenchmarkDatabase(database_root="external/benchmark_database_release") scenario_generation = db.get_scenario_generator(scenario_set_id=0) param_server = ParameterServer() viewer = MPViewer(params=param_server, x_range=[5060, 5160], y_range=[5070, 5150]) for _ in range(0, 5): # run 5 scenarios in a row, repeating after 3 scenario, idx = scenario_generation.get_next_scenario() world_state = scenario.get_world_state() print("Running scenario {} of {}".format( idx, scenario_generation.num_scenarios)) for _ in range(0, 10): # run each scenario for 3 steps world_state.step(0.2) viewer.drawWorld(world_state) viewer.show(block=False) time.sleep(0.2)
def test_dr_chn_merging(self): # threeway_intersection xodr_parser = XodrParser( "modules/runtime/tests/data/DR_CHN_Merging_ZS_partial_v02.xodr") # World Definition params = ParameterServer() world = World(params) map_interface = MapInterface() map_interface.SetOpenDriveMap(xodr_parser.map) world.SetMap(map_interface) roads = [0, 1] driving_direction = XodrDrivingDirection.forward map_interface.GenerateRoadCorridor(roads, driving_direction) road_corridor = map_interface.GetRoadCorridor(roads, driving_direction) # Draw map viewer = MPViewer(params=params, use_world_bounds=True) viewer.drawWorld(world) viewer.drawPolygon2d(road_corridor.lane_corridors[0].polygon, color="blue", alpha=0.5) viewer.drawPolygon2d(road_corridor.lane_corridors[1].polygon, color="blue", alpha=0.5) viewer.drawPolygon2d(road_corridor.lane_corridors[2].polygon, color="blue", alpha=0.5) viewer.show(block=False) self.assertTrue(road_corridor.lane_corridors[0].polygon.Valid()) self.assertTrue(road_corridor.lane_corridors[1].polygon.Valid()) self.assertTrue(road_corridor.lane_corridors[2].polygon.Valid()) self.assertTrue(road_corridor.polygon.Valid())
def test_evaluator_drivable_area(self): # World Definition params = ParameterServer() world = World(params) # Model Definitions behavior_model = BehaviorConstantVelocity(params) execution_model = ExecutionModelInterpolate(params) dynamic_model = SingleTrackModel(params) # Map Definition map_interface = MapInterface() xodr_map = MakeXodrMapOneRoadTwoLanes() map_interface.SetOpenDriveMap(xodr_map) world.SetMap(map_interface) #open_drive_map = world.map.GetOpenDriveMap() #agent_2d_shape = CarLimousine() agent_2d_shape = Polygon2d( [1.25, 1, 0], [Point2d(-1, -1), Point2d(-1, 1), Point2d(3, 1), Point2d(3, -1)]) init_state = np.array([0, 3, -1.75, 0, 5]) agent_params = params.AddChild("agent1") goal_polygon = Polygon2d( [1, 1, 0], [Point2d(0, 0), Point2d(0, 2), Point2d(2, 2), Point2d(2, 0)]) goal_polygon = goal_polygon.Translate(Point2d(50, -2)) agent = Agent( init_state, behavior_model, dynamic_model, execution_model, agent_2d_shape, agent_params, GoalDefinitionPolygon(goal_polygon), # goal_lane_id map_interface) world.AddAgent(agent) evaluator = EvaluatorDrivableArea() world.AddEvaluator("drivable_area", evaluator) info = world.Evaluate() self.assertFalse(info["drivable_area"]) viewer = MPViewer(params=params, use_world_bounds=True) # Draw map viewer.drawGoalDefinition(goal_polygon, color=(1, 0, 0), alpha=0.5, facecolor=(1, 0, 0)) viewer.drawWorld(world) viewer.drawRoadCorridor(agent.road_corridor) viewer.show(block=False)
from modules.runtime.scenario.scenario_generation.configurable_scenario_generation import ConfigurableScenarioGeneration from modules.runtime.commons.parameters import ParameterServer from modules.runtime.viewer.matplotlib_viewer import MPViewer from modules.runtime.runtime import Runtime from modules.runtime.viewer.pygame_viewer import PygameViewer import time import os scenario_param_file ="highway_merge_configurable.json" # must be within examples params folder param_server = ParameterServer(filename= os.path.join("examples/params/",scenario_param_file)) scenario_generation = ConfigurableScenarioGeneration(num_scenarios=3, params=param_server) viewer = MPViewer( params=param_server, x_range=[5060, 5160], y_range=[5070,5150], use_world_bounds=True) sim_step_time = param_server["simulation"]["step_time", "Step-time used in simulation", 0.2] sim_real_time_factor = param_server["simulation"]["real_time_factor", "execution in real-time or faster", 1] env = Runtime(0.2, viewer, scenario_generation, render=True) env.reset() for _ in range(0, 5):
def test_python_behavior_model(self): # World Definition scenario_param_file = "macro_actions_test.json" # must be within examples params folder params = ParameterServer(filename=os.path.join( "modules/world/tests/params/", scenario_param_file)) world = World(params) # Define two behavior models one python one standard c++ model behavior_model = PythonDistanceBehavior(params) execution_model = ExecutionModelInterpolate(params) dynamic_model = SingleTrackModel(params) behavior_model2 = BehaviorConstantVelocity(params) execution_model2 = ExecutionModelInterpolate(params) dynamic_model2 = SingleTrackModel(params) # Define the map interface and load a testing map map_interface = MapInterface() xodr_map = MakeXodrMapOneRoadTwoLanes() map_interface.SetOpenDriveMap(xodr_map) world.SetMap(map_interface) # Define the agent shapes agent_2d_shape = CarRectangle() init_state = np.array([0, 3, -5.25, 0, 20]) # Define the goal definition for agents center_line = Line2d() center_line.AddPoint(Point2d(0.0, -1.75)) center_line.AddPoint(Point2d(100.0, -1.75)) max_lateral_dist = (0.4, 0.5) max_orientation_diff = (0.08, 0.1) velocity_range = (5.0, 20.0) goal_definition = GoalDefinitionStateLimitsFrenet( center_line, max_lateral_dist, max_orientation_diff, velocity_range) # define two agents with the different behavior models agent_params = params.AddChild("agent1") agent = Agent(init_state, behavior_model, dynamic_model, execution_model, agent_2d_shape, agent_params, goal_definition, map_interface) world.AddAgent(agent) init_state2 = np.array([0, 25, -5.25, 0, 15]) agent2 = Agent(init_state2, behavior_model2, dynamic_model2, execution_model2, agent_2d_shape, agent_params, goal_definition, map_interface) world.AddAgent(agent2) # viewer viewer = MPViewer(params=params, use_world_bounds=True) # World Simulation sim_step_time = params["simulation"]["step_time", "Step-time in simulation", 0.2] sim_real_time_factor = params["simulation"][ "real_time_factor", "execution in real-time or faster", 1] # Draw map video_renderer = VideoRenderer(renderer=viewer, world_step_time=sim_step_time) for _ in range(0, 20): world.Step(sim_step_time) viewer.clear() video_renderer.drawWorld(world) video_renderer.drawGoalDefinition(goal_definition, "red", 0.5, "red") time.sleep(sim_step_time / sim_real_time_factor) video_renderer.export_video(filename="./test_video_intermediate", remove_image_dir=True)
def test_database_run_and_analyze(self): dbs = DatabaseSerializer(test_scenarios=4, test_world_steps=5, num_serialize_scenarios=10) dbs.process("database") local_release_filename = dbs.release(version="test") db = BenchmarkDatabase(database_root=local_release_filename) evaluators = { "success": "EvaluatorGoalReached", "collision": "EvaluatorCollisionEgoAgent", "max_steps": "EvaluatorStepCount" } terminal_when = { "collision": lambda x: x, "max_steps": lambda x: x > 5 } params = ParameterServer( ) # only for evaluated agents not passed to scenario! behaviors_tested = { "IDM": BehaviorIDMClassic(params), "Const": BehaviorConstantVelocity(params) } benchmark_runner = BenchmarkRunnerMP(benchmark_database=db, evaluators=evaluators, terminal_when=terminal_when, behaviors=behaviors_tested, log_eval_avg_every=10) result = benchmark_runner.run(maintain_history=True) result.dump(os.path.join("./benchmark_results.pickle")) result_loaded = BenchmarkResult.load( os.path.join("./benchmark_results.pickle")) params2 = ParameterServer() fig = plt.figure(figsize=[10, 10]) viewer = MPViewer(params=params2, center=[5112, 5165], y_length=120, enforce_y_length=True, axis=fig.gca()) analyzer = BenchmarkAnalyzer(benchmark_result=result_loaded) configs = analyzer.find_configs(criteria={ "behavior": lambda x: x == "IDM", "success": lambda x: not x }) configs_const = analyzer.find_configs(criteria={ "behavior": lambda x: x == "Const", "success": lambda x: not x }) #analyzer.visualize(configs_idx_list = configs, # viewer = viewer, real_time_factor=10, fontsize=12) plt.close(fig) fig, (ax1, ax2) = plt.subplots(1, 2) viewer1 = MPViewer(params=params2, center=[5112, 5165], y_length=120, enforce_y_length=True, axis=ax1) viewer2 = MPViewer(params=params2, center=[5112, 5165], y_length=120, enforce_y_length=True, axis=ax2) analyzer.visualize(configs_idx_list=[configs[1:3], configs_const[1:3]], viewer=[viewer1, viewer2], viewer_names=["IDM", "ConstVelocity"], real_time_factor=1, fontsize=12)
road_ids=[16], lane_corridor_id=1, controlled_ids=True) # create 5 scenarios scenarios = \ ConfigWithEase( num_scenarios=5, map_file_name="modules/runtime/tests/data/city_highway_straight.xodr", random_seed=0, params=param_server, lane_corridor_configs=[left_lane, right_lane]) # viewer viewer = MPViewer(params=param_server, x_range=[-75, 75], y_range=[-75, 75], follow_agent_id=True) sim_step_time = param_server["simulation"]["step_time", "Step-time used in simulation", 0.05] sim_real_time_factor = param_server["simulation"][ "real_time_factor", "execution in real-time or faster", 0.5] # viewer = VideoRenderer(renderer=viewer, # world_step_time=sim_step_time, # fig_path="/home/hart/Dokumente/2020/bark/video") # gym like interface env = Runtime(step_time=0.2, viewer=viewer,
map_interface) world.add_agent(agent) # viewer viewer = PygameViewer(params=param_server, x_range=[-50, 50], y_range=[-50, 50], follow_agent_id=agent.id, screen_dims=[500, 500]) """ viewer = Panda3dViewer(params=param_server, x_range=[-150, 150], y_range=[-150, 150], follow_agent_id=agent.id) """ viewer = MPViewer(params=param_server) # World Simulation sim_step_time = param_server["simulation"]["step_time", "Step-time in simulation", 0.05] sim_real_time_factor = param_server["simulation"][ "real_time_factor", "execution in real-time or faster", 100] for _ in range(0, 100): viewer.clear() world.step(sim_step_time) viewer.drawWorld(world) viewer.show(block=False) time.sleep(sim_step_time / sim_real_time_factor) param_server.save("examples/params/od8_const_vel_one_agent_written.json")
def test_three_way_intersection(self): # threeway_intersection xodr_parser = XodrParser( "modules/runtime/tests/data/threeway_intersection.xodr") # World Definition params = ParameterServer() world = World(params) map_interface = MapInterface() map_interface.SetOpenDriveMap(xodr_parser.map) world.SetMap(map_interface) open_drive_map = world.map.GetOpenDriveMap() viewer = MPViewer(params=params, use_world_bounds=True) comb_all = [] start_point = [Point2d(-30, -2)] end_point_list = [Point2d(30, -2), Point2d(-2, -30)] comb = list(itertools.product(start_point, end_point_list)) comb_all = comb_all + comb # starting on the right start_point = [Point2d(30, 2)] end_point_list = [Point2d(-30, 2)] comb = list(itertools.product(start_point, end_point_list)) comb_all = comb_all + comb # starting on the bottom start_point = [Point2d(2, -30)] end_point_list = [Point2d(30, -2), Point2d(-30, 2)] comb = list(itertools.product(start_point, end_point_list)) comb_all = comb_all + comb # check few corridors def GenerateRoadCorridor(map_interface, comb): (start_p, end_p) = comb polygon = Polygon2d([0, 0, 0], [ Point2d(-1, -1), Point2d(-1, 1), Point2d(1, 1), Point2d(1, -1) ]) start_polygon = polygon.Translate(start_p) goal_polygon = polygon.Translate(end_p) rc = map_interface.GenerateRoadCorridor(start_p, goal_polygon) return rc # assert road ids rc = GenerateRoadCorridor(map_interface, comb_all[0]) self.assertEqual(rc.road_ids, [0, 11, 1]) self.assertEqual(len(rc.lane_corridors), 3) rc = GenerateRoadCorridor(map_interface, comb_all[1]) self.assertEqual(rc.road_ids, [0, 5, 2]) self.assertEqual(len(rc.lane_corridors), 3) rc = GenerateRoadCorridor(map_interface, comb_all[2]) self.assertEqual(rc.road_ids, [1, 10, 0]) self.assertEqual(len(rc.lane_corridors), 3) rc = GenerateRoadCorridor(map_interface, comb_all[3]) self.assertEqual(rc.road_ids, [2, 6, 1]) self.assertEqual(len(rc.lane_corridors), 3) rc = GenerateRoadCorridor(map_interface, comb_all[4]) self.assertEqual(rc.road_ids, [2, 4, 0]) self.assertEqual(len(rc.lane_corridors), 3)
from modules.runtime.commons.parameters import ParameterServer from modules.runtime.viewer.matplotlib_viewer import MPViewer from modules.runtime.viewer.video_renderer import VideoRenderer import os scenario_param_file = "highway_merging.json" # must be within examples params folder param_server = ParameterServer( filename=os.path.join("examples/params/", scenario_param_file)) scenario_generation = UniformVehicleDistribution(num_scenarios=3, random_seed=0, params=param_server) viewer = MPViewer(params=param_server, x_range=[-50, 50], y_range=[-20, 80], follow_agent_id=True) sim_step_time = param_server["simulation"]["step_time", "Step-time used in simulation", 0.2] sim_real_time_factor = param_server["simulation"][ "real_time_factor", "execution in real-time or faster", 1] scenario, idx = scenario_generation.get_next_scenario() # Rendering WITHOUT intermediate steps video_renderer = VideoRenderer(renderer=viewer, world_step_time=sim_step_time) world_state = scenario.get_world_state() for _ in range(0, 10): # run scenario for 100 steps world_state.step(sim_step_time) video_renderer.drawWorld(world_state, scenario._eval_agent_ids) video_renderer.export_video(filename="examples/scenarios/test_video_step")