dataclasses are 🔥

Author: SchwartzCode

PathPlanning/TimeBasedPathPlanning/GridWithDynamicObstacles.py

@@ -1,15 +1,18 @@
+"""
+This file implements a grid with a 3d reservation matrix with dimensions for x, y, and time. There
+is also infrastructure to generate dynamic obstacles that move around the grid. The obstacles' paths
+are stored in the reservation matrix on creation.
+"""
 import numpy as np
 import matplotlib.pyplot as plt
 from enum import Enum
+from dataclasses import dataclass
 
+@dataclass(order=True)
 class Position:
     x: int
     y: int
 
-    def __init__(self, x: int, y: int):
-        self.x = x
-        self.y = y
-
     def as_ndarray(self) -> np.ndarray:
         return np.array([self.x, self.y])
 
@@ -27,14 +30,6 @@ def __sub__(self, other):
             f"Subtraction not supported for Position and {type(other)}"
         )
 
-    def __eq__(self, other):
-        if isinstance(other, Position):
-            return self.x == other.x and self.y == other.y
-        return False
-
-    def __repr__(self):
-        return f"Position({self.x}, {self.y})"
-
 
 class ObstacleArrangement(Enum):
     # Random obstacle positions and movements
@@ -46,7 +41,7 @@ class ObstacleArrangement(Enum):
 class Grid:
     # Set in constructor
     grid_size: np.ndarray
-    grid: np.ndarray
+    reservation_matrix: np.ndarray
     obstacle_paths: list[list[Position]] = []
     # Obstacles will never occupy these points. Useful to avoid impossible scenarios
     obstacle_avoid_points: list[Position] = []
@@ -68,7 +63,7 @@ def __init__(
         self.obstacle_avoid_points = obstacle_avoid_points
         self.time_limit = time_limit
         self.grid_size = grid_size
-        self.grid = np.zeros((grid_size[0], grid_size[1], self.time_limit))
+        self.reservation_matrix = np.zeros((grid_size[0], grid_size[1], self.time_limit))
 
         if num_obstacles > self.grid_size[0] * self.grid_size[1]:
             raise Exception("Number of obstacles is greater than grid size!")
@@ -83,8 +78,8 @@ def __init__(
             for t, position in enumerate(path):
                 # Reserve old & new position at this time step
                 if t > 0:
-                    self.grid[path[t - 1].x, path[t - 1].y, t] = obs_idx
-                self.grid[position.x, position.y, t] = obs_idx
+                    self.reservation_matrix[path[t - 1].x, path[t - 1].y, t] = obs_idx
+                self.reservation_matrix[position.x, position.y, t] = obs_idx
 
     """
     Generate dynamic obstacles that move around the grid. Initial positions and movements are random
@@ -191,7 +186,7 @@ def valid_position(self, position: Position, t: int) -> bool:
             return False
 
         # Check if new position is not occupied at time t
-        return self.grid[position.x, position.y, t] == 0
+        return self.reservation_matrix[position.x, position.y, t] == 0
 
     """
     Returns True if the given position is valid at time t and is not in the set of obstacle_avoid_points

PathPlanning/TimeBasedPathPlanning/SpaceTimeAStar.py

@@ -1,6 +1,9 @@
 """
 Space-time A* Algorithm
     This script demonstrates the Space-time A* algorithm for path planning in a grid world with moving obstacles.
+    This algorithm is different from normal 2D A* in one key way - the cost (often notated as g(n)) is
+    the number of time steps it took to get to a given node, instead of the number of cells it has 
+    traversed. This ensures the path is time-optimal, while respescting any dynamic obstacles in the environment.
 
     Reference: https://www.davidsilver.uk/wp-content/uploads/2020/03/coop-path-AIWisdom.pdf
 """
@@ -15,31 +18,27 @@
 import heapq
 from collections.abc import Generator
 import random
-from functools import total_ordering
+from dataclasses import dataclass
+
 
 # Seed randomness for reproducibility
 RANDOM_SEED = 50
 random.seed(RANDOM_SEED)
 np.random.seed(RANDOM_SEED)
 
-@total_ordering # so the linter will chill about not implementing __gt__, __ge__, etc
+@dataclass(order=True)
 class Node:
     position: Position
     time: int
     heuristic: int
     parent_index: int
 
-    def __init__(
-        self, position: Position, time: int, heuristic: int, parent_index: int
-    ):
-        self.position = position
-        self.time = time
-        self.heuristic = heuristic
-        self.parent_index = parent_index
-
     """
     This is what is used to drive node expansion. The node with the lowest value is expanded next.
     This comparison prioritizes the node with the lowest cost-to-come (self.time) + cost-to-go (self.heuristic)
+    
+    This an __eq__ are overridden because we don't care about parent_index when comparing these; two nodes
+    with the same position, time, and heuristic are equivalent from the search algorithm's perspective.
     """
     def __lt__(self, other: object):
         if not isinstance(other, Node):
@@ -51,9 +50,6 @@ def __eq__(self, other: object):
             return NotImplementedError(f"Cannot compare Node with object of type: {type(other)}")
         return self.position == other.position and self.time == other.time
 
-    def __repr__(self):
-        return f"Node(position={self.position}, time={self.time}, heuristic={self.heuristic}, parent_index={self.parent_index})"
-
 
 class NodePath:
     path: list[Node]