Update README.md

README.md

@@ -1,48 +1,43 @@
-from itertools import product, chain
-import math
-import matplotlib.pyplot as plt
 import numpy as np
-import networkx as nx
-import cv2
-im = cv2.imread("/kaggle/working/black.png")
-im = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) 
-
-h, w = im.shape # Get height and width of image
-
-# Add only those nodes which are black to graph
-nodes = [(i, j) for (i, j) in product(range(h), range(w)) if im[i, j] == 0]
-g = nx.Graph(nodes)
-
-# For each node there can be 8 neighbours, if you consider diagonal as well.
-def get_neighbors(node):
-    box_coords = product([-1, 0, 1], [-1, 0, 1])
-    nns = []
-    for coord in box_coords:
-        if coord[0] != coord[1]:
-            nn = (node[0] - coord[0], node[1] - coord[1])
-            nns.append(nn)
-    return nns
-
-# A point will be a neighbour if it is black as well and is in image bounds
-neighbors = list(chain.from_iterable([[(node, ng_node, 1) for ng_node in  get_neighbors(node) if (im[node] == 0) and (0 < ng_node[0] < h) and (0 < ng_node[1] , w)] for node in nodes]))
-
-g.add_weighted_edges_from(neighbors)
-
-# In image loaded above (0, 0) is top left point. To keep things little more generic. I select point closest to (0, 0) as start and furthest as end.
-
-min_pt = min(nodes, key=lambda x: math.hypot(x[0], x[1]))
-max_pt = max(nodes, key=lambda x: math.hypot(x[0], x[1]))
-
-# Now we can just use networkx to find path between two points
-path = nx.shortest_path(g, source=min_pt, target=max_pt)
-
-# Get new image with only shortest path
-im2 = 255*np.ones_like(im)
-# Draw the path on the original image before saving
-# Draw the path on the original image with white color
-for i in range(len(path)-1):
-    cv2.line(im, path[i], path[i+1], color=(255), thickness=1)
-
-cv2.imwrite('image_with_path.png', im)
-plt.figure(figsize=(10, 10))
-plt.imshow(im, cmap='gray')
+import heapq
+
+def heuristic(a, b):
+    return np.sqrt((b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2)
+
+def astar(array, start, goal):
+    neighbors = [(0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
+    close_set = set()
+    came_from = {}
+    gscore = {start: 0}
+    fscore = {start: heuristic(start, goal)}
+    open_heap = [(fscore[start], start)]
+    array_shape = array.shape
+    array_get = array.__getitem__
+
+    while open_heap:
+        current_fscore, current = heapq.heappop(open_heap)
+
+        if current == goal:
+            path = []
+            while current in came_from:
+                path.append(current)
+                current = came_from[current]
+            return path[::-1]
+
+        close_set.add(current)
+        for i, j in neighbors:
+            neighbor = current[0] + i, current[1] + j
+
+            if 0 <= neighbor[0] < array_shape[0] and 0 <= neighbor[1] < array_shape[1]:
+                if array_get(neighbor) == 1 or neighbor in close_set:
+                    continue  # Skip obstacles and already visited nodes
+
+                tentative_g_score = gscore[current] + heuristic(current, neighbor)
+
+                if tentative_g_score < gscore.get(neighbor, float('inf')):
+                    came_from[neighbor] = current
+                    gscore[neighbor] = tentative_g_score
+                    fscore[neighbor] = tentative_g_score + heuristic(neighbor, goal)
+                    heapq.heappush(open_heap, (fscore[neighbor], neighbor))
+
+    return None  # No path found