Port tuples to Point class

twitu · twitu · commit 66abcfab2d81 · 2019-08-10T01:44:37.000+05:30
diff --git a/helper.py b/helper.py
@@ -1,7 +1,7 @@
-import next_moves
-
 from itertools import tee
 
+from moves import adjacent_octile
+
 
 def pairwise(iterable):
     "s -> (s0,s1), (s1,s2), (s2, s3), ..."
@@ -24,7 +24,7 @@ def get_next_positions(point, moves):
 
 def get_neighbors(point, map_size):
     m, n = map_size
-    octile_moves = next_moves.adjacent_octile()
+    octile_moves = adjacent_octile()
     nbors = get_next_positions(point, octile_moves)
 
     def is_valid(point):
@@ -33,3 +33,21 @@ def is_valid(point):
 
     selected_nbors = [point for point in nbors if is_valid(point)]
     return selected_nbors
+
+
+def get_x_and_y_from_store(store):
+    x, y = [], []
+    for key in store.keys():
+        x.append(key.x)
+        y.append(key.y)
+
+    return x, y
+
+
+def get_x_and_y_from_path(path):
+    x, y = [], []
+    for key in path:
+        x.append(key.x)
+        y.append(key.y)
+
+    return x, y
diff --git a/main.py b/main.py
@@ -1,25 +1,24 @@
+from timeit import default_timer as timer
+
 import map_generator
-import potential
-import numpy as np
-from movement_cost import linear_cost, randomized_cost
+from movement_cost import linear_cost
+from moves import adjacent_linear
 from path_finding import PathFinder
-from terrain_analysis import TerrainAnalyzer
-from next_moves import adjacent_linear
-from timeit import default_timer as timer
+from point import Point
 
 map_data = None
 
 
 def is_valid_pos(cur_pos):
-    x, y = cur_pos
+    x, y = cur_pos.x, cur_pos.y
     return 0 <= x < 100 and 0 <= y < 100 and map_data[y][x]
 
 
 if __name__ == "__main__":
     map_data = map_generator.generate_map(100, 100, seed=25, obstacle_density=0.35)
-    start = (59, 45)
-    mid = (0, 0)
-    end = (86, 40)
+    start = Point(59, 45)
+    mid = Point(0, 0)
+    end = Point(86, 40)
     waypoints = [start, mid, end]
     moves = adjacent_linear()
     cost_func = linear_cost()
@@ -28,11 +27,11 @@ def is_valid_pos(cur_pos):
     path, store = path_finder.find_path_waypoints(moves, waypoints, return_store=True)
     print(timer() - start)
     map_generator.view_path(map_data, path, store)
-    start = timer()
-    potn = potential.manhattan(map_data)
-    print(timer() - start)
-    potential.view_potential(potn)
-    start = timer()
-    terrainer = TerrainAnalyzer(map_data)
-    print(timer() - start)
-    terrainer.view_terrain(True)
+    # start = timer()
+    # potn = potential.manhattan(map_data)
+    # print(timer() - start)
+    # potential.view_potential(potn)
+    # start = timer()
+    # terrainer = TerrainAnalyzer(map_data)
+    # print(timer() - start)
+    # terrainer.view_terrain(True)
diff --git a/map_generator.py b/map_generator.py
@@ -1,3 +1,6 @@
+from helper import get_x_and_y_from_store
+from helper import get_x_and_y_from_path
+
 import matplotlib.pyplot as plt
 import numpy as np
 import perlin
@@ -31,18 +34,18 @@ def view_path(map_data, path, store=None, grid=True, markers=False):
     """
     # plot all the points in the store
     if store:
-        x, y = tuple(zip(*store.keys()))
+        x, y = get_x_and_y_from_store(store)
         plt.scatter(x, y, color='orange')
     # plot all the points in the path
     if path:
         start = path[0]
         end = path[-1]
-        x, y = tuple(zip(*path))
+        x, y = get_x_and_y_from_path(path)
         plt.plot(x, y, color='blue')
         if markers:
             plt.scatter(x, y, color='green')
-        plt.plot(start[0], start[1], 'gx')
-        plt.plot(end[0], end[1], 'rx')
+        plt.plot(start.x, start.y, 'gx')
+        plt.plot(end.x, end.y, 'rx')
         view_map(map_data, grid)
     else:
         print("Empty path")
diff --git a/movement_cost.py b/movement_cost.py
@@ -16,8 +16,8 @@ def linear_cost(scale=1):
     """
 
     def cost(start, end):
-        delta_x = abs(start[0] - end[0])
-        delta_y = abs(start[1] - end[1])
+        delta_x = abs(start.x - end.x)
+        delta_y = abs(start.y - end.y)
         return (delta_x + delta_y) * scale
 
     return cost
@@ -38,8 +38,8 @@ def euclidean_cost(scale=1):
     """
 
     def cost(start, end):
-        delta_x = abs(start[0] - end[0])
-        delta_y = abs(start[1] - end[1])
+        delta_x = abs(start.x - end.x)
+        delta_y = abs(start.y - end.y)
         return math.sqrt(delta_x * delta_x + delta_y * delta_y) * scale
 
     return cost
@@ -63,8 +63,8 @@ def diagonal_cost(lin=1, diag=1):
     """
 
     def cost(start, end):
-        delta_x = abs(start[0] - end[0])
-        delta_y = abs(start[1] - end[1])
+        delta_x = abs(start.x - end.x)
+        delta_y = abs(start.y - end.y)
         return (delta_x + delta_y) * lin + min(delta_x, delta_y) * (diag - 2 * lin)
 
     return cost
@@ -107,3 +107,4 @@ def cost(start, end):
         return h_func(start, end) * random.normalvariate(mu, sigma)
 
     return cost
