MapManager & command-line interface analogous to algorithm's one (#61)

* Added MapManager and switched to using that rather than Maps

* Reworked map management

Signed-off-by: [ 大鳄 ] Asew <[email protected]>

* Checking for name when updating map

Signed-off-by: [ 大鳄 ] Asew <[email protected]>

Co-authored-by: [ 大鳄 ] Asew <[email protected]>

Author: Nabushika

src/algorithms/algorithm_manager.py

@@ -1,5 +1,6 @@
 from algorithms.algorithm import Algorithm
 from utility.compatibility import HAS_OMPL
+from utility.misc import static_class
 
 from typing import Optional, List, Type, Dict, Any, Tuple
 import importlib.util
@@ -75,11 +76,6 @@
     from algorithms.classic.sample_based.ompl_stride import OMPL_STRIDE
     from algorithms.classic.sample_based.ompl_qrrt import OMPL_QRRT
 
-def static_class(cls):
-    if getattr(cls, "_static_init_", None):
-        cls._static_init_()
-    return cls
-
 @static_class
 class AlgorithmManager():
     MetaData = Tuple[Type[Algorithm], Type[BasicTesting], Tuple[List[Any], Dict[str, Any]]]

src/algorithms/configuration/configuration.py

@@ -112,6 +112,9 @@ def __init__(self) -> None:
         from algorithms.algorithm_manager import AlgorithmManager
         self.algorithms = copy.deepcopy(AlgorithmManager.builtins)
 
+        from maps.map_manager import MapManager
+        self.maps = copy.deepcopy(MapManager.builtins)
+
         self.map_name = None
         self.algorithm_name = None
 

src/algorithms/configuration/maps/dense_map.py

@@ -28,7 +28,7 @@ class DenseMap(Map):
     # The transpose flag is set to true as a default for the initialization, as that is
     # how we are storing internally, but it will be set to false when we are simply translating from sparsemap
     # When we create more map views, we should set it to false
-    def __init__(self, grid: Optional[List] = None, services: Services = None, transpose: bool = True, mutable: bool = False) -> None:
+    def __init__(self, grid: Optional[List] = None, services: Services = None, transpose: bool = True, mutable: bool = False, name: Optional[str] = None) -> None:
         self.grid = None
 
         arr_grid = None
@@ -37,9 +37,9 @@ def __init__(self, grid: Optional[List] = None, services: Services = None, trans
             if arr_grid.dtype == object:
                 raise ValueError("Cannot create DenseMap grid from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes)")
 
-            super().__init__(Size(*([0]*arr_grid.ndim)), services, mutable)
+            super().__init__(Size(*([0]*arr_grid.ndim)), services, mutable, name)
         else:
-            super().__init__(services=services, mutable=mutable)
+            super().__init__(services=services, mutable=mutable, name=name)
             return
 
         # Doesn't work with non-uniform grids
@@ -186,6 +186,7 @@ def __copy__(self) -> 'DenseMap':
 
     def __deepcopy__(self, memo: Dict) -> 'DenseMap':
         dense_map = self.__class__(copy.deepcopy(self.grid), services=self.services, transpose=False)
+        dense_map.name = copy.deepcopy(self.name)
         dense_map.trace = copy.deepcopy(self.trace)
         dense_map.agent = copy.deepcopy(self.agent)
         dense_map.goal = copy.deepcopy(self.goal)

src/algorithms/configuration/maps/map.py

@@ -30,6 +30,7 @@ class Map:
     EXTENDED_WALL_ID: int = 4
     UNMAPPED_ID: int = 5
 
+    name: Optional[str]
     agent: Agent
     goal: Goal
     obstacles: List[Obstacle]
@@ -93,7 +94,7 @@ def init_direction_vectors(self):
         self.DIRECT_POINTS_MOVE_VECTOR: List[Point] = \
             list(map(lambda x: Point(*x), ALL_DIRECT_POINTS_DIMENSIONS))
 
-    def __init__(self, size: Size = None, services: Services = None, mutable: bool = False) -> None:
+    def __init__(self, size: Size = None, services: Services = None, mutable: bool = False, name: Optional[str] = None) -> None:
         """
         :param size: The map size
         :param services: The simulator services
@@ -106,6 +107,7 @@ def __init__(self, size: Size = None, services: Services = None, mutable: bool =
         self._size = None
         self.size = size
         self.__mutable = mutable
+        self.name = name
 
     def get_obstacle_bound(self, obstacle_start_point: Point, visited: Optional[Set[Point]] = None) -> Set[Point]:
         """

src/algorithms/configuration/maps/occupancy_grid_map.py

@@ -37,8 +37,9 @@ def __init__(self,
                  traversable_threshold: Optional[Real] = None,
                  unmapped_value: Optional[Real] = None,
                  services: Services = None,
-                 mutable: bool = True) -> None:
-        super().__init__(services=services, mutable=mutable)
+                 mutable: bool = True,
+                 name: Optional[str] = None) -> None:
+        super().__init__(services=services, mutable=mutable, name=name)
         self.agent = agent
         self.goal = goal
         self.weight_grid = None
