示例#1
0
    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)
示例#2
0
    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])
示例#3
0
    def test_lateral_same_direction(self):
        map = "bark/runtime/tests/data/city_highway_straight.xodr"
        map_interface = EvaluatorRSSTests.load_map(map)
        world = self.defaults["world"].Copy()
        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.5, 10, 0, 10])
        other_state = np.array([0, 1.8, -10, 0, 15])

        ego = Agent(ego_state, self.defaults["ego_behavior"],
                    self.defaults["ego_dynamic"],
                    self.defaults["ego_execution"], self.defaults["ego_shape"],
                    self.defaults["agent_params"],
                    GoalDefinitionPolygon(goal_polygon_1), map_interface)
        other = Agent(other_state, self.defaults["other_behavior"],
                      self.defaults["other_dynamic"],
                      self.defaults["other_execution"],
                      self.defaults["other_shape"],
                      self.defaults["agent_params"],
                      GoalDefinitionPolygon(goal_polygon_2), map_interface)

        world.AddAgent(ego)
        world.AddAgent(other)

        evaluator_rss = EvaluatorRss(ego.id, map,
                                     self.defaults["default_vehicle_dynamics"])

        for _ in range(7):
            world.Step(1)
            self.assertEqual(
                True,
                evaluator_rss.PairwiseDirectionalEvaluate(world)[other.id][1])
示例#4
0
    def test_one_agent_at_goal_state_limits(self):
        param_server = ParameterServer()
        # Model Definition
        behavior_model = BehaviorConstantVelocity(param_server)
        execution_model = ExecutionModelInterpolate(param_server)
        dynamic_model = SingleTrackModel(param_server)

        # Agent Definition
        agent_2d_shape = CarLimousine()
        init_state = np.array(
            [0, -191.789, -50.1725, 3.14 * 3.0 / 4.0, 150 / 3.6])
        agent_params = param_server.AddChild("agent1")
        goal_polygon = Polygon2d(
            [0, 0, 0],
            [Point2d(-1, -1),
             Point2d(-1, 1),
             Point2d(1, 1),
             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,
            GoalDefinitionStateLimits(
                goal_polygon,
                (3.14 * 3.0 / 4.0 - 0.08, 3.14 * 3.0 / 4.0 + 0.08)), None)

        world = World(param_server)
        world.AddAgent(agent)
        evaluator = EvaluatorGoalReached(agent.id)
        world.AddEvaluator("success", evaluator)

        info = world.Evaluate()
        self.assertEqual(info["success"], True)
示例#5
0
  def test_planning_time(self):
    param_server = ParameterServer()
    # Model Definition
    behavior_model = BehaviorConstantAcceleration(param_server)
    execution_model = ExecutionModelInterpolate(param_server)
    dynamic_model = SingleTrackModel(param_server)

    # Agent Definition
    agent_2d_shape = CarLimousine()
    init_state = np.array([0, -191.789,-50.1725, 3.14*3.0/4.0, 150/3.6])
    agent_params = param_server.AddChild("agent1")
    goal_polygon = Polygon2d([0, 0, 0],
                             [Point2d(-4,-4),
                              Point2d(-4,4),
                              Point2d(4,4),
                              Point2d(4,-4)])
    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),
                  None)

    world = World(param_server)
    world.AddAgent(agent)
    evaluator = EvaluatorPlanningTime(agent.id)
    world.AddEvaluator("time", evaluator)


    info = world.Evaluate()
    self.assertEqual(info["time"], 0.0)
示例#6
0
    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)
示例#7
0
    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)
示例#8
0
 def goal(self, world):
     goal_polygon = Polygon2d(
         [-1000, -1000, -1000],
         [Point2d(-1, -1),
          Point2d(-1, 1),
          Point2d(1, 1),
          Point2d(1, -1)])
     return GoalDefinitionPolygon(goal_polygon)
示例#9
0
  def test_one_agent_at_goal_sequential(self):
    param_server = ParameterServer()
    # Model Definition
    dynamic_model = SingleTrackModel(param_server)
    behavior_model = BehaviorMPContinuousActions(param_server)
    idx = behavior_model.AddMotionPrimitive(np.array([1, 0]))
    behavior_model.ActionToBehavior(idx)
    execution_model = ExecutionModelInterpolate(param_server)


    # Agent Definition
    agent_2d_shape = CarLimousine()
    init_state = np.array([0, 0, 0, 0, 0])
    agent_params = param_server.AddChild("agent1")
    goal_frame = Polygon2d([0, 0, 0],
                             [Point2d(-1,-1),
                              Point2d(-1,1),
                              Point2d(1,1),
                              Point2d(1,-1)])

    goal_polygon1 = goal_frame.Translate(Point2d(10, 0))
    goal_polygon2 = goal_frame.Translate(Point2d(20, 0))
    goal_polygon3 = goal_frame.Translate(Point2d(30, 0))

    goal_def1 = GoalDefinitionStateLimits(goal_polygon1, [-0.08, 0.08])
    goal_def2 = GoalDefinitionStateLimits(goal_polygon2, [-0.08, 0.08])
    goal_def3 = GoalDefinitionStateLimits(goal_polygon3, [-0.08, 0.08])

    goal_definition = GoalDefinitionSequential([goal_def1,
                                                goal_def2,
                                                goal_def3])

    self.assertEqual(len(goal_definition.sequential_goals),3)
    agent = Agent(init_state,
                behavior_model,
                dynamic_model,
                execution_model,
                agent_2d_shape,
                agent_params,
                goal_definition,
                  None)

    world = World(param_server)
    world.AddAgent(agent)
    evaluator = EvaluatorGoalReached(agent.id)
    world.AddEvaluator("success", evaluator)

    # just drive with the single motion primitive should be successful 
    for _ in range(0,1000):
        world.Step(0.2)
        info = world.Evaluate()
        if info["success"]:
            break
    
    self.assertEqual(info["success"], True)
    self.assertAlmostEqual(agent.state[int(StateDefinition.X_POSITION)], 30, delta=0.5)
示例#10
0
    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 ShapeFromTrack(track, wheelbase=2.7):
    offset = wheelbase / 2.0
    length = track.length
    width = track.width
    pose = [0.0, 0.0, 0.0]
    points = [[length / 2.0 + offset, -width / 2.0],
              [length / 2.0 + offset, width / 2.0],
              [-length / 2.0 + offset, width / 2.0],
              [-length / 2.0 + offset, -width / 2.0],
              [length / 2.0 + offset, -width / 2.0]]
    poly = Polygon2d(pose, points)
    return poly
def ShapeFromTrack(track, wheelbase=2.7):
    offset = wheelbase / 2.0
    length = track.length
    width = track.width
    pose = [0.0, 0.0, 0.0]
    p1 = [length / 2.0 + offset, -width / 2.0]
    p2 = [length / 2.0 + offset, width / 2.0]
    p3 = [-length / 2.0 + offset, width / 2.0]
    p4 = [-length / 2.0 + offset, -width / 2.0]
    points = [p1, p2, p3, p4, p1]
    poly = Polygon2d(pose, points)
    return poly
def GoalDefinitionFromTrack(track, end):
    states = list(dict_utils.get_item_iterator(track.motion_states))
    motion_state = states[-1][1]
    bark_state = BarkStateFromMotionState(motion_state)
    goal_polygon = Polygon2d(
        np.array([0.0, 0.0, 0.0]),
        [Point2d(-1.5, 0),
         Point2d(-1.5, 8),
         Point2d(1.5, 8),
         Point2d(1.5, 0)])
    goal_polygon = goal_polygon.Translate(
        Point2d(bark_state[0, int(StateDefinition.X_POSITION)],
                bark_state[0, int(StateDefinition.Y_POSITION)]))
    goal_definition = GoalDefinitionPolygon(goal_polygon)
    return goal_definition
示例#14
0
 def test_write_params_agent(self):
     params = ParameterServer()
     behavior = BehaviorConstantAcceleration(params)
     execution = ExecutionModelInterpolate(params)
     dynamic = SingleTrackModel(params)
     shape = Polygon2d([1.25, 1, 0], [
         Point2d(0, 0),
         Point2d(0, 2),
         Point2d(4, 2),
         Point2d(4, 0),
         Point2d(0, 0)
     ])
     init_state = np.zeros(4)
     agent = Agent(init_state, behavior, dynamic, execution, shape,
                   params.AddChild("agent"))
     params.Save("written_agents_param_test.json")
示例#15
0
    def test_longitude_ego_follow_other(self):
        map = "bark/runtime/tests/data/city_highway_straight.xodr"
        map_interface = EvaluatorRSSTests.load_map(map)
        world = self.defaults["world"].Copy()
        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, -114.9, 0, 10])
        other_state = np.array([0, 1.8, -72.95, 0, 7])

        ego = Agent(ego_state, self.defaults["ego_behavior"],
                    self.defaults["ego_dynamic"],
                    self.defaults["ego_execution"], self.defaults["ego_shape"],
                    self.defaults["agent_params"],
                    GoalDefinitionPolygon(goal_polygon), map_interface)
        other = Agent(other_state, self.defaults["other_behavior"],
                      self.defaults["other_dynamic"],
                      self.defaults["other_execution"],
                      self.defaults["other_shape"],
                      self.defaults["agent_params"],
                      GoalDefinitionPolygon(goal_polygon), map_interface)

        world.AddAgent(ego)
        world.AddAgent(other)

        evaluator_rss = EvaluatorRss(ego.id,
                                     map,
                                     self.defaults["default_vehicle_dynamics"],
                                     checking_relevent_range=1.5)
        world.Step(0.01)
        self.assertEqual(
            True,
            evaluator_rss.PairwiseDirectionalEvaluate(world)[other.id][0])
        world.Step(0.01)
        self.assertEqual(
            False,
            evaluator_rss.PairwiseDirectionalEvaluate(world)[other.id][0])
示例#16
0
    def test_lateral_merging(self):
        map = "bark/runtime/tests/data/DR_DEU_Merging_MT_v01_centered.xodr"
        map_interface = EvaluatorRSSTests.load_map(map)
        world = self.defaults["world"].Copy()
        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(-16, 108))

        # Hard coded
        ego_state = np.array([0, 68, 108, 0, 5])
        other_state = np.array([0, 64, 104, 0, 5])

        ego = Agent(ego_state, self.defaults["ego_behavior"],
                    self.defaults["ego_dynamic"],
                    self.defaults["ego_execution"], self.defaults["ego_shape"],
                    self.defaults["agent_params"],
                    GoalDefinitionPolygon(goal_polygon), map_interface)
        other = Agent(other_state, self.defaults["other_behavior"],
                      self.defaults["other_dynamic"],
                      self.defaults["other_execution"],
                      self.defaults["other_shape"],
                      self.defaults["agent_params"],
                      GoalDefinitionPolygon(goal_polygon), map_interface)

        world.AddAgent(ego)
        world.AddAgent(other)

        evaluator_rss = EvaluatorRss(ego.id, map,
                                     self.defaults["default_vehicle_dynamics"])
        world.Step(1)
        self.assertEqual(
            True,
            evaluator_rss.PairwiseDirectionalEvaluate(world)[other.id][1])

        world.Step(1)
        self.assertEqual(
            False,
            evaluator_rss.PairwiseDirectionalEvaluate(world)[other.id][1])
示例#17
0
    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])
示例#18
0
    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])
示例#19
0
def GoalDefinitionFromTrack(track, end, xy_offset):
    goal_size = 12.0
    states = list(dict_utils.get_item_iterator(track.motion_states))
    # Goal position is spatial position of last state
    motion_state = states[-1][1]
    bark_state = BarkStateFromMotionState(motion_state, xy_offset=xy_offset)
    goal_polygon = Polygon2d(np.array([0.5 * goal_size, 0.5 * goal_size, 0.0]),
                             [
                                 Point2d(0.0, 0.0),
                                 Point2d(goal_size, 0.0),
                                 Point2d(goal_size, goal_size),
                                 Point2d(0.0, goal_size),
                                 Point2d(0.0, 0.0)
                             ])
    goal_point = Point2d(
        bark_state[0, int(StateDefinition.X_POSITION)] - 0.5 * goal_size,
        bark_state[0, int(StateDefinition.Y_POSITION)] - 0.5 * goal_size)
    goal_polygon = goal_polygon.Translate(goal_point)
    goal_definition = GoalDefinitionPolygon(goal_polygon)
    return goal_definition
示例#20
0
    def test_draw_agents(self):
        params = ParameterServer()
        behavior = BehaviorConstantAcceleration(params)
        execution = ExecutionModelInterpolate(params)
        dynamic = SingleTrackModel(params)
        shape = Polygon2d([1.25, 1, 0], [
            Point2d(0, 0),
            Point2d(0, 2),
            Point2d(4, 2),
            Point2d(4, 0),
            Point2d(0, 0)
        ])
        shape2 = CarLimousine()

        init_state = [0, 3, 2, 1]
        init_state2 = [0, 0, 5, 4]

        agent = Agent(init_state, behavior, dynamic, execution, shape,
                      params.AddChild("agent"))
        agent2 = Agent(init_state2, behavior, dynamic, execution, shape2,
                       params.AddChild("agent"))
示例#21
0
    def test_world(self):
        # create agent
        params = ParameterServer()
        behavior = BehaviorConstantAcceleration(params)
        execution = ExecutionModelInterpolate(params)
        dynamic = SingleTrackModel(params)
        shape = Polygon2d([1.25, 1, 0], [
            Point2d(0, 0),
            Point2d(0, 2),
            Point2d(4, 2),
            Point2d(4, 0),
            Point2d(0, 0)
        ])
        init_state = np.array([0, 0, 0, 0, 5])
        agent = Agent(init_state, behavior, dynamic, execution, shape,
                      params.AddChild("agent"))
        road_map = OpenDriveMap()
        newXodrRoad = XodrRoad()
        newXodrRoad.id = 1
        newXodrRoad.name = "Autobahn A9"
        newPlanView = PlanView()
        newPlanView.AddLine(Point2d(0, 0), 1.57079632679, 10)
        newXodrRoad.plan_view = newPlanView
        line = newXodrRoad.plan_view.GetReferenceLine().ToArray()
        p = Point2d(line[-1][0], line[-1][1])
        newXodrRoad.plan_view.AddSpiral(p, 1.57079632679, 50.0, 0.0, 0.3, 0.4)
        line = newXodrRoad.plan_view.GetReferenceLine()
        lane_section = XodrLaneSection(0)
        lane = XodrLane()
        lane.line = line
        lane_section.AddLane(lane)
        newXodrRoad.AddLaneSection(lane_section)
        road_map.AddRoad(newXodrRoad)

        r = Roadgraph()
        map_interface = MapInterface()
        map_interface.SetOpenDriveMap(road_map)
        map_interface.SetRoadgraph(r)
        world = World(params)
        world.AddAgent(agent)
示例#22
0
    def test_relevent_agents(self):
        map = "bark/runtime/tests/data/city_highway_straight.xodr"
        map_interface = EvaluatorRSSTests.load_map(map)
        world = self.defaults["world"].Copy()
        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.5, 10, 0, 10])
        other_1_state = np.array([0, 1.8, -10, 0, 15])
        other_2_state = np.array([0, 1.8, -120, 0, 10])

        ego = Agent(ego_state, self.defaults["ego_behavior"],
                    self.defaults["ego_dynamic"],
                    self.defaults["ego_execution"], self.defaults["ego_shape"],
                    self.defaults["agent_params"],
                    GoalDefinitionPolygon(goal_polygon_1), map_interface)
        other_1 = Agent(other_1_state, self.defaults["other_behavior"],
                        self.defaults["other_dynamic"],
                        self.defaults["other_execution"],
                        self.defaults["other_shape"],
                        self.defaults["agent_params"],
                        GoalDefinitionPolygon(goal_polygon_2), map_interface)

        other_2_behavior = BehaviorConstantAcceleration(
            self.defaults["agent_params"])
        other_2_dynamic = SingleTrackModel(self.defaults["agent_params"])
        other_2_execution = ExecutionModelInterpolate(
            self.defaults["agent_params"])

        other_2 = Agent(other_2_state, other_2_behavior, other_2_dynamic,
                        other_2_execution, self.defaults["other_shape"],
                        self.defaults["agent_params"],
                        GoalDefinitionPolygon(goal_polygon_2), map_interface)

        world.AddAgent(ego)
        world.AddAgent(other_1)
        world.AddAgent(other_2)

        evaluator_rss = EvaluatorRss(ego.id, map,
                                     self.defaults["default_vehicle_dynamics"])
        world.Step(1)
        responses = evaluator_rss.PairwiseEvaluate(world)

        self.assertEqual(1, len(responses))  # Test GetRelevantAgents
        self.assertTrue(responses[other_1.id])
        self.assertFalse(other_2.id in responses)
示例#23
0
# end_point_list = [Point2d(153, 172), Point2d(172, 187), Point2d(188, 168)]
# comb = list(itertools.product(start_point, end_point_list))
# comb_all = comb_all + comb

# # starting on the top
# start_point = [Point2d(168, 187)]
# end_point_list = [Point2d(153, 172), Point2d(168, 153), Point2d(188, 168)]
# comb = list(itertools.product(start_point, end_point_list))
# comb_all = comb_all + comb

print("comb_all", comb_all)

for cnt, (start_p, end_p) in enumerate(comb_all):
    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)
    if rc:
        roads = rc.roads
        road_ids = list(roads.keys())
        print(road_ids, rc.road_ids)

        viewer.drawWorld(world)
        viewer.drawRoadCorridor(rc, "blue")
        viewer.saveFig(output_dir + "/" + "roadcorridor_" + str(cnt) + ".png")
        viewer.show()
        viewer.clear()
示例#24
0
    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)