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))