@@ -200,7 +201,8 @@ def __deepcopy__(self, memo: Dict) -> 'OccupancyGridMap':
         mp = self.__class__(agent=copy.deepcopy(self.agent),
                             goal=copy.deepcopy(self.goal),
                             services=self.services,
-                            mutable=self.mutable)
+                            mutable=self.mutable,
+                            name=copy.deepcopy(self.name))
         mp.size = copy.deepcopy(self.size)
         mp.traversable_threshold = copy.deepcopy(self.traversable_threshold)
         mp.weight_grid = copy.deepcopy(self.weight_grid)

src/algorithms/configuration/maps/ros_map.py

@@ -24,8 +24,9 @@ def __init__(self, agent: Agent, goal: Goal,
                  wp_publish: Optional[Callable[[Point], None]] = None,
                  update_requested: Optional[Callable[[], None]] = None,
                  services: Services = None,
-                 mutable: bool = True) -> None:
-        super().__init__(agent=agent, goal=goal, services=services, mutable=mutable)
+                 mutable: bool = True,
+                 name: Optional[str] = None) -> None:
+        super().__init__(agent=agent, goal=goal, services=services, mutable=mutable, name=name)
 
         self.__get_grid = get_grid
         self.__wp_publish = wp_publish
@@ -53,7 +54,7 @@ def __deepcopy__(self, memo: Dict) -> 'RosMap':
         mp = RosMap(copy.deepcopy(self.agent), copy.deepcopy(self.goal),
                     self.__get_grid, self.__weight_bounds, self.__traversable_threshold, self.__unmapped_value,
                     self.__wp_publish, self.__update_requested,
-                    self.services, self.mutable)
+                    self.services, self.mutable, copy.deepcopy(self.name))
         mp.size = copy.deepcopy(self.size)
         mp.weight_grid = copy.deepcopy(self.weight_grid)
         mp.traversable_threshold = copy.deepcopy(self.traversable_threshold)

src/algorithms/configuration/maps/sparse_map.py

@@ -22,9 +22,9 @@ class SparseMap(Map):
 
     DIST_TOLERANCE = 0.0001
 
-    def __init__(self, size: Size, agent: Agent, obstacles: List[Obstacle], goal: Goal, services: Services = None, mutable: bool = False) \
+    def __init__(self, size: Size, agent: Agent, obstacles: List[Obstacle], goal: Goal, services: Services = None, mutable: bool = False, name: Optional[str] = None) \
             -> None:
-        super().__init__(size, services, mutable)
+        super().__init__(size, services, mutable, name)
         self.agent = agent
         self.obstacles = obstacles
         self.goal = goal
@@ -118,8 +118,13 @@ def __copy__(self) -> 'SparseMap':
         return copy.deepcopy(self)
 
     def __deepcopy__(self, memo: Dict) -> 'SparseMap':
-        dense_map = SparseMap(self.size, copy.deepcopy(self.agent),
-                              copy.deepcopy(self.obstacles), copy.deepcopy(self.goal), self.services)
+        dense_map = SparseMap(self.size,
+                              copy.deepcopy(self.agent),
+                              copy.deepcopy(self.obstacles),
+                              copy.deepcopy(self.goal),
+                              self.services,
+                              self.mutable,
+                              copy.deepcopy(self.name))
         dense_map.trace = copy.deepcopy(self.trace)
         return dense_map
 

src/analyzer/analyzer.py

@@ -11,7 +11,6 @@
 from algorithms.basic_testing import BasicTesting
 from algorithms.algorithm import Algorithm
 from structures import Point
-from maps import Maps
 
 from io import StringIO
 import seaborn as sns

src/main.py

@@ -1,5 +1,6 @@
 from algorithms.configuration.configuration import Configuration
 from algorithms.algorithm_manager import AlgorithmManager
+from maps.map_manager import MapManager
 from algorithms.lstm.trainer import Trainer
 from analyzer.analyzer import Analyzer
 from generator.generator import Generator
@@ -151,7 +152,7 @@ def configure_common(config, args) -> bool:
         print("Available algorithms:")
         for key in AlgorithmManager.builtins.keys():
             print(f"  {key}")