+
diff --git a/moves.py b/moves.py
@@ -1,3 +1,5 @@
+from point import Point
+
 import random
 
 
@@ -15,14 +17,14 @@ def adjacent_linear(randomize=False):
             or not
 
     Returns:
-        List (int, int): List of x and y offsets from
+        List (Point): List of point offsets from
         current position
     """
     moves = [
-        (0, 1),
-        (1, 0),
-        (0, -1),
-        (-1, 0)
+        Point(0, 1),
+        Point(1, 0),
+        Point(0, -1),
+        Point(-1, 0)
     ]
 
     if randomize:
@@ -45,18 +47,18 @@ def adjacent_octile(randomize=False):
             or not
 
     Returns:
-        List (int, int): List of x and y offsets from
+        List (Point): List of point offsets from
         current position
     """
     moves = [
-        (0, 1),
-        (1, 0),
-        (0, -1),
-        (-1, 0),
-        (1, 1),
-        (1, -1),
-        (-1, 1),
-        (-1, -1)
+        Point(0, 1),
+        Point(1, 0),
+        Point(0, -1),
+        Point(-1, 0),
+        Point(1, 1),
+        Point(1, -1),
+        Point(-1, 1),
+        Point(-1, -1)
     ]
 
     if randomize:
@@ -81,22 +83,22 @@ def bc19_4_radius(randomize=False):
             or not
 
     Returns:
-        List (int, int): List of x and y offsets from
+        List (Point): List of point offsets from
         current position
     """
     moves = [
-        (0, 1),
-        (1, 0),
-        (0, -1),
-        (-1, 0),
-        (1, 1),
-        (1, -1),
-        (-1, 1),
-        (-1, -1),
-        (2, 0),
-        (0, 2),
-        (0, -2),
-        (-2, 0)
+        Point(0, 1),
+        Point(1, 0),
+        Point(0, -1),
+        Point(-1, 0),
+        Point(1, 1),
+        Point(1, -1),
+        Point(-1, 1),
+        Point(-1, -1),
+        Point(2, 0),
+        Point(0, 2),
+        Point(0, -2),
+        Point(-2, 0)
     ]
 
     if randomize:
@@ -123,38 +125,38 @@ def bc19_9_radius(randomize=False):
             or not
 
     Returns:
-        List (int, int): List of x and y offsets from
+        List (Point): List of point offsets from
         current position
     """
     moves = [
-        (0, 1),
-        (1, 0),
-        (0, -1),
-        (-1, 0),
-        (1, 1),
-        (1, -1),
-        (-1, 1),
-        (-1, -1),
-        (2, 0),
-        (0, 2),
-        (0, -2),
-        (-2, 0),
-        (0, 3),
-        (1, 2),
-        (2, 1),
-        (3, 0),
-        (2, -1),
-        (1, -2),
-        (0, -3),
-        (-1, -2),
-        (-2, -1),
-        (-3, 0),
-        (-2, 1),
-        (-1, 2),
-        (2, 2),
-        (2, -2),
-        (-2, 2),
-        (-2, -2)
+        Point(0, 1),
+        Point(1, 0),
+        Point(0, -1),
+        Point(-1, 0),
+        Point(1, 1),
+        Point(1, -1),
+        Point(-1, 1),
+        Point(-1, -1),
+        Point(2, 0),
+        Point(0, 2),
+        Point(0, -2),
+        Point(-2, 0),
+        Point(0, 3),
+        Point(1, 2),
+        Point(2, 1),
+        Point(3, 0),
+        Point(2, -1),
+        Point(1, -2),
+        Point(0, -3),
+        Point(-1, -2),
+        Point(-2, -1),
+        Point(-3, 0),
+        Point(-2, 1),
+        Point(-1, 2),
+        Point(2, 2),
+        Point(2, -2),
+        Point(-2, 2),
+        Point(-2, -2)
     ]
 
     if randomize:
@@ -177,11 +179,12 @@ def adjacent_linear_directional(up_down=True):
             or left right movement
 
     Returns:
-        List (int, int): List of x and y offsets from
+        List (Point): List of point offsets from
         current position
     """
 
     if up_down:
-        return [(0, 1), (0, -1)]
+        return [Point(0, 1), Point(0, -1)]
     else:
-        return [(1, 0), (-1, 0)]
+        return [Point(1, 0), Point(-1, 0)]
+
diff --git a/path_finding.py b/path_finding.py
@@ -182,7 +182,7 @@ def total_cost(cur_pos, next_pos, end):
             if cur_pos == end:
                 return store  # return store on reaching end
 
-            next_moves = [helper.add_tuple_elements(cur_pos, move) for move in moves]
+            next_moves = [cur_pos + move for move in moves]
             valid_moves = [move for move in next_moves if self.is_valid_move(move)]
             possible_state = [(total_cost(cur_pos, move, end), move) for move in valid_moves]
             valid_state = [(next_score, next_pos) for (next_score, next_pos) in possible_state
@@ -193,3 +193,20 @@ def total_cost(cur_pos, next_pos, end):
                 queue.push((next_score, next_pos))
 
         return {}
+
+    def best_potential_step(self, cur_pos, path=None, range=None):
+        """
+        Finds the point with the best potential score for the next step.
+        If path and range is given, finds the best potential score point
+        within the range of the next step prescribed by path.
+
+        Args:
+            cur_pos Point: current position
+            path List(Point): prescribed path from source to destination
+            range int: cutoff range from points along the path
+
+        Return:
+            Point: best step
+        """
+        return None
+
diff --git a/point.py b/point.py
diff --git a/potential.py b/potential.py
diff --git a/terrain_analysis.py b/terrain_analysis.py
