def calcPath(self, startx, starty, targetx, targety, grid):
start = grid.node(startx, starty)
end = grid.node(targetx, targety)
finder = DijkstraFinder(diagonal_movement=DiagonalMovement.
only_when_no_obstacle) #, heuristic=null)
path, runs = finder.find_path(start, end, grid)
print('operations:', runs, 'path length:', len(path))
#fix path offset
np = []
for tile in path:
np.append([tile[0], tile[1]])
#print(grid.grid_str(path=path, start=start, end=end)
return np
def index():
matrix = request.json['matrix']
start_pos = request.json['start']
end_pos = request.json['end']
finder_name = request.json['finder']
is_diagonal = request.json['isDiagonal']
grid = Grid(matrix=matrix)
start = grid.node(start_pos[0], start_pos[1])
end = grid.node(end_pos[0], end_pos[1])
diagonal_movement = DiagonalMovement.always if is_diagonal else DiagonalMovement.never
finder = None
if finder_name == 'a_star':
finder = AStarFinder(diagonal_movement=diagonal_movement)
elif finder_name == 'breadth_first':
finder = BreadthFirstFinder(diagonal_movement=diagonal_movement)
elif finder_name == 'bi_a_star':
finder = BiAStarFinder(diagonal_movement=diagonal_movement)
elif finder_name == 'best_first':
finder = BestFirst(diagonal_movement=diagonal_movement)
elif finder_name == 'dijkstra':
finder = DijkstraFinder(diagonal_movement=diagonal_movement)
elif finder_name == 'ida_star':
finder = IDAStarFinder(diagonal_movement=diagonal_movement)
path, runs = finder.find_path(start, end, grid)
return jsonify({
"path": path,
"steps": len(path),
"finder_name": finder_name
})
def fill_distances():
if os.path.isfile('day18_distances.txt'):
f = open("day18_distances.txt", "r")
content = f.read()
f.close()
for line in content.split('\n'):
if line != "":
key1, key2, door, keys, distance = line.split(',')
if door == "": door = None
distance = int(distance)
key_combo_distances[(key1, key2)] = (door, keys, distance)
key_combo_distances[(key2, key1)] = (door, keys, distance)
else:
f = open("day18_distances.txt", "w")
finder = DijkstraFinder()
key_combos = combinations(key_locations.keys(), 2)
for key1, key2 in key_combos:
local_map = copy.deepcopy(pathfinding_map)
grid = Grid(matrix=local_map)
key_location1 = key_locations[key1]
key_location2 = key_locations[key2]
start = grid.node(key_location1[0], key_location1[1])
end = grid.node(key_location2[0], key_location2[1])
path, runs = finder.find_path(start, end, grid)
path_len = len(path)
doors_passed = set(door_locations.values()).intersection(path)
doors_opened = ""
for door, door_cord in door_locations.items():
if door_cord in doors_passed:
doors_opened += door
keys_picked_up_str = ""
keys_picked_up = set(key_locations.values()).intersection(path)
for key, key_coord in key_locations.items():
if key_coord in keys_picked_up and key != "@" and key != key1 and key != key2:
keys_picked_up_str += key
print(
"found: {} to {} with doors {} opened and keys picked up: {}".
format(key1, key2, doors_opened, keys_picked_up_str))
f.write(','.join(
[key1, key2, doors_opened, keys_picked_up_str,
str(path_len)]))
f.write('\n')
f.close()
def on_submit_clicked(self):
curr_algorithm = self.current_algorithm.get()
grid = Grid_(matrix=self.matriz)
start = grid.node(self.inicio[1], self.inicio[0])
end = grid.node(self.destino[1], self.destino[0])
for row in self.matriz:
print(row)
if curr_algorithm == "Custo Uniforme":
finder = DijkstraFinder()
elif curr_algorithm == "A*":
finder = AStarFinder()
elif curr_algorithm == "Guloso":
finder = BestFirst()
else:
finder = BreadthFirstFinder()
path, runs = finder.find_path(start, end, grid)
self.draw_path(path[1:-1:], [])
self.update_stats(path, runs)
def findOptimalPath(self, targetPos, matrix, tileSize):
grid = Grid(matrix=matrix)
start = grid.node(floor(self.pos.x / tileSize),
floor(self.pos.y / tileSize))
end = grid.node(floor(targetPos.x / tileSize),
floor(targetPos.y / tileSize))
finder = DijkstraFinder(diagonal_movement=DiagonalMovement.always)
path, runs = finder.find_path(start, end, grid)
if (len(path) <= 3):
self.atNeighboringTile = True
self.isAttacking = True
self.animationDelayFrame = 0
self.animationFrame = 0
else:
self.isAttacking = False
self.isIdle = False
self.atNeighboringTile = False
self.movingTo = pygame.math.Vector2(
(path[1][0] * tileSize) + tileSize / 2,
(path[1][1] * tileSize) + tileSize / 2)
original_cave[original_cave == 10] = 1
extended_cave = np.concatenate((extended_cave, original_cave), axis=1)
original_cave = extended_cave.copy()
for _ in range(4):
original_cave += 1
original_cave[original_cave == 10] = 1
extended_cave = np.concatenate((extended_cave, original_cave), axis=0)
grid = Grid(matrix=extended_cave)
start = grid.node(0, 0)
end = grid.node(len(extended_cave) - 1, len(extended_cave) - 1)
start_time = datetime.now()
finder = DijkstraFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(start, end, grid)
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))
total_risk = 0
for x, y in path[1:]:
total_risk += extended_cave[y][x]
print('operations:', runs, 'path length:', len(path))
#print(grid.grid_str(path=path, start=start, end=end))
print(total_risk)
# print(row)
# print("\n")
# print("start: " + str(start) + ", end: " + str(end) + "\n")
if is_comecar and opcao_selecionada == "comecar" and not finalizado:
grid_procura = Grid(matrix=grid)
start = grid_procura.node(start[1], start[0])
end = grid_procura.node(end[1], end[0])
if metodo == "a_star":
finder = AStarFinder(
diagonal_movement=DiagonalMovement.always)
elif metodo == "guloso":
finder = BestFirst(
diagonal_movement=DiagonalMovement.always)
elif metodo == "dijkstra":
finder = DijkstraFinder(
diagonal_movement=DiagonalMovement.always)
else:
finder = BreadthFirstFinder(
diagonal_movement=DiagonalMovement.always)
start_time = time.time()
path, runs = finder.find_path(start, end, grid_procura)
end_time = time.time()
total_time = end_time - start_time
for no in visitados:
if grid[no.x][no.y] != '0' and [no.x, no.y] != [
start.x, start.y
] and [no.x, no.y] != [end.x, end.y]:
button(Botao.light_blue,
(MARGIN + WIDTH) * no.x + MARGIN,
(MARGIN + HEIGHT) * no.y + MARGIN, WIDTH,
HEIGHT, "").draw(screen)
print(Fore.BLUE + 'E' + ": Fim\n")
print(Fore.RED + 'x' + ": Caminho\n")
print(Fore.YELLOW + '#' + ": Obstaculo\n" + Style.RESET_ALL)
print("A*:")
print('Operações:', runs, 'Tamanho:', len(path))
color_print(grid.grid_str(path=path, start=start, end=end, show_weight=True))
print('\n' + "---//----//-----------//----------//---------//-----")
grid2 = Grid(matrix=matrix)
start = grid2.node(idxStart[0], idxStart[1])
end = grid2.node(idxEnd[0], idxEnd[1])
bfs_finder = BreadthFirstFinder(diagonal_movement=DiagonalMovement.always)
path, runs = bfs_finder.find_path(start, end, grid2)
print("Busca em Largura:")
print('Operações:', runs, 'Tamanho:', len(path))
color_print(grid2.grid_str(path=path, start=start, end=end, show_weight=True))
print('\n' + "---//----//-----------//----------//---------//-----")
grid3 = Grid(matrix=matrix)
start = grid3.node(idxStart[0], idxStart[1])
end = grid3.node(idxEnd[0], idxEnd[1])
dijkstra_finder = DijkstraFinder(diagonal_movement=True)
path, runs = dijkstra_finder.find_path(start, end, grid3)
print("Dijkstra:")
print('Operações:', runs, 'Tamanho:', len(path))
color_print(grid3.grid_str(path=path, start=start, end=end, show_weight=True))
from pathfinding.core.grid import Grid
from pathfinding.finder.dijkstra import DijkstraFinder
# Side of the grid.
x = 100
y = 100
p = 0.8
# Generate map.
obstacles = numpy.random.choice(a=[False, True], size=(x, y), p=[p, 1 - p])
obstacles[0, 0] = False
obstacles[x - 1, y - 1] = False
grid = Grid(matrix=numpy.logical_not(obstacles))
start = grid.node(0, 0)
end = grid.node(x - 1, y - 1)
finder = DijkstraFinder(diagonal_movement=DiagonalMovement.always)
start_time = time.time()
path = pathfinder.dijkstra(obstacles, (0, 0), (x - 1, y - 1))
t = time.time() - start_time
start_time = time.time()
finder.find_path(start, end, grid)
t2 = time.time() - start_time
print(grid.grid_str(path=path, start=(0, 0), end=(x - 1, y - 1)))
print(f"Ext {t*1000:>10f} ms")
print(f"Lib {t2*1000:>10f} ms")