-        print("Or specify your own file with a class that inherits from Algorithm")
+        print("Or specify your own file that contains a class that inherits from Algorithm")
         sys.exit(0)
 
     if args.algorithms:
@@ -162,7 +163,7 @@ def configure_common(config, args) -> bool:
             valid_str = ",".join('"' + a + '"' for a in AlgorithmManager.builtins.keys())
             print(f"Invalid algorithm(s) specified: {invalid_str}", file=sys.stderr)
             print(f"Available algorithms: {valid_str}", file=sys.stderr)
-            print("Or specify your own file with a class that inherits from Algorithm", file=sys.stderr)
+            print("Or specify your own file that contains a class that inherits from Algorithm", file=sys.stderr)
             return False
 
         algorithms = list(flatten(algorithms, depth=1))
@@ -179,6 +180,46 @@ def configure_common(config, args) -> bool:
 
         config.algorithms = algorithms
 
+    if args.list_maps:
+        print("Available maps:")
+        for key in MapManager.builtins.keys():
+            print(f"  {key}")
+        print("Can also specify a custom map,")
+        print("  (1) cached map stored in Maps")
+        print("  (2) external file that contains a global variable with type that inherits from Map")
+        sys.exit(0)
+
+    if args.maps:
+        maps = MapManager.load_all(args.maps)
+        if not all(maps):
+            invalid_maps = [args.maps[i] for i in range(len(maps)) if not maps[i]]
+            invalid_str = ",".join('"' + a + '"' for a in invalid_maps)
+            valid_str = ",".join('"' + a + '"' for a in MapManager.builtins.keys())
+            print(f"Invalid map(s) specified: {invalid_str}", file=sys.stderr)
+            print(f"Available maps: {valid_str}", file=sys.stderr)
+            print("Can also specify a custom map,", file=sys.stderr)
+            print("  (1) cached map stored in Maps", file=sys.stderr)
+            print("  (2) external file that contains a global variable with type that inherits from Map", file=sys.stderr)
+            return False
+
+        maps = list(flatten(maps, depth=1))
+
+        # name uniqueness
+        names = [a[0] for a in maps]
+        if len(set(names)) != len(names):
+            print("Name conflict detected in custom map list:", names, file=sys.stderr)
+            return False
+
+        maps = dict(maps)
+        if args.include_default_builtin_maps or args.include_all_builtin_maps:
+            maps.update(MapManager.builtins)
+        if args.include_all_builtin_maps:
+            maps.update(MapManager.cached_builtins)
+
+        config.maps = maps
+    elif args.include_all_builtin_maps:
+        config.maps.update(MapManager.cached_builtins)
+
     if args.deterministic:
         random.seed(args.std_random_seed)
         torch.manual_seed(args.torch_random_seed)
@@ -225,9 +266,17 @@ def main() -> bool:
     parser.add_argument("--dims", type=int, help="[generator|analyzer] number of dimensions", default=3)
 
     parser.add_argument("--algorithms", help="[visualiser|analyzer] algorithms to load (either built-in algorithm name or module file path)", nargs="+")
-    parser.add_argument("--include-builtin-algorithms", action='store_true', help="include all builtin algorithms even when a custom list is provided via '--algorithms'")
+    parser.add_argument("--include-builtin-algorithms", action='store_true',
+                        help="[visualiser|analyzer] include all builtin algorithms even when a custom list is provided via '--algorithms'")
     parser.add_argument("--list-algorithms", action="store_true", help="[visualiser|analyzer] output list of available built-in algorithms")
 
+    parser.add_argument("--maps", help="[visualiser|analyzer|trainer] maps to load (either built-in map name or module file path)", nargs="+")
+    parser.add_argument("--include-all-builtin-maps", action='store_true',
+                        help="[visualiser|analyzer|trainer] include all builtin maps (includes all cached maps) even when a custom list is provided via '--maps'")
+    parser.add_argument("--include-default-builtin-maps", action='store_true',
+                        help="[visualiser|analyzer|trainer] include default builtin maps (does not include all cached maps) even when a custom list is provided via '--maps'")
+    parser.add_argument("--list-maps", action="store_true", help="[visualiser|analyzer|trainer] output list of available built-in maps")
+
     parser.add_argument("--deterministic", action='store_true', help="use pre-defined random seeds for deterministic exeuction")
     parser.add_argument("--std-random-seed", type=int, default=0, help="'random' module random number generator seed")
     parser.add_argument("--numpy-random-seed", type=int, default=0, help="'numpy' module random number generator seed")