def _build_world_state(self): param_server = ParameterServer(json=self._json_params) world = World(param_server) if self._map_interface is None: self.CreateMapInterface(self.full_map_file_name) world.SetMap(self._map_interface) else: world.SetMap(self._map_interface) for agent in self._agent_list: agent.GenerateRoadCorridor(self._map_interface) world.AddAgent(agent) world.UpdateAgentRTree() return world
def test_number_of_agents(self): # World Definition params = ParameterServer() world = World(params) # Model Definitions behavior_model = BehaviorConstantAcceleration(params) execution_model = ExecutionModelInterpolate(params) dynamic_model = SingleTrackModel(params) behavior_model2 = BehaviorConstantAcceleration(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() init_state = np.array([0, 13, -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), map_interface) world.AddAgent(agent) init_state2 = np.array([0, 16, -1.75, 0, 5]) agent2 = Agent(init_state2, behavior_model2, dynamic_model2, execution_model2, agent_2d_shape, agent_params, GoalDefinitionPolygon(goal_polygon), map_interface) world.AddAgent(agent2) evaluator = EvaluatorNumberOfAgents(agent.id) world.AddEvaluator("num_agents", evaluator) info = world.Evaluate() self.assertEqual(info["num_agents"], len(world.agents)) # do it once more self.assertEqual(info["num_agents"], len(world.agents)) world.RemoveAgentById(agent2.id) info = world.Evaluate() # evaluator should still hold two self.assertNotEqual(info["num_agents"], len(world.agents)) self.assertEqual(info["num_agents"], 2) world.Step(0.1) info = world.Evaluate() # evaluator should still hold two self.assertEqual(info["num_agents"], 2)
def test_lane_change(self): # World Definition params = ParameterServer() world = World(params) # Model Definitions behavior_model = BehaviorMobil(params) execution_model = ExecutionModelInterpolate(params) dynamic_model = SingleTrackModel(params) behavior_model2 = BehaviorIDMLaneTracking(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, -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), map_interface) world.AddAgent(agent) init_state2 = np.array([0, 15, -1.75, 0, 2]) agent2 = Agent(init_state2, behavior_model2, dynamic_model2, execution_model2, agent_2d_shape, agent_params, GoalDefinitionPolygon(goal_polygon), 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.05] sim_real_time_factor = params["simulation"][ "real_time_factor", "execution in real-time or faster", 100] # Draw map for _ in range(0, 10): viewer.clear() world.Step(sim_step_time) viewer.drawWorld(world) viewer.show(block=False) time.sleep(sim_step_time / sim_real_time_factor)
def make_initial_world(primitives): # must be within examples params folder params = ParameterServer() world = World(params) # Define two behavior models behavior_model = BehaviorMPContinuousActions(params) primitive_mapping = {} for prim in primitives: idx = behavior_model.AddMotionPrimitive( np.array(prim)) # adding action primitive_mapping[idx] = prim behavior_model.ActionToBehavior(0) # setting initial action 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) return world
def test_gap_distance_front(self): # World Definition params = ParameterServer() world = World(params) gap = 10 # Model Definitions behavior_model = BehaviorConstantAcceleration(params) execution_model = ExecutionModelInterpolate(params) dynamic_model = SingleTrackModel(params) behavior_model2 = BehaviorConstantAcceleration(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() init_state = np.array([0, 13, -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), map_interface) world.AddAgent(agent) init_state2 = np.array([0, 13 + gap, -1.75, 0, 5]) agent2 = Agent(init_state2, behavior_model2, dynamic_model2, execution_model2, agent_2d_shape, agent_params, GoalDefinitionPolygon(goal_polygon), map_interface) world.AddAgent(agent2) world.Step(0.1) evaluator = EvaluatorGapDistanceFront(agent.id) world.AddEvaluator("gap", evaluator) info = world.Evaluate() self.assertAlmostEqual(info["gap"], gap - agent_2d_shape.front_dist - agent_2d_shape.rear_dist, places=4)
def test_relevant_agents(self): params = ParameterServer() map = "bark/runtime/tests/data/city_highway_straight.xodr" params["EvaluatorRss"]["MapFilename"] = map map_interface = EvaluatorRSSTests.load_map(map) world = World(params) world.SetMap(map_interface) goal_polygon_1 = Polygon2d( [0, 0, 0], [Point2d(-1, -1), Point2d(-1, 1), Point2d(1, 1), Point2d(1, -1)]) goal_polygon_1 = goal_polygon_1.Translate(Point2d(5.5, 120)) goal_polygon_2 = Polygon2d( [0, 0, 0], [Point2d(-1, -1), Point2d(-1, 1), Point2d(1, 1), Point2d(1, -1)]) goal_polygon_2 = goal_polygon_2.Translate(Point2d(1.8, 120)) ego_state = np.array([0, 5.5, 10, np.pi / 2, 10]) other_1_state = np.array([0, 1.8, -10, np.pi / 2, 15]) other_2_state = np.array([0, 1.8, -120, np.pi / 2, 10]) ego = TestAgent(ego_state, goal_polygon_1, map_interface, params) other_1 = TestAgent(other_1_state, goal_polygon_2, map_interface, params) other_2 = TestAgent(other_2_state, goal_polygon_2, map_interface, params) world.AddAgent(ego) world.AddAgent(other_1) world.AddAgent(other_2) viewer = MPViewer(params=params, use_world_bounds=True) viewer.drawWorld(world) viewer.show(block=False) evaluator_rss = EvaluatorRSS(ego.id, params) responses = evaluator_rss.PairwiseEvaluate(world) self.assertEqual(1, len(responses)) self.assertTrue(responses[other_1.id]) self.assertFalse(other_2.id in responses)
def test_lateral_highway_unsafe(self): """ Checking Lateral Responses (true means safe) """ params = ParameterServer() map = "bark/runtime/tests/data/city_highway_straight.xodr" params["EvaluatorRss"]["MapFilename"] = map map_interface = EvaluatorRSSTests.load_map(map) world = World(params) world.SetMap(map_interface) goal_polygon_1 = Polygon2d( [0, 0, 0], [Point2d(-1, -1), Point2d(-1, 1), Point2d(1, 1), Point2d(1, -1)]) goal_polygon_1 = goal_polygon_1.Translate(Point2d(5.5, 120)) goal_polygon_2 = Polygon2d( [0, 0, 0], [Point2d(-1, -1), Point2d(-1, 1), Point2d(1, 1), Point2d(1, -1)]) goal_polygon_2 = goal_polygon_2.Translate(Point2d(1.8, 120)) # Hard coded ego_state = np.array([0, 5.0, 10, np.pi / 2, 10]) # straight north other_state = np.array([0, 3.1, 0, np.pi / 2, 10]) # straight north ego = TestAgent(ego_state, goal_polygon_1, map_interface, params) other = TestAgent(other_state, goal_polygon_2, map_interface, params) world.AddAgent(ego) world.AddAgent(other) world.UpdateAgentRTree() viewer = MPViewer(params=params, use_world_bounds=True) viewer.drawWorld(world) viewer.show(block=False) evaluator_rss = EvaluatorRSS(ego.id, params) self.assertEqual( False, evaluator_rss.PairwiseDirectionalEvaluate(world)[other.id][1])
def test_between_lanes(self): xodr_parser = XodrParser( os.path.join( os.path.dirname(__file__), "../../../runtime/tests/data/city_highway_straight.xodr")) np.set_printoptions(precision=8) params = ParameterServer() world = World(params) map_interface = MapInterface() map_interface.SetOpenDriveMap(xodr_parser.map) world.SetMap(map_interface) # Simple test point_close = Point2d(2, -92.55029) lane_sw = map_interface.FindLane(point_close) self.assertIsNotNone( lane_sw, "This point is still in the left lane! XodrLane boundary is 5114.683" ) switched_lane = False lng_coord = -92.55029 i = 1.817 lane_sw = map_interface.FindLane(Point2d(i, lng_coord)) assert lane_sw != None prev = lane_sw.lane_id prev_i = i while (i < 4.817): lane_sw = map_interface.FindLane(Point2d(i, lng_coord)) self.assertIsNotNone( lane_sw, "Should always be on at least one lane! Currently at ({}, {})". format(i, lng_coord)) if prev != lane_sw.lane_id: # print(prev) # print(prev_i) # print(lane_sw.lane_id) # print(i) self.assertFalse(switched_lane, "XodrLane switch should only happens once!") switched_lane = True prev_i = i prev = lane_sw.lane_id i = i + 0.01 self.assertTrue(switched_lane, "Eventually should have switched lanes!")
def test_lateral_merging_safe(self): """ Checking Lateral Responses (true means safe) """ params = ParameterServer() map = "bark/runtime/tests/data/DR_DEU_Merging_MT_v01_centered.xodr" params["EvaluatorRss"]["MapFilename"] = map map_interface = EvaluatorRSSTests.load_map(map) world = World(params) world.SetMap(map_interface) goal_polygon = Polygon2d( [0, 0, 0], [Point2d(-1, -1), Point2d(-1, 1), Point2d(1, 1), Point2d(1, -1)]) goal_polygon = goal_polygon.Translate(Point2d(-15.4, 108.6)) # Hard coded ego_state = np.array([0, 68.1, 108, -np.pi, 5]) other_state = np.array([0, 64.1, 105, -np.pi, 5]) ego = TestAgent(ego_state, goal_polygon, map_interface, params) other = TestAgent(other_state, goal_polygon, map_interface, params) world.AddAgent(ego) world.AddAgent(other) world.UpdateAgentRTree() viewer = MPViewer(params=params, use_world_bounds=True) viewer.drawWorld(world) viewer.show(block=False) evaluator_rss = EvaluatorRSS(ego.id, params) world.AddEvaluator("rss", evaluator_rss) pw_directional_evaluation_return = evaluator_rss.PairwiseDirectionalEvaluate( world) self.assertEqual(True, pw_directional_evaluation_return[other.id][1])
def test_longitude_highway_unsafe(self): """ Checking Longitudinal Responses (true means safe) """ params = ParameterServer() map = "bark/runtime/tests/data/city_highway_straight.xodr" params["EvaluatorRss"]["MapFilename"] = map map_interface = EvaluatorRSSTests.load_map(map) world = World(params) world.SetMap(map_interface) goal_polygon = Polygon2d( [0, 0, 0], [Point2d(-1, -1), Point2d(-1, 1), Point2d(1, 1), Point2d(1, -1)]) goal_polygon = goal_polygon.Translate(Point2d(1.8, 120)) # The safety distance seems more conservative than in the paper # Hard coded ego_state = np.array([0, 1.8, -60.0, np.pi / 2, 10]) other_state = np.array([0, 1.8, -68.0, np.pi / 2, 10]) ego = TestAgent(ego_state, goal_polygon, map_interface, params) other = TestAgent(other_state, goal_polygon, map_interface, params) world.AddAgent(ego) world.AddAgent(other) world.UpdateAgentRTree() viewer = MPViewer(params=params, use_world_bounds=True) viewer.drawWorld(world) viewer.show(block=False) evaluator_rss = EvaluatorRSS(ego.id, params) pw_directional_evaluation_return = evaluator_rss.PairwiseDirectionalEvaluate( world) self.assertEqual(False, pw_directional_evaluation_return[other.id][0])
def test_dr_chn_merging(self): # threeway_intersection xodr_parser = XodrParser( os.path.join( os.path.dirname(__file__), "../../../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_curved_road(self): params = ParameterServer() world = World(params) xodr_map = MakeXodrMapCurved(50, 0.1) map_interface = MapInterface() map_interface.SetOpenDriveMap(xodr_map) world.SetMap(map_interface) roads = [100] driving_direction = XodrDrivingDirection.forward map_interface.GenerateRoadCorridor(roads, driving_direction) road_corr = map_interface.GetRoadCorridor(roads, driving_direction) viewer = MPViewer(params=params, use_world_bounds=True) viewer.drawWorld(world) viewer.drawRoadCorridor(road_corr) #viewer.show(block=True) # if this is not here, the second unit test is not executed (maybe parsing takes too long?) time.sleep(1)
def test_two_roads_one_lane(self): params = ParameterServer() world = World(params) xodr_map = MakeXodrMapOneRoadTwoLanes() map_interface = MapInterface() map_interface.SetOpenDriveMap(xodr_map) world.SetMap(map_interface) start_point = Point2d(0, -11) lanes_near_start = map_interface.find_nearest_lanes(start_point, 1) assert(len(lanes_near_start) == 1) goal_point = Point2d(-191.789, -50.1725) lanes_near_goal = map_interface.find_nearest_lanes(goal_point, 1) assert(len(lanes_near_goal) == 1) viewer = MPViewer(params=params, use_world_bounds=True) viewer.drawWorld(world) # if this is not here, the second unit test is not executed (maybe parsing takes too long?) time.sleep(2)
def test_road_corridor_forward(self): xodr_parser = XodrParser( os.path.join( os.path.dirname(__file__), "../../../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
def test_dr_deu_merging_centered(self): # threeway_intersection xodr_parser = XodrParser( os.path.join( os.path.dirname(__file__), "../../../runtime/tests/data/DR_DEU_Merging_MT_v01_centered.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.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.polygon.Valid()) tol = 0.2 center_line_array = road_corridor.lane_corridors[ 0].center_line.ToArray() left_boundary_array = road_corridor.lane_corridors[ 0].left_boundary.ToArray() right_boundary_array = road_corridor.lane_corridors[ 0].right_boundary.ToArray() # beginning of left lane self.assertAlmostEquals(center_line_array[0, 0], 106.4, 1) self.assertAlmostEquals(center_line_array[0, 1], 103.47, 1) self.assertAlmostEquals( Distance( Point2d(left_boundary_array[0, 0], left_boundary_array[0, 1]), Point2d(right_boundary_array[0, 0], right_boundary_array[0, 1])), 2.8, 1) # end of left lane self.assertAlmostEquals(center_line_array[-1, 0], -18.15, 1) self.assertAlmostEquals(center_line_array[-1, 1], 109.0, 1) self.assertAlmostEquals( Distance( Point2d(left_boundary_array[-1, 0], left_boundary_array[-1, 1]), Point2d(right_boundary_array[-1, 0], right_boundary_array[-1, 1])), 2.63, 1)
def test_evaluator_drivable_area(self): # World Definition params = ParameterServer() world = World(params) # Model Definitions behavior_model = BehaviorConstantAcceleration(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)
def test_three_way_intersection(self): # threeway_intersection xodr_parser = XodrParser( os.path.join( os.path.dirname(__file__), "../../../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) self.assertTrue(rc.polygon.Valid()) rc = GenerateRoadCorridor(map_interface, comb_all[1]) self.assertEqual(rc.road_ids, [0, 5, 2]) self.assertEqual(len(rc.lane_corridors), 3) self.assertTrue(rc.polygon.Valid()) rc = GenerateRoadCorridor(map_interface, comb_all[2]) self.assertEqual(rc.road_ids, [1, 10, 0]) self.assertEqual(len(rc.lane_corridors), 3) self.assertTrue(rc.polygon.Valid()) rc = GenerateRoadCorridor(map_interface, comb_all[3]) self.assertEqual(rc.road_ids, [2, 6, 1]) self.assertEqual(len(rc.lane_corridors), 3) self.assertTrue(rc.polygon.Valid()) rc = GenerateRoadCorridor(map_interface, comb_all[4]) self.assertEqual(rc.road_ids, [2, 4, 0]) self.assertEqual(len(rc.lane_corridors), 3) self.assertTrue(rc.polygon.Valid())
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( os.path.dirname(__file__), "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 = BehaviorConstantAcceleration(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_uct_single_agent(self): try: from bark.core.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( os.path.dirname(__file__), "params/", scenario_param_file)) world = World(params) # Model Definitions behavior_model = BehaviorUCTSingleAgentMacroActions(params) execution_model = ExecutionModelInterpolate(params) dynamic_model = SingleTrackModel(params) behavior_model2 = BehaviorConstantAcceleration(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)
map_name = "left_turn_rural" output_dir = "/tmp/" + map_name # Map Definition xodr_parser = XodrParser("bark/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)