def test_line_is_unblocked(self): visible_obstacles = environment_details.visible_obstacles # Test line from open space to polygon p = geometry_helpers.Point(33, 8) r = geometry_helpers.Point(32, 11) self.assertTrue(percepts.line_is_unblocked(p, r, visible_obstacles)) # Test line from polygon to polygon p = geometry_helpers.Point(29, 12) r = geometry_helpers.Point(32, 11) self.assertTrue(percepts.line_is_unblocked(p, r, visible_obstacles)) # Test line along the side of a polygon p = geometry_helpers.Point(32, 11) r = geometry_helpers.Point(29, 21) self.assertTrue(percepts.line_is_unblocked(p, r, visible_obstacles)) # Test line going through obstacle p = geometry_helpers.Point(35, 21) r = geometry_helpers.Point(29, 21) self.assertFalse(percepts.line_is_unblocked(p, r, visible_obstacles)) # Test line going through obstacle, along edge of obstacle p = geometry_helpers.Point(10, 14) r = geometry_helpers.Point(16, 14) self.assertFalse(percepts.line_is_unblocked(p, r, visible_obstacles))
def test_goal_test(self): goal_point = geometry_helpers.Point(29, 17) sim_agent = agent.Agent(goal_point, None, None) p = geometry_helpers.Point(30, 12) self.assertFalse(sim_agent.goal_test(p)) q = geometry_helpers.Point(29, 17) self.assertTrue(sim_agent.goal_test(q))
def test_run_simulation(self): number_of_turns = 250 goal_point = geometry_helpers.Point(34, 22) goal_reward = 1000 initial_location = geometry_helpers.Point(5, 5) self.assertTrue( simulation.run_simulation(number_of_turns, goal_point, goal_reward, initial_location))
def test_current_state_probability(self): a = geometry_helpers.Point(6, 10) obstacles = environment_details.visible_obstacles goal = geometry_helpers.Point(34, 22) sim_agent = agent.Agent(goal, None, obstacles) sim_agent.prev_state = agent.State(geometry_helpers.Point(6, 2), 1) sim_agent.prev_cost_estimates = {} sim_agent.prev_result = {} self.assertEqual(0.375, sim_agent._current_prob(a))
def test_heuristic(self): # For now these tests are also redundant since actual_cost is just # a straight line, but this could also change in the future, so # we keep them. # Test straight horizontal line s1 = geometry_helpers.Point(1, 1) s2 = geometry_helpers.Point(4, 1) self.assertEqual(3, percepts.actual_cost(s1, s2, s2)) # Test straight vertical line s1 = geometry_helpers.Point(1, 1) s2 = geometry_helpers.Point(1, 4) self.assertEqual(3, percepts.actual_cost(s1, s2, s2)) # Test positive horizontal line s1 = geometry_helpers.Point(1, 1) s2 = geometry_helpers.Point(4, 4) self.assertEqual(4.242640687119285, percepts.actual_cost(s1, s2, s2)) # Test negative horizontal line s1 = geometry_helpers.Point(1, 1) s2 = geometry_helpers.Point(-2, -2) self.assertEqual(4.242640687119285, percepts.actual_cost(s1, s2, s2))
def test_heuristic(self): # For now these tests are slightly redundant since heuristic is just # a straight line, but since the heuristic could change in the # future it's better to have them. # Test straight horizontal line p1 = geometry_helpers.Point(1, 1) goal = geometry_helpers.Point(4, 1) self.assertEqual(3, percepts.heuristic(p1, goal)) # Test straight vertical line p1 = geometry_helpers.Point(1, 1) goal = geometry_helpers.Point(1, 4) self.assertEqual(3, percepts.heuristic(p1, goal)) # Test positive horizontal line p1 = geometry_helpers.Point(1, 1) goal = geometry_helpers.Point(4, 4) self.assertEqual(4.242640687119285, percepts.heuristic(p1, goal)) # Test negative horizontal line p1 = geometry_helpers.Point(1, 1) goal = geometry_helpers.Point(-2, -2) self.assertEqual(4.242640687119285, percepts.heuristic(p1, goal))
def test_obstacle_blocks_line(self): # Test line clearly crossing through obstacle p = geometry_helpers.Point(23, 9) r = geometry_helpers.Point(6, 10) O = environment_details.rectangle1 self.assertTrue(geometry_helpers.obstacle_blocks_line(p, r, O), "Line intersection not detected.") # Test one line segment end touching obstacle, # but otherwise not intersecting p = geometry_helpers.Point(26, 9) r = geometry_helpers.Point(23, 9) O = environment_details.hexagon self.assertFalse(geometry_helpers.obstacle_blocks_line(p, r, O), "Only ends touch, shouldn't count as intersection.") # Test line clearly not intersecting obstacle p = geometry_helpers.Point(32, 23) r = geometry_helpers.Point(35, 21) O = environment_details.hexagon self.assertFalse( geometry_helpers.obstacle_blocks_line(p, r, O), "Lines are nowhere near each other, something's wrong.") # Test line intersecting obstacle by passing along # one of the obstacle's edges p = geometry_helpers.Point(32, 6) r = geometry_helpers.Point(32, 11) O = environment_details.hexagon self.assertTrue(geometry_helpers.obstacle_blocks_line(p, r, O), "Line should intersect along obstacle's edge.")
def test_refine_possible_locations(self): # Sanity check, no possible locations obstacles = environment_details.visible_obstacles possible_locations = [] goal = geometry_helpers.Point(34, 22) sim_agent = agent.Agent(goal, None, obstacles) sim_agent.prev_state = agent.State(geometry_helpers.Point(6, 2), 1) sim_agent.prev_result = {} sim_agent.prev_cost_estimates = {} self.assertEqual([], sim_agent._refine_loc(possible_locations)) # prev_state not visible from any of the possible locations possible_locations = [geometry_helpers.Point(35, 21)] self.assertEqual([], sim_agent._refine_loc(possible_locations)) # only point (6, 10) from possible_locations is visible possible_locations = [geometry_helpers.Point(6, 10), geometry_helpers.Point(35, 21)] self.assertEqual([agent.State(geometry_helpers.Point(6, 10), 0.375)], sim_agent._refine_loc(possible_locations)) # Sanity check, a refined list of locations shouldn't be # updated again. possible_locations = [geometry_helpers.Point(6, 10)] self.assertEqual([agent.State(geometry_helpers.Point(6, 10), 0.375)], sim_agent._refine_loc(possible_locations))
def test_LRTA_star_agent(self): visible_obstacles = environment_details.visible_obstacles goal_point = geometry_helpers.Point(4, 5) agent_location = geometry_helpers.Point(4, 5) sim_agent = agent.Agent(goal_point, agent.State(agent_location, 1), visible_obstacles) sim_agent.result = {} sim_agent.cost_estimates = {} sim_agent.prev_state = agent.State(None, 1) sim_agent.prev_action = None sim_agent.LRTA_star_agent() self.assertEqual(None, sim_agent.prev_action) self.assertEqual(None, sim_agent.prev_state.location) self.assertEqual({}, sim_agent.result) self.assertEqual({}, sim_agent.cost_estimates) # Update goal point so agent has to plan an action sim_agent.goal = geometry_helpers.Point(34, 22) sim_agent.LRTA_star_agent() self.assertEqual(sim_agent.cost_estimates[sim_agent.prev_state.location], percepts.heuristic(sim_agent.prev_state.location, sim_agent.goal)) self.assertFalse((None, None) in sim_agent.result) self.assertFalse(None in sim_agent.cost_estimates) self.assertEqual(geometry_helpers.Point(6, 2), sim_agent.prev_action) self.assertEqual(geometry_helpers.Point(4, 5), sim_agent.prev_state.location) sim_agent.belief_state = agent.State( percepts.perform_action(sim_agent.prev_action), 1) sim_agent.LRTA_star_agent() self.assertEqual(sim_agent.prev_state.location, sim_agent.result[(geometry_helpers.Point(4, 5), geometry_helpers.Point(6, 2))]) self.assertEqual(34.48187929913333, sim_agent.cost_estimates[geometry_helpers.Point(4, 5)]) self.assertEqual(geometry_helpers.Point(18, 2), sim_agent.prev_action) self.assertEqual(geometry_helpers.Point(6, 2), sim_agent.prev_state.location)
def test_line_is_valid_for_own_obstacle(self): # Test line is part of obstacle p = geometry_helpers.Point(6, 2) r = geometry_helpers.Point(6, 10) obstacle = environment_details.rectangle1 self.assertTrue( geometry_helpers.line_is_valid_for_own_obstacle(p, r, obstacle)) # Test line crosses through obstacle p = geometry_helpers.Point(6, 2) r = geometry_helpers.Point(18, 10) obstacle = environment_details.rectangle1 self.assertFalse( geometry_helpers.line_is_valid_for_own_obstacle(p, r, obstacle))
def test_prev_state_probability(self): # Test prev_state not visible from a a = geometry_helpers.Point(6, 2) goal = geometry_helpers.Point(34, 22) visible_obstacles = environment_details.visible_obstacles sim_agent = agent.Agent(goal, None, visible_obstacles) sim_agent.prev_result = {} sim_agent.prev_cost_estimates = {} sim_agent.prev_state = agent.State(geometry_helpers.Point(32, 23), 1) self.assertEqual(0, sim_agent._prev_prob(a)) # Test location A not an optimal move from prev_state a = geometry_helpers.Point(5, 20) sim_agent.prev_state = agent.State(geometry_helpers.Point(6, 2), 1) sim_agent.prev_result[(sim_agent.prev_state.location, a)] = a sim_agent.prev_cost_estimates[a] = 50 self.assertEqual(0, sim_agent._prev_prob(a)) # Test location A is visible from prev_state, and is an # optimal move from prev_state sim_agent.prev_result = {} sim_agent.prev_cost_estimates = {} sim_agent.prev_state = agent.State(geometry_helpers.Point(6, 2), 1) a = geometry_helpers.Point(6, 10) self.assertEqual(0.375, sim_agent._prev_prob(a))
def test_point_in_any_obstacle(self): # Test point clearly inside obstacle p = geometry_helpers.Point(8, 8) obstacles = environment_details.visible_obstacles self.assertTrue(geometry_helpers.point_in_any_obstacle(p, obstacles)) # Test point clearly outside obstacle p = geometry_helpers.Point(5, 5) obstacles = environment_details.visible_obstacles self.assertFalse(geometry_helpers.point_in_any_obstacle(p, obstacles)) # Test point on edge of obstacle p = geometry_helpers.Point(10, 2) obstacles = environment_details.visible_obstacles self.assertFalse(geometry_helpers.point_in_any_obstacle(p, obstacles))
def sim_perform_action(sim_agent, actual_location): """ Given the agent's true location, let the agent perform its intended action and return the true results of the action. """ print('Agent believes it is attempting to reach point {}'.format( sim_agent.prev_action)) relative_move = geom.Point( (sim_agent.prev_action.x - sim_agent.belief_state.location.x), (sim_agent.prev_action.y - sim_agent.belief_state.location.y)) actual_target = geom.Point((relative_move.x + actual_location.x), (relative_move.y + actual_location.y)) print('Agent actually attempting to reach point {}'.format(actual_target)) actual_location = percepts.perform_action(sim_agent.prev_action) return actual_location
def test_point_inside_own_obstacle(self): # Test point is clearly vertex p = geometry_helpers.Point(6, 2) obstacle = environment_details.rectangle1 self.assertTrue(geometry_helpers.point_inside_own_obstacle( p, obstacle)) # Test point on edge of obstacle p = geometry_helpers.Point(10, 2) obstacle = environment_details.rectangle1 self.assertFalse( geometry_helpers.point_inside_own_obstacle(p, obstacle)) # Test point clearly outside obstacle p = geometry_helpers.Point(6, 2) obstacle = environment_details.hexagon self.assertFalse( geometry_helpers.point_inside_own_obstacle(p, obstacle))
def test_update_certain(self): possible_locations = [geometry_helpers.Point(6, 10)] sim_agent = agent.Agent(None, None, None) sim_agent.prev_state = agent.State(geometry_helpers.Point(6, 2), 0.7) sim_agent.prev_action = geometry_helpers.Point(6, 10) sim_agent.belief_history = [[agent.State(geometry_helpers.Point(5, 3), 0.8)]] # Agent is uncertain of past location, update previous belief states sim_agent._update_certain(possible_locations) self.assertEqual(geometry_helpers.Point(6, 10), sim_agent.belief_state.location) # TODO This will change when we add update_previous_belief logic # Add logic to check that agent.results were updated self.assertEqual([], sim_agent.belief_history) # Agent is certain of past location, and ended at # intended destination. sim_agent.prev_state = agent.State(geometry_helpers.Point(6, 2), 1) sim_agent._update_certain(possible_locations) self.assertEqual(geometry_helpers.Point(6, 10), sim_agent.belief_state.location) self.assertEqual([], sim_agent.belief_history) # Agent is certain of past location, but did not end up at # intended destination. # TODO Add logic to check that recovery scheme worked sim_agent.prev_action = geometry_helpers.Point(18, 2) sim_agent._update_certain(possible_locations) self.assertEqual(geometry_helpers.Point(6, 10), sim_agent.belief_state.location) # TODO This will change when we add update_previous_belief logic # Add logic to check that agent.results were updated self.assertEqual([], sim_agent.belief_history)
def test_orientation(self): # Test colinear p = geometry_helpers.Point(1, 1) q = geometry_helpers.Point(2, 2) r = geometry_helpers.Point(3, 3) self.assertEqual(geometry_helpers.orientation(p, r, q), 0) # Test clockwise p = geometry_helpers.Point(1, 1) q = geometry_helpers.Point(4, 2) r = geometry_helpers.Point(3, 3) self.assertEqual(geometry_helpers.orientation(p, r, q), 1) # Test counter-clockwise p = geometry_helpers.Point(1, 1) q = geometry_helpers.Point(4, 5) r = geometry_helpers.Point(3, 3) self.assertEqual(geometry_helpers.orientation(p, r, q), 2)
def test_inside_area(self): # q clearly inside area of line pr p = geometry_helpers.Point(1, 1) r = geometry_helpers.Point(3, 3) q = geometry_helpers.Point(2, 2) self.assertTrue(geometry_helpers.inside_area(p, q, r)) # q clearly outside area of line pr p = geometry_helpers.Point(1, 1) r = geometry_helpers.Point(3, 3) q = geometry_helpers.Point(5, 5) self.assertFalse(geometry_helpers.inside_area(p, q, r)) # q on edge of area of line pr p = geometry_helpers.Point(1, 1) r = geometry_helpers.Point(3, 3) q = geometry_helpers.Point(1, 3) self.assertTrue(geometry_helpers.inside_area(p, q, r))
def test_distance(self): # Test straight horizontal line p1 = geometry_helpers.Point(1, 1) p2 = geometry_helpers.Point(4, 1) self.assertEqual(3, geometry_helpers.distance(p1, p2)) # Test straight vertical line p1 = geometry_helpers.Point(1, 1) p2 = geometry_helpers.Point(1, 4) self.assertEqual(3, geometry_helpers.distance(p1, p2)) # Test positive horizontal line p1 = geometry_helpers.Point(1, 1) p2 = geometry_helpers.Point(4, 4) self.assertEqual(4.242640687119285, geometry_helpers.distance(p1, p2)) # Test negative horizontal line p1 = geometry_helpers.Point(1, 1) p2 = geometry_helpers.Point(-2, -2) self.assertEqual(4.242640687119285, geometry_helpers.distance(p1, p2))
def test_LRTA_star_cost(self): # Test without state prev_state = geometry_helpers.Point(1, 1) action = geometry_helpers.Point(3, 1) state = None cost_estimates = {geometry_helpers.Point(3, 1): 2, geometry_helpers.Point(1, 1): 4} goal_point = geometry_helpers.Point(5, 1) a = agent.Agent(goal_point, None, None) self.assertEqual(4, a.LRTA_star_cost(prev_state, action, state, cost_estimates, goal_point)) # Test with state state = geometry_helpers.Point(3, 1) self.assertEqual(4, a.LRTA_star_cost(prev_state, action, state, cost_estimates, goal_point))
def test_obstacle_inside_area(self): # Test obstacle clearly inside area p = geometry_helpers.Point(23, 9) r = geometry_helpers.Point(6, 10) O = environment_details.rectangle1 self.assertTrue(geometry_helpers.obstacle_inside_area(p, r, O)) # Test obstacle clearly outside area p = geometry_helpers.Point(26, 9) r = geometry_helpers.Point(23, 9) O = environment_details.rectangle2 self.assertFalse(geometry_helpers.obstacle_inside_area(p, r, O)) # Test obstacle on edge of area p = geometry_helpers.Point(19, 7) r = geometry_helpers.Point(18, 10) O = environment_details.rectangle1 self.assertTrue(geometry_helpers.obstacle_inside_area(p, r, O))
def test_actions(self): # Redundant since this only makes a call to visible_vertices, so only # test a subset of visible_vertices tests for a sanity check. # Test upper-right corner (open space) state = geometry_helpers.Point(34, 22) self.assertEqual( set([ geometry_helpers.Point(32, 23), geometry_helpers.Point(35, 21) ]), set(percepts.actions(state))) # Test lower-left corner (open space) state = geometry_helpers.Point(5, 1) self.assertEqual( set([ geometry_helpers.Point(5, 20), geometry_helpers.Point(6, 2), geometry_helpers.Point(6, 10), geometry_helpers.Point(18, 2) ]), set(percepts.actions(state))) # Test far-right vertex of pentagon state = geometry_helpers.Point(12, 19) self.assertEqual( set([ geometry_helpers.Point(8.5, 23), geometry_helpers.Point(14.5, 21), geometry_helpers.Point(10, 14), geometry_helpers.Point(13, 14) ]), set(percepts.actions(state))) # Test top of triangle1 (on triangle) state = geometry_helpers.Point(14.5, 21) self.assertEqual( set([ geometry_helpers.Point(13, 14), geometry_helpers.Point(16, 14), geometry_helpers.Point(18.5, 23), geometry_helpers.Point(16.5, 21.5), geometry_helpers.Point(10, 14), geometry_helpers.Point(16, 17), geometry_helpers.Point(12, 19), geometry_helpers.Point(8.5, 23), geometry_helpers.Point(19, 7), geometry_helpers.Point(18, 10) ]), set(percepts.actions(state)))
def test_update_uncertain(self): possible_locations = [geometry_helpers.Point(6, 10), geometry_helpers.Point(35, 21)] obstacles = environment_details.visible_obstacles goal = geometry_helpers.Point(34, 22) sim_agent = agent.Agent(goal, None, obstacles) sim_agent.prev_state = agent.State(geometry_helpers.Point(6, 2), 1) sim_agent.prev_action = geometry_helpers.Point(6, 10) sim_agent.prev_result = {} sim_agent.prev_cost_estimates = {} sim_agent.belief_history = [[agent.State(geometry_helpers.Point(5, 3), 0.8)]] # Agent is initially uncertain of current location # but is able to refine it sim_agent._update_uncertain(possible_locations) self.assertEqual(geometry_helpers.Point(6, 10), sim_agent.belief_state.location) self.assertEqual([], sim_agent.belief_history) # After refining the current possible locations there are no # possible results, so agent searches back in its history to # find a previous state that fits with the current possibilities. sim_agent.belief_history = [[agent.State(geometry_helpers.Point(35, 21), 0.8), agent.State(geometry_helpers.Point(6, 2), 0.2)]] sim_agent.prev_state = agent.State(geometry_helpers.Point(35, 21), 1) sim_agent._update_uncertain(possible_locations) self.assertEqual(geometry_helpers.Point(6, 10), sim_agent.belief_state.location) self.assertEqual([], sim_agent.belief_history) # Agent once again has to search back in its history to find a # compatible previous state, but this time is still not # certain of its current location afterwards sim_agent.belief_history = [[agent.State(geometry_helpers.Point(35, 21), 0.8), agent.State(geometry_helpers.Point(6, 2), 0.2)]] sim_agent.prev_state = agent.State(geometry_helpers.Point(35, 21), 1) possible_locations.append(geometry_helpers.Point(18, 2)) sim_agent._update_uncertain(possible_locations) self.assertEqual(geometry_helpers.Point(6, 10), sim_agent.belief_state.location) self.assertEqual([[agent.State(geometry_helpers.Point(35, 21), 0.8), agent.State(geometry_helpers.Point(6, 2), 0.2)], [agent.State(geometry_helpers.Point(6, 10), 0.375), agent.State(geometry_helpers.Point(18, 2), 0.3)]], sim_agent.belief_history)
def test_vertices_relative_to_agent(self): visible_obstacles = environment_details.visible_obstacles # Test arbitrary points p = geometry_helpers.Point(5, 5) vertices = [ geometry_helpers.Point(7, 7), geometry_helpers.Point(4, 6), geometry_helpers.Point(5, 3), geometry_helpers.Point(1, 5), geometry_helpers.Point(7, 0) ] self.assertEqual( set([ geometry_helpers.Point(2, 2), geometry_helpers.Point(-1, 1), geometry_helpers.Point(0, -2), geometry_helpers.Point(-4, 0), geometry_helpers.Point(2, -5) ]), set(percepts.vertices_relative_to_agent(vertices, p))) # Test open space in maze near top-left corner p = geometry_helpers.Point(34, 22) vertices = percepts.visible_vertices(p, visible_obstacles) self.assertEqual( set([geometry_helpers.Point(-2, 1), geometry_helpers.Point(1, -1)]), set(percepts.vertices_relative_to_agent(vertices, p))) # Test on hexagon vertex in maze p = geometry_helpers.Point(32, 6) vertices = percepts.visible_vertices(p, visible_obstacles) self.assertEqual( set([ geometry_helpers.Point(-3, -3), geometry_helpers.Point(0, 3), geometry_helpers.Point(3, 15) ]), set(percepts.vertices_relative_to_agent(vertices, p))) # Test open space in maze in between pentagon and triangle p = geometry_helpers.Point(13, 19) vertices = percepts.visible_vertices(p, visible_obstacles) self.assertEqual( set([ geometry_helpers.Point(-1, 0), geometry_helpers.Point(-3, -5), geometry_helpers.Point(-4.5, 4), geometry_helpers.Point(0, -5), geometry_helpers.Point(1.5, 2) ]), set(percepts.vertices_relative_to_agent(vertices, p)))
def test_get_locations(self): visible_obstacles = environment_details.visible_obstacles # Test upper-right corner (open space) p = geometry_helpers.Point(34, 22) vertex_list = percepts.visible_vertices(p, visible_obstacles) agent_vertex_list = percepts.vertices_relative_to_agent(vertex_list, p) self.assertEqual( set([ geometry_helpers.Point(34, 22), geometry_helpers.Point(18, 13) ]), set(percepts.get_locations(agent_vertex_list, visible_obstacles))) # Test upper-left corner above pentagon (open space) p = geometry_helpers.Point(12, 21) vertex_list = percepts.visible_vertices(p, visible_obstacles) agent_vertex_list = percepts.vertices_relative_to_agent(vertex_list, p) self.assertEqual( set([geometry_helpers.Point(12, 21)]), set(percepts.get_locations(agent_vertex_list, visible_obstacles))) # Test lower-right corner of hexagon (on polygon) p = geometry_helpers.Point(32, 6) vertex_list = percepts.visible_vertices(p, visible_obstacles) agent_vertex_list = percepts.vertices_relative_to_agent(vertex_list, p) self.assertEqual( set([geometry_helpers.Point(32, 6)]), set(percepts.get_locations(agent_vertex_list, visible_obstacles))) # Test open space in middle p = geometry_helpers.Point(5, 20) vertex_list = percepts.visible_vertices(p, visible_obstacles) agent_vertex_list = percepts.vertices_relative_to_agent(vertex_list, p) self.assertEqual( set([geometry_helpers.Point(5, 20)]), set(percepts.get_locations(agent_vertex_list, visible_obstacles))) # Test far-left side of pentagon (on polygon) p = geometry_helpers.Point(20, 16) vertex_list = percepts.visible_vertices(p, visible_obstacles) agent_vertex_list = percepts.vertices_relative_to_agent(vertex_list, p) self.assertEqual( set([geometry_helpers.Point(20, 16)]), set(percepts.get_locations(agent_vertex_list, visible_obstacles)))
print('Agent score: {}'.format(sim_agent.score)) remaining_turns -= 1 if not sim_agent.reached_goal: print('Agent failed to find goal in alloted turns.') print('Final agent location: {}'.format(agent_location)) return sim_agent.reached_goal if __name__ == "__main__": if len(sys.argv) < 5: number_of_turns = 250 goal_reward = 1000 goal_point = geom.Point(34, 22) initial_location = geom.Point(5, 5) else: try: number_of_turns = int(sys.argv[1]) goal_reward = int(sys.argv[2]) user_goal = ast.literal_eval(sys.argv[3]) goal_point = geom.Point(user_goal[0], user_goal[1]) user_init = ast.literal_eval(sys.argv[4]) initial_location = geom.Point(user_init[0], user_init[1]) except (ValueError, TypeError) as e: print( 'Usage: python -m learningagent.simulation number_of_turns goal_reward goal_point initial_point' )
def test_on_segment(self): # q clearly on line pr p = geometry_helpers.Point(1, 1) q = geometry_helpers.Point(2, 1) r = geometry_helpers.Point(3, 1) epsilon = 0.01 self.assertTrue(geometry_helpers.on_segment(p, r, q, epsilon)) p = geometry_helpers.Point(1, 1) q = geometry_helpers.Point(2, 2) r = geometry_helpers.Point(3, 3) epsilon = 0.01 self.assertTrue(geometry_helpers.on_segment(p, r, q, epsilon)) p = geometry_helpers.Point(1, 1) q = geometry_helpers.Point(1, 2) r = geometry_helpers.Point(1, 3) epsilon = 0.01 self.assertTrue(geometry_helpers.on_segment(p, r, q, epsilon)) # q clearly outside of line pr p = geometry_helpers.Point(19, 12) q = geometry_helpers.Point(22, 11) r = geometry_helpers.Point(23, 9) epsilon = 0.01 self.assertFalse(geometry_helpers.on_segment(p, r, q, epsilon)) # q on edge of line pr p = geometry_helpers.Point(1, 1) q = geometry_helpers.Point(3, 3) r = geometry_helpers.Point(3, 3) epsilon = 0.01 self.assertTrue(geometry_helpers.on_segment(p, r, q, epsilon))
def test_update_agent_location(self): possible_locations = [geometry_helpers.Point(6, 10)] obstacles = environment_details.visible_obstacles goal = geometry_helpers.Point(34, 22) sim_agent = agent.Agent(goal, None, obstacles) sim_agent.prev_state = None sim_agent.prev_action = geometry_helpers.Point(6, 10) sim_agent.prev_result = {} sim_agent.prev_cost_estimates = {} sim_agent.belief_history = [] # Agent is certain of its current location sim_agent.update_agent_location(possible_locations) self.assertEqual(geometry_helpers.Point(6, 10), sim_agent.belief_state.location) self.assertEqual([], sim_agent.belief_history) # Agent is uncertain of current location and does not # have a previous location for context possible_locations.append(geometry_helpers.Point(18, 2)) sim_agent.update_agent_location(possible_locations) self.assertEqual(geometry_helpers.Point(6, 10), sim_agent.belief_state.location) self.assertEqual([[agent.State(geometry_helpers.Point(6, 10), 0.5), agent.State(geometry_helpers.Point(18, 2), 0.5)]], sim_agent.belief_history) # Agent is uncertain of current location but # has previous state for context sim_agent.prev_state = agent.State(geometry_helpers.Point(6, 2), 0.7) sim_agent.belief_history = [] sim_agent.update_agent_location(possible_locations) self.assertEqual(geometry_helpers.Point(6, 10), sim_agent.belief_state.location) self.assertEqual([[agent.State(geometry_helpers.Point(6, 10), 0.5), agent.State(geometry_helpers.Point(18, 2), 0.5)]], sim_agent.belief_history)
def test_visible_vertices(self): visible_obstacles = environment_details.visible_obstacles # Test upper-right corner (open space) p = geometry_helpers.Point(34, 22) self.assertEqual( set([ geometry_helpers.Point(32, 23), geometry_helpers.Point(35, 21) ]), set(percepts.visible_vertices(p, visible_obstacles))) # Test lower-left corner (open space) p = geometry_helpers.Point(5, 1) self.assertEqual( set([ geometry_helpers.Point(5, 20), geometry_helpers.Point(6, 2), geometry_helpers.Point(6, 10), geometry_helpers.Point(18, 2) ]), set(percepts.visible_vertices(p, visible_obstacles))) # Test bottom-middle (open space) p = geometry_helpers.Point(23, 8) self.assertEqual( set([ geometry_helpers.Point(18, 2), geometry_helpers.Point(19, 7), geometry_helpers.Point(23, 9), geometry_helpers.Point(27, 11), geometry_helpers.Point(29, 12), geometry_helpers.Point(29, 3), geometry_helpers.Point(26, 9), geometry_helpers.Point(26, 6) ]), set(percepts.visible_vertices(p, visible_obstacles))) # Test bottom-middle (on triangle) p = geometry_helpers.Point(23, 9) self.assertEqual( set([ geometry_helpers.Point(18, 2), geometry_helpers.Point(19, 7), geometry_helpers.Point(19, 12), geometry_helpers.Point(26, 6), geometry_helpers.Point(16, 17), geometry_helpers.Point(22, 11), geometry_helpers.Point(26, 9), geometry_helpers.Point(27, 11) ]), set(percepts.visible_vertices(p, visible_obstacles))) # Test far-right vertex of pentagon p = geometry_helpers.Point(12, 19) self.assertEqual( set([ geometry_helpers.Point(8.5, 23), geometry_helpers.Point(14.5, 21), geometry_helpers.Point(10, 14), geometry_helpers.Point(13, 14) ]), set(percepts.visible_vertices(p, visible_obstacles))) # Test bottom of quadrilateral (on vertex) p = geometry_helpers.Point(32, 11) self.assertEqual( set([ geometry_helpers.Point(29, 12), geometry_helpers.Point(32, 9), geometry_helpers.Point(27, 23), geometry_helpers.Point(29, 21), geometry_helpers.Point(35, 21) ]), set(percepts.visible_vertices(p, visible_obstacles))) # Test upper-left corner of rectangle2 p = geometry_helpers.Point(22, 23) self.assertEqual( set([ geometry_helpers.Point(27, 23), geometry_helpers.Point(22, 11), geometry_helpers.Point(18.5, 23), geometry_helpers.Point(21, 20), geometry_helpers.Point(18, 10), geometry_helpers.Point(19, 12) ]), set(percepts.visible_vertices(p, visible_obstacles))) # Test top of triangle1 (on triangle) p = geometry_helpers.Point(14.5, 21) self.assertEqual( set([ geometry_helpers.Point(13, 14), geometry_helpers.Point(16, 14), geometry_helpers.Point(18.5, 23), geometry_helpers.Point(16.5, 21.5), geometry_helpers.Point(10, 14), geometry_helpers.Point(16, 17), geometry_helpers.Point(12, 19), geometry_helpers.Point(8.5, 23), geometry_helpers.Point(19, 7), geometry_helpers.Point(18, 10) ]), set(percepts.visible_vertices(p, visible_obstacles)))
def test_do_instersect(self): # sanity check - bottom-left rectangle p1 = geometry_helpers.Point(18, 10) q1 = geometry_helpers.Point(18, 2) p2 = geometry_helpers.Point(6, 10) q2 = geometry_helpers.Point(18, 10) self.assertTrue(geometry_helpers.do_intersect(p1, q1, p2, q2)) # sanity check - bottom-right hexagon p1 = geometry_helpers.Point(29, 12) q1 = geometry_helpers.Point(32, 9) p2 = geometry_helpers.Point(32, 6) q2 = geometry_helpers.Point(32, 9) self.assertTrue(geometry_helpers.do_intersect(p1, q1, p2, q2)) # test bottom-middle triangle to upper-left pentagon p1 = geometry_helpers.Point(19, 7) q1 = geometry_helpers.Point(10, 14) p2 = geometry_helpers.Point(18, 10) q2 = geometry_helpers.Point(18, 2) self.assertTrue(geometry_helpers.do_intersect(p1, q1, p2, q2)) # test bottom-right hexagon to top-middle rectangle p1 = geometry_helpers.Point(26, 9) q1 = geometry_helpers.Point(29, 12) p2 = geometry_helpers.Point(27, 23) q2 = geometry_helpers.Point(27, 11) self.assertFalse(geometry_helpers.do_intersect(p1, q1, p2, q2))
def test_perform_action(self): # TODO Beef up these tests after we add random failure logic action = geometry_helpers.Point(1, 1) self.assertEqual(action, percepts.perform_action(action))