def test_start_successors(self):
"""
Test that a starting node produces all neighbors of it as successors.
"""
expected = {JPSNode(Coord(0, 3), Coord(0, 1))}
actual = self.jps.successors(JPSNode(Coord(0, 0), None), Coord(0, 3))
self.assertEqual(expected, actual)
def test_diagonal_obstacle(self):
expected = [
JPSNode(Coord(0, 0), None),
JPSNode(Coord(2, 2), Coord(1, 1)),
JPSNode(Coord(3, 3), Coord(1, 1))
]
diagonal_obstacle_grid = DiagonalGrid(4, 4, [Coord(2, 1)])
obstacle_jps = JumpPointSearch(diagonal_obstacle_grid, diagonal)
path = obstacle_jps.execute((Coord(0, 0), Coord(3, 3)))
self.assertEqual(expected, path,
coordinate_mismatch_message(expected, path))
def test_obstacle_execute(self):
expected = [
JPSNode(Coord(0, 0), None),
JPSNode(Coord(1, 1), Coord(1, 1)),
JPSNode(Coord(1, 2), Coord(0, 1)),
JPSNode(Coord(0, 3), Coord(-1, 1))
]
obstacle_jps = JumpPointSearch(self.obstacle_grid, diagonal)
path = obstacle_jps.execute((Coord(0, 0), Coord(0, 3)))
self.assertEqual(expected, path,
coordinate_mismatch_message(expected, path))
def test_forced_diagonal(self):
obstacle_grid = DiagonalGrid(4, 4, [Coord(2, 1)])
diag_jps = JumpPointSearch(obstacle_grid, diagonal)
expected = Coord(3, 1)
current = JPSNode(Coord(2, 2), Coord(1, 1))
neighbors = set(
diag_jps.forced_neighbors(current.coord, current.direction))
self.assertTrue(expected in neighbors)
def _raw_execute(self, start, goal):
start_node = JPSNode(start, None, 0, self.heuristic_fn(start, goal))
open_set = JPSHashHeap()
open_set.add(start_node)
jump_points = []
while len(open_set) > 0 and open_set.top().coord != goal:
current = open_set.pop()
jump_points.append(current)
for successor in self.successors(current, goal):
open_set.add(successor)
return jump_points + [open_set.top()]
def successors(self, current: JPSNode, goal: Coord):
"""
Finds jump point successors of current JPSNode.
:param current:
:param goal:
:return: A set of successors, including empty set if no successors are found.
"""
succ = set()
neighbors = self.prune(current)
parent_x, parent_y = current.coord.x, current.coord.y
for neighbor in neighbors:
dir_coord = self.direction(current.coord, neighbor)
next_jump_point = self.jump(Coord(parent_x, parent_y),
Coord(dir_coord.x, dir_coord.y), goal)
if next_jump_point is not None:
next_node = JPSNode(next_jump_point, dir_coord)
next_node.g = current.g + STRAIGHT_COST
next_node.f = next_node.g + self.heuristic_fn(
next_node.coord, goal)
succ.add(next_node)
return succ
def test_prune_horizontal_node(self):
expected = {Coord(1, 2)}
current = JPSNode(Coord(1, 1), Coord(0, 1))
neighbors = set(self.jps.prune(current))
self.assertEqual(expected, neighbors)
def test_prune_start_node(self):
expected = {Coord(0, 1)}
current = JPSNode(Coord(0, 0), Coord(0, 1))
neighbors = set(self.jps.prune(current))
self.assertEqual(expected, neighbors)
def test_horizontal_execute(self):
goal = Coord(0, 3)
expected = [JPSNode(Coord(0, 0), None), JPSNode(goal, Coord(0, 1))]
path = self.jps.execute((Coord(0, 0), goal))
self.assertEqual(expected, path)