miniworld-maze 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

miniworld_maze/__init__.py

@@ -15,17 +15,29 @@ Main modules:
 - tools: Observation generation and utilities
 """
 
+import os
+import warnings
+
+# Set PYGLET_HEADLESS=1 by default if not already set
+if "PYGLET_HEADLESS" not in os.environ:
+    os.environ["PYGLET_HEADLESS"] = "1"
+    warnings.warn(
+        "Automatically set PYGLET_HEADLESS=1 for headless rendering. "
+        "Set PYGLET_HEADLESS=0 before importing miniworld_maze to override this behavior.",
+        UserWarning,
+        stacklevel=2
+    )
+
 from .core import ObservationLevel
-from .environments.factory import (
-    NineRoomsEnvironmentWrapper,
-)
 from .environments.nine_rooms import NineRooms
 from .environments.spiral_nine_rooms import SpiralNineRooms
 from .environments.twenty_five_rooms import TwentyFiveRooms
 
-__version__ = "1.0.0"
+# Import factory to register environments
+from .environments import factory  # noqa: F401
+
+__version__ = "1.1.0"
 __all__ = [
-    "NineRoomsEnvironmentWrapper",
     "NineRooms",
     "SpiralNineRooms",
     "TwentyFiveRooms",

miniworld_maze/core/constants.py

@@ -57,23 +57,64 @@ DEFAULT_BENCHMARK_STEPS: Final[int] = 100
 DEFAULT_WARMUP_STEPS: Final[int] = 10
 
 # ========================
-# OBSERVATION TEST POSITIONS
+# TEXTURE THEMES
 # ========================
 
+class TextureThemes:
+    """Pre-defined texture themes for different environments."""
+
+    NINE_ROOMS = [
+        "beige",
+        "lightbeige",
+        "lightgray",
+        "copperred",
+        "skyblue",
+        "lightcobaltgreen",
+        "oakbrown",
+        "navyblue",
+        "cobaltgreen",
+    ]
+
+    SPIRAL_NINE_ROOMS = [
+        "beige",
+        "lightbeige",
+        "lightgray",
+        "copperred",
+        "skyblue",
+        "lightcobaltgreen",
+        "oakbrown",
+        "navyblue",
+        "cobaltgreen",
+    ]
+
+    TWENTY_FIVE_ROOMS = [
+        "crimson",
+        "beanpaste",
+        "cobaltgreen",
+        "lightnavyblue",
+        "skyblue",
+        "lightcobaltgreen",
+        "oakbrown",
+        "copperred",
+        "lightgray",
+        "lime",
+        "turquoise",
+        "violet",
+        "beige",
+        "morningglory",
+        "silver",
+        "magenta",
+        "sunnyyellow",
+        "blueberry",
+        "lightbeige",
+        "seablue",
+        "lemongrass",
+        "orchid",
+        "redbean",
+        "orange",
+        "realblueberry",
+    ]
 
-# Convenient position calculations for standard room layouts
-class RoomPositions:
-    """Pre-calculated positions for standard room layouts."""
-
-    # NineRooms (3x3) strategic positions
-    NINE_ROOMS_CENTER: Final[tuple[float, float, float]] = (22.5, 0.0, 22.5)
-    NINE_ROOMS_TOP_LEFT: Final[tuple[float, float, float]] = (7.5, 0.0, 7.5)
-    NINE_ROOMS_BOTTOM_RIGHT: Final[tuple[float, float, float]] = (37.5, 0.0, 37.5)
-
-    # TwentyFiveRooms (5x5) strategic positions
-    TWENTY_FIVE_CENTER: Final[tuple[float, float, float]] = (75.0, 0.0, 75.0)
-    TWENTY_FIVE_CORNER: Final[tuple[float, float, float]] = (37.5, 0.0, 37.5)
-    TWENTY_FIVE_FAR_CORNER: Final[tuple[float, float, float]] = (112.5, 0.0, 112.5)
 
 
 # ========================

miniworld_maze/core/miniworld_gymnasium/__init__.py

@@ -1,4 +1,4 @@
 # Core module cleaned up - imports removed since files were consolidated
 
 # Import the envs module so that envs register themselves
-from . import envs
+from . import envs as envs

miniworld_maze/core/miniworld_gymnasium/unified_env.py

@@ -332,34 +332,32 @@ class UnifiedMiniWorldEnv(gym.Env):
         self._render_static()
 
         # Generate the first camera image
-        obs = self._generate_observation()
+        obs = self._generate_observation(self.obs_level)
 
         # Generate additional observations for info dictionary if specified
         info = {}
         if self.info_obs is not None:
             for obs_level in self.info_obs:
-                # Temporarily change obs_level to generate the desired observation
-                original_obs_level = self.obs_level
-                self.obs_level = obs_level
-                info_obs = self._generate_observation()
-                self.obs_level = original_obs_level
+                # Generate observation with the specified level
+                info_obs = self._generate_observation(observation_level=obs_level)
                 # Use the observation level name as key
                 info[str(obs_level)] = info_obs
 
         # Return first observation with info dict for Gymnasium compatibility
         return obs, info
 
-    def _generate_observation(self, render_agent: bool = None):
-        """Generate observation based on current observation level.
+    def _generate_observation(self, observation_level, render_agent: bool = None):
+        """Generate observation based on specified observation level.
 
         Args:
+            observation_level: Observation level to use.
             render_agent: Whether to render the agent in the observation.
                          If None, uses default behavior based on observation level.
         """
         # Import ObservationLevel here to avoid circular imports
         from ..observation_types import ObservationLevel
 
-        if self.obs_level == ObservationLevel.TOP_DOWN_PARTIAL:
+        if observation_level == ObservationLevel.TOP_DOWN_PARTIAL:
             if self.agent_mode == "empty":
                 # Agent mode 'empty' always renders without agent
                 render_ag = False
@@ -371,19 +369,19 @@ class UnifiedMiniWorldEnv(gym.Env):
                 render_ag = True
             return self.render_top_view(POMDP=True, render_ag=render_ag)
 
-        elif self.obs_level == ObservationLevel.TOP_DOWN_FULL:
+        elif observation_level == ObservationLevel.TOP_DOWN_FULL:
             # Use explicit render_agent parameter or default to True
             render_ag = render_agent if render_agent is not None else True
             return self.render_top_view(POMDP=False, render_ag=render_ag)
 
-        elif self.obs_level == ObservationLevel.FIRST_PERSON:
+        elif observation_level == ObservationLevel.FIRST_PERSON:
             # First person view doesn't include the agent anyway
             return self.render_obs()
 
         else:
             valid_levels = list(ObservationLevel)
             raise ValueError(
-                f"Invalid obs_level {self.obs_level}. Must be one of {valid_levels}"
+                f"Invalid obs_level {observation_level}. Must be one of {valid_levels}"
             )
 
     def _calculate_carried_object_position(self, agent_pos, ent):
@@ -507,7 +505,7 @@ class UnifiedMiniWorldEnv(gym.Env):
         self._process_action(action)
 
         # Generate observation
-        observation = self._generate_observation()
+        observation = self._generate_observation(self.obs_level)
 
         # Calculate step results
         reward, terminated, info = self._calculate_step_results(observation)
@@ -586,11 +584,8 @@ class UnifiedMiniWorldEnv(gym.Env):
         info = {}
         if self.info_obs is not None:
             for obs_level in self.info_obs:
-                # Temporarily change obs_level to generate the desired observation
-                original_obs_level = self.obs_level
-                self.obs_level = obs_level
-                info_obs = self._generate_observation()
-                self.obs_level = original_obs_level
+                # Generate observation with the specified level
+                info_obs = self._generate_observation(observation_level=obs_level)
                 # Use the observation level name as key
                 info[str(obs_level)] = info_obs
 

miniworld_maze/environments/__init__.py

@@ -1,14 +1,12 @@
 """Nine Rooms environment implementations."""
 
 from .base_grid_rooms import GridRoomsEnvironment
-from .factory import NineRoomsEnvironmentWrapper
 from .nine_rooms import NineRooms
 from .spiral_nine_rooms import SpiralNineRooms
 from .twenty_five_rooms import TwentyFiveRooms
 
 __all__ = [
     "GridRoomsEnvironment",
-    "NineRoomsEnvironmentWrapper",
     "NineRooms",
     "SpiralNineRooms",
     "TwentyFiveRooms",

miniworld_maze/environments/base_grid_rooms.py

@@ -77,7 +77,8 @@ class GridRoomsEnvironment(UnifiedMiniWorldEnv):
 
         # Validate and set textures
         assert len(textures) == self.total_rooms, (
-            f"Textures for floor should be same as the number of the rooms ({self.total_rooms})"
+            f"Textures for floor should be same as the number of the rooms "
+            f"({self.total_rooms})"
         )
         self.textures = textures
 
@@ -226,16 +227,20 @@ class GridRoomsEnvironment(UnifiedMiniWorldEnv):
         obs, reward, terminated, truncated, info = super().step(action)
 
         # Check if goal is achieved
-        if self.is_goal_achieved():
+        if self._is_goal_achieved():
             terminated = True
             reward = 1.0  # Positive reward for achieving goal
 
+        # Add agent and goal positions to info dictionary
+        agent_pos = self.agent.pos
+        info["agent_position"] = np.array([agent_pos[0], agent_pos[2]])  # x, z
+
+        if hasattr(self, "_current_goal_position"):
+            goal_pos = self._current_goal_position
+            info["goal_position"] = np.array([goal_pos[0], goal_pos[2]])  # x, z
+
         # Return observation as dict
-        obs_dict = {
-            "observation": obs,
-            "desired_goal": self.desired_goal,
-            "achieved_goal": obs,
-        }
+        obs_dict = self._build_observation_dict(obs)
         return obs_dict, reward, terminated, truncated, info
 
     def reset(self, seed=None, options=None, pos=None):
@@ -254,17 +259,21 @@ class GridRoomsEnvironment(UnifiedMiniWorldEnv):
         obs, info = super().reset(seed=seed, options=options, pos=pos)
 
         # Generate goal
-        self.desired_goal = self.get_goal()
+        self.desired_goal = self._get_goal()
+
+        # Add agent and goal positions to info dictionary
+        agent_pos = self.agent.pos
+        info["agent_position"] = np.array([agent_pos[0], agent_pos[2]])  # x, z
+
+        if hasattr(self, "_current_goal_position"):
+            goal_pos = self._current_goal_position
+            info["goal_position"] = np.array([goal_pos[0], goal_pos[2]])  # x, z
 
         # Return observation as dict with desired_goal and achieved_goal
-        obs_dict = {
-            "observation": obs,
-            "desired_goal": self.desired_goal,
-            "achieved_goal": obs,
-        }
+        obs_dict = self._build_observation_dict(obs)
         return obs_dict, info
 
-    def get_goal(self):
+    def _get_goal(self):
         """
         Generate a goal by randomly selecting a room and goal position.
 
@@ -318,7 +327,7 @@ class GridRoomsEnvironment(UnifiedMiniWorldEnv):
 
         return obs
 
-    def is_goal_achieved(self, pos=None, threshold=0.5):
+    def _is_goal_achieved(self, pos=None, threshold=0.5):
         """
         Check if the agent has achieved the current goal.
 
@@ -341,3 +350,66 @@ class GridRoomsEnvironment(UnifiedMiniWorldEnv):
         distance = np.linalg.norm(pos_array - goal_array)
 
         return bool(distance < threshold)
+
+    @staticmethod
+    def _generate_goal_positions(
+        grid_size: int, room_size: Union[int, float], goals_per_room: int = 2
+    ) -> List[List[List[float]]]:
+        """
+        Generate goal positions for grid layout.
+        Args:
+            grid_size: Size of the grid (e.g., 3 for 3x3, 5 for 5x5)
+            room_size: Size of each room
+            goals_per_room: Number of goals per room (1 or 2)
+        Returns:
+            List of goal positions for each room
+        """
+        goal_positions = []
+        for i in range(grid_size):  # rows
+            for j in range(grid_size):  # columns
+                center_x = room_size * j + room_size / 2
+                center_z = room_size * i + room_size / 2
+                if goals_per_room == 1:
+                    # One goal per room at the center
+                    goal_positions.append([[center_x, 0.0, center_z]])
+                else:
+                    # Two goals per room: center-left and center-right
+                    goal_positions.append([
+                        [center_x - 1.0, 0.0, center_z],  # left goal
+                        [center_x + 1.0, 0.0, center_z],  # right goal
+                    ])
+        return goal_positions
+
+    def get_extent(self, padding: float = 1.0) -> Tuple[float, float, float, float]:
+        """
+        Get the scene extent for use with matplotlib imshow.
+        
+        Returns the scene bounds with padding in the format expected by 
+        matplotlib's imshow(extent=...) parameter: (left, right, bottom, top).
+        
+        Args:
+            padding: Padding to add around environment bounds (default: 1.0)
+            
+        Returns:
+            Tuple[float, float, float, float]: (min_x, max_x, min_z, max_z) with padding
+        """
+        return (
+            self.min_x - padding,
+            self.max_x + padding,
+            self.min_z - padding,
+            self.max_z + padding
+        )
+
+    def _build_observation_dict(self, obs: np.ndarray) -> dict:
+        """
+        Build the standard observation dictionary format.
+        Args:
+            obs: The observation array
+        Returns:
+            Dictionary with observation, desired_goal, and achieved_goal
+        """
+        return {
+            "observation": obs,
+            "desired_goal": self.desired_goal,
+            "achieved_goal": obs,
+        }

miniworld_maze/environments/factory.py

@@ -1,105 +1,42 @@
-"""Factory for creating Nine Rooms environment variants."""
-
-from typing import List
-
-import gymnasium as gym
-import numpy as np
+"""Gymnasium environment registrations for Nine Rooms environment variants."""
 
+from gymnasium.envs.registration import register
 from ..core import ObservationLevel
 from ..core.constants import FACTORY_DOOR_SIZE, FACTORY_ROOM_SIZE
-from .nine_rooms import NineRooms
-from .spiral_nine_rooms import SpiralNineRooms
-from .twenty_five_rooms import TwentyFiveRooms
-
-
-class NineRoomsEnvironmentWrapper(gym.Wrapper):
-    """Unified wrapper for all Nine Rooms environment variants."""
-
-    def __init__(
-        self,
-        variant="NineRooms",
-        obs_level=ObservationLevel.TOP_DOWN_PARTIAL,
-        continuous=False,
-        size=64,
-        room_size=FACTORY_ROOM_SIZE,
-        door_size=FACTORY_DOOR_SIZE,
-        agent_mode=None,
-        info_obs: List[ObservationLevel] = None,
-    ):
-        """
-        Create a Nine Rooms environment variant.
-
-        Args:
-            variant: Environment variant ("NineRooms", "SpiralNineRooms", "TwentyFiveRooms")
-            obs_level: Observation level (ObservationLevel enum)
-            continuous: Whether to use continuous actions
-            size: Observation image size (rendered directly at this size to avoid resizing)
-            room_size: Size of each room in environment units
-            door_size: Size of doors between rooms
-            agent_mode: Agent rendering mode ('empty', 'circle', 'triangle', or None for default)
-            info_obs: List of observation levels to include in info dictionary
-        """
-        self.variant = variant
-
-        # Select the appropriate environment class
-        env_classes = {
-            "NineRooms": NineRooms,
-            "SpiralNineRooms": SpiralNineRooms,
-            "TwentyFiveRooms": TwentyFiveRooms,
-        }
-
-        if variant not in env_classes:
-            raise ValueError(
-                f"Unknown variant '{variant}'. Available: {list(env_classes.keys())}"
-            )
-
-        env_class = env_classes[variant]
-
-        # Create base environment with direct rendering size
-        base_env = env_class(
-            room_size=room_size,
-            door_size=door_size,
-            obs_level=obs_level,
-            continuous=continuous,
-            obs_width=size,
-            obs_height=size,
-            agent_mode=agent_mode,
-            info_obs=info_obs,
-        )
-
-        # Apply wrappers - no resize needed since we render at target size
-
-        # Initialize gym.Wrapper with the base environment
-        super().__init__(base_env)
-
-    def render_on_pos(self, pos):
-        """Render observation from a specific position."""
-        # Get access to the base environment
-        base_env = self.env
-        while hasattr(base_env, "env") or hasattr(base_env, "_env"):
-            if hasattr(base_env, "env"):
-                base_env = base_env.env
-            elif hasattr(base_env, "_env"):
-                base_env = base_env._env
-            else:
-                break
-
-        # Store original position
-        original_pos = base_env.agent.pos.copy()
-
-        # Move agent to target position
-        base_env.place_agent(pos=pos)
-
-        # Get first-person observation from the agent's perspective at this position
-        obs = base_env.render_obs()
-
-        # Restore original position
-        base_env.place_agent(pos=original_pos)
-
-        # Apply wrapper transformations manually for consistency
-        # Convert to PyTorch format (CHW) - no resize needed since we render at target size
-        obs = np.transpose(obs, (2, 0, 1))
-
-        return obs
-
 
+# Register environment variants with factory defaults matching the original wrapper
+register(
+    id="NineRooms-v0",
+    entry_point="miniworld_maze.environments.nine_rooms:NineRooms",
+    max_episode_steps=1000,
+    kwargs={
+        "room_size": FACTORY_ROOM_SIZE,
+        "door_size": FACTORY_DOOR_SIZE,
+        "obs_level": ObservationLevel.TOP_DOWN_PARTIAL,
+        "agent_mode": None,  # becomes "empty" by default
+    },
+)
+
+register(
+    id="SpiralNineRooms-v0", 
+    entry_point="miniworld_maze.environments.spiral_nine_rooms:SpiralNineRooms",
+    max_episode_steps=1000,
+    kwargs={
+        "room_size": FACTORY_ROOM_SIZE,
+        "door_size": FACTORY_DOOR_SIZE,
+        "obs_level": ObservationLevel.TOP_DOWN_PARTIAL,
+        "agent_mode": None,
+    },
+)
+
+register(
+    id="TwentyFiveRooms-v0",
+    entry_point="miniworld_maze.environments.twenty_five_rooms:TwentyFiveRooms", 
+    max_episode_steps=1000,
+    kwargs={
+        "room_size": FACTORY_ROOM_SIZE,
+        "door_size": FACTORY_DOOR_SIZE,
+        "obs_level": ObservationLevel.TOP_DOWN_PARTIAL,
+        "agent_mode": None,
+    },
+)

miniworld_maze/environments/nine_rooms.py

@@ -1,6 +1,7 @@
 """NineRooms environment implementation."""
 
 from ..core import ObservationLevel
+from ..core.constants import TextureThemes
 from .base_grid_rooms import GridRoomsEnvironment
 
 
@@ -46,31 +47,12 @@ class NineRooms(GridRoomsEnvironment):
             (6, 7),
             (7, 8),
         ]
-        default_textures = [
-            "beige",
-            "lightbeige",
-            "lightgray",
-            "copperred",
-            "skyblue",
-            "lightcobaltgreen",
-            "oakbrown",
-            "navyblue",
-            "cobaltgreen",
-        ]
+        default_textures = TextureThemes.NINE_ROOMS
 
         # Initialize goal positions for each room (2 goals per room)
-        goal_positions = []
-        for i in range(3):  # rows
-            for j in range(3):  # columns
-                center_x = room_size * j + room_size / 2
-                center_z = room_size * i + room_size / 2
-                # Two goals per room: center-left and center-right
-                goal_positions.append(
-                    [
-                        [center_x - 1.0, 0.0, center_z],  # left goal
-                        [center_x + 1.0, 0.0, center_z],  # right goal
-                    ]
-                )
+        goal_positions = GridRoomsEnvironment._generate_goal_positions(
+            3, room_size, goals_per_room=2
+        )
 
         super().__init__(
             grid_size=3,

miniworld_maze/environments/spiral_nine_rooms.py

@@ -1,6 +1,7 @@
 """SpiralNineRooms environment implementation."""
 
 from ..core import ObservationLevel
+from ..core.constants import TextureThemes
 from .base_grid_rooms import GridRoomsEnvironment
 
 
@@ -42,31 +43,12 @@ class SpiralNineRooms(GridRoomsEnvironment):
             (6, 7),
             (7, 8),
         ]
-        default_textures = [
-            "beige",
-            "lightbeige",
-            "lightgray",
-            "copperred",
-            "skyblue",
-            "lightcobaltgreen",
-            "oakbrown",
-            "navyblue",
-            "cobaltgreen",
-        ]
+        default_textures = TextureThemes.SPIRAL_NINE_ROOMS
 
         # Initialize goal positions for each room (2 goals per room)
-        goal_positions = []
-        for i in range(3):  # rows
-            for j in range(3):  # columns
-                center_x = room_size * j + room_size / 2
-                center_z = room_size * i + room_size / 2
-                # Two goals per room: center-left and center-right
-                goal_positions.append(
-                    [
-                        [center_x - 1.0, 0.0, center_z],  # left goal
-                        [center_x + 1.0, 0.0, center_z],  # right goal
-                    ]
-                )
+        goal_positions = GridRoomsEnvironment._generate_goal_positions(
+            3, room_size, goals_per_room=2
+        )
 
         super().__init__(
             grid_size=3,

miniworld_maze/environments/twenty_five_rooms.py

@@ -1,6 +1,7 @@
 """TwentyFiveRooms environment implementation."""
 
 from ..core import ObservationLevel
+from ..core.constants import TextureThemes
 from .base_grid_rooms import GridRoomsEnvironment
 
 
@@ -78,46 +79,12 @@ class TwentyFiveRooms(GridRoomsEnvironment):
             (22, 23),
             (23, 24),
         ]
-        default_textures = [
-            "crimson",
-            "beanpaste",
-            "cobaltgreen",
-            "lightnavyblue",
-            "skyblue",
-            "lightcobaltgreen",
-            "oakbrown",
-            "copperred",
-            "lightgray",
-            "lime",
-            "turquoise",
-            "violet",
-            "beige",
-            "morningglory",
-            "silver",
-            "magenta",
-            "sunnyyellow",
-            "blueberry",
-            "lightbeige",
-            "seablue",
-            "lemongrass",
-            "orchid",
-            "redbean",
-            "orange",
-            "realblueberry",
-        ]
+        default_textures = TextureThemes.TWENTY_FIVE_ROOMS
 
         # Initialize goal positions for each room (1 goal per room at center)
-        goal_positions = []
-        for i in range(5):  # rows
-            for j in range(5):  # columns
-                center_x = room_size * j + room_size / 2
-                center_z = room_size * i + room_size / 2
-                # One goal per room at the center
-                goal_positions.append(
-                    [
-                        [center_x, 0.0, center_z],
-                    ]
-                )
+        goal_positions = GridRoomsEnvironment._generate_goal_positions(
+            5, room_size, goals_per_room=1
+        )
 
         super().__init__(
             grid_size=5,

miniworld_maze/tools/__init__.py

@@ -1,5 +1,3 @@
 """Tools for Nine Rooms environments."""
 
-from .generate_observations import generate_observations, main
-
-__all__ = ["generate_observations", "main"]
+__all__ = []

miniworld_maze/utils.py

@@ -0,0 +1,286 @@
+"""Utility functions for miniworld_maze package."""
+
+from typing import Tuple, Union
+import numpy as np
+
+
+def environment_to_pixel_coords(
+    env_pos: np.ndarray,
+    env_min: np.ndarray,
+    env_max: np.ndarray,
+    image_size: Union[int, Tuple[int, int]],
+) -> Tuple[int, int]:
+    """
+    Convert environment coordinates to pixel coordinates.
+
+    Args:
+        env_pos: Environment position as ndarray [x, z] or [x, y]
+        env_min: Environment minimum bounds as ndarray [min_x, min_z] or [min_x, min_y]
+        env_max: Environment maximum bounds as ndarray [max_x, max_z] or [max_x, max_y]
+        image_size: Image size (width, height) or single size for square image
+
+    Returns:
+        Tuple of (pixel_x, pixel_y) coordinates
+    """
+    env_x, env_y = env_pos[:2]
+    env_min_x, env_min_y = env_min[:2]
+    env_max_x, env_max_y = env_max[:2]
+
+    if isinstance(image_size, int):
+        width = height = image_size
+    else:
+        width, height = image_size
+
+    # Normalize to [0, 1] range and scale to pixel coordinates
+    pixel_x = int((env_x - env_min_x) / (env_max_x - env_min_x) * width)
+    pixel_y = int((env_y - env_min_y) / (env_max_y - env_min_y) * height)
+
+    return pixel_x, pixel_y
+
+
+def pixel_to_environment_coords(
+    pixel_pos: np.ndarray,
+    env_min: np.ndarray,
+    env_max: np.ndarray,
+    image_size: Union[int, Tuple[int, int]],
+) -> Tuple[float, float]:
+    """
+    Convert pixel coordinates to environment coordinates.
+
+    Args:
+        pixel_pos: Pixel position as ndarray [x, y]
+        env_min: Environment minimum bounds as ndarray [min_x, min_z] or [min_x, min_y]
+        env_max: Environment maximum bounds as ndarray [max_x, max_z] or [max_x, max_y]
+        image_size: Image size (width, height) or single size for square image
+
+    Returns:
+        Tuple of (env_x, env_y) coordinates
+    """
+    pixel_x, pixel_y = pixel_pos[:2]
+    env_min_x, env_min_y = env_min[:2]
+    env_max_x, env_max_y = env_max[:2]
+
+    if isinstance(image_size, int):
+        width = height = image_size
+    else:
+        width, height = image_size
+
+    # Convert to normalized [0, 1] range and scale to environment coordinates
+    env_x = pixel_x / width * (env_max_x - env_min_x) + env_min_x
+    env_y = pixel_y / height * (env_max_y - env_min_y) + env_min_y
+
+    return env_x, env_y
+
+
+def clamp_to_bounds(
+    value: Union[int, float, np.ndarray],
+    min_val: Union[int, float, np.ndarray],
+    max_val: Union[int, float, np.ndarray],
+) -> Union[int, float, np.ndarray]:
+    """
+    Clamp a value or array of values to specified bounds.
+
+    Args:
+        value: Value(s) to clamp (scalar or ndarray)
+        min_val: Minimum bound(s) (scalar or ndarray)
+        max_val: Maximum bound(s) (scalar or ndarray)
+
+    Returns:
+        Clamped value(s)
+    """
+    if isinstance(value, np.ndarray):
+        return np.clip(value, min_val, max_val)
+    else:
+        return max(min_val, min(max_val, value))
+
+
+def clamp_pixel_coords(
+    pixel_x: int, pixel_y: int, image_size: Union[int, Tuple[int, int]]
+) -> Tuple[int, int]:
+    """
+    Clamp pixel coordinates to image bounds.
+
+    Args:
+        pixel_x: X pixel coordinate
+        pixel_y: Y pixel coordinate
+        image_size: Image size (width, height) or single size for square image
+
+    Returns:
+        Tuple of clamped (pixel_x, pixel_y) coordinates
+    """
+    if isinstance(image_size, int):
+        width = height = image_size
+    else:
+        width, height = image_size
+
+    clamped_x = max(0, min(width - 1, pixel_x))
+    clamped_y = max(0, min(height - 1, pixel_y))
+
+    return clamped_x, clamped_y
+
+
+def normalize_coordinates(
+    coords: np.ndarray,
+    min_bounds: np.ndarray,
+    max_bounds: np.ndarray,
+) -> Tuple[float, float]:
+    """
+    Normalize coordinates to [0, 1] range based on given bounds.
+
+    Args:
+        coords: Coordinates to normalize as ndarray
+        min_bounds: Minimum bounds as ndarray
+        max_bounds: Maximum bounds as ndarray
+
+    Returns:
+        Normalized coordinates as (x, y) tuple
+    """
+    x, y = coords[:2]
+    min_x, min_y = min_bounds[:2]
+    max_x, max_y = max_bounds[:2]
+
+    norm_x = (x - min_x) / (max_x - min_x)
+    norm_y = (y - min_y) / (max_y - min_y)
+
+    return norm_x, norm_y
+
+
+def denormalize_coordinates(
+    normalized_coords: np.ndarray,
+    min_bounds: np.ndarray,
+    max_bounds: np.ndarray,
+) -> Tuple[float, float]:
+    """
+    Convert normalized [0, 1] coordinates back to original coordinate space.
+
+    Args:
+        normalized_coords: Normalized coordinates in [0, 1] range as ndarray
+        min_bounds: Original minimum bounds as ndarray
+        max_bounds: Original maximum bounds as ndarray
+
+    Returns:
+        Denormalized coordinates as (x, y) tuple
+    """
+    norm_x, norm_y = normalized_coords[:2]
+    min_x, min_y = min_bounds[:2]
+    max_x, max_y = max_bounds[:2]
+
+    x = norm_x * (max_x - min_x) + min_x
+    y = norm_y * (max_y - min_y) + min_y
+
+    return x, y
+
+
+def get_environment_bounds(env) -> Tuple[Tuple[float, float], Tuple[float, float]]:
+    """
+    Extract environment bounds from an environment object.
+
+    Args:
+        env: Environment object (may be wrapped)
+
+    Returns:
+        Tuple of ((min_x, min_z), (max_x, max_z))
+    """
+    # Unwrap environment to access base environment
+    base_env = env
+    while hasattr(base_env, "env"):
+        base_env = base_env.env
+
+    min_bounds = (base_env.min_x, base_env.min_z)
+    max_bounds = (base_env.max_x, base_env.max_z)
+
+    return min_bounds, max_bounds
+
+
+def calculate_view_size_from_bounds(
+    min_bounds: np.ndarray,
+    max_bounds: np.ndarray,
+) -> Tuple[float, float]:
+    """
+    Calculate view size (width, height) from coordinate bounds.
+
+    Args:
+        min_bounds: Minimum bounds as ndarray (min_x, min_y)
+        max_bounds: Maximum bounds as ndarray (max_x, max_y)
+
+    Returns:
+        Tuple of (width, height)
+    """
+    min_x, min_y = min_bounds[:2]
+    max_x, max_y = max_bounds[:2]
+
+    width = max_x - min_x
+    height = max_y - min_y
+
+    return width, height
+
+
+def scale_coordinates(
+    coords: np.ndarray,
+    scale_factor: Union[float, Tuple[float, float]],
+) -> Tuple[float, float]:
+    """
+    Scale coordinates by a given factor.
+
+    Args:
+        coords: Coordinates to scale as ndarray
+        scale_factor: Scale factor (uniform) or (scale_x, scale_y)
+
+    Returns:
+        Scaled coordinates as (x, y) tuple
+    """
+    x, y = coords[:2]
+
+    if isinstance(scale_factor, (tuple, list)):
+        scale_x, scale_y = scale_factor
+    else:
+        scale_x = scale_y = scale_factor
+
+    return x * scale_x, y * scale_y
+
+
+def distance_2d(
+    pos1: np.ndarray,
+    pos2: np.ndarray,
+) -> float:
+    """
+    Calculate 2D Euclidean distance between two positions.
+
+    Args:
+        pos1: First position as ndarray (x, y)
+        pos2: Second position as ndarray (x, y)
+
+    Returns:
+        Euclidean distance
+    """
+    x1, y1 = pos1[:2]
+    x2, y2 = pos2[:2]
+
+    return np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
+
+
+def lerp_2d(
+    pos1: np.ndarray,
+    pos2: np.ndarray,
+    t: float,
+) -> Tuple[float, float]:
+    """
+    Linear interpolation between two 2D positions.
+
+    Args:
+        pos1: Start position as ndarray (x, y)
+        pos2: End position as ndarray (x, y)
+        t: Interpolation parameter [0, 1]
+
+    Returns:
+        Interpolated position as (x, y) tuple
+    """
+    x1, y1 = pos1[:2]
+    x2, y2 = pos2[:2]
+
+    t = clamp_to_bounds(t, 0.0, 1.0)
+
+    x = x1 + t * (x2 - x1)
+    y = y1 + t * (y2 - y1)
+
+    return x, y

{miniworld_maze-1.1.0.dist-info → miniworld_maze-1.2.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.3
 Name: miniworld-maze
-Version: 1.1.0
-Summary: Multi-room maze environments from the DrStrategy paper for reinforcement learning research
+Version: 1.2.0
+Summary: Multi-room maze environments from the DrStrategy paper. Provides NineRooms-v0, SpiralNineRooms-v0, and TwentyFiveRooms-v0 gymnasium environments.
 Keywords: reinforcement-learning,environment,gymnasium,multi-room-maze,drstrategy,maze-navigation,partial-observability,3d-environments
 Author: Tim Joseph
 Author-email: Tim Joseph <tim@mctigger.com>
@@ -46,9 +46,6 @@ Requires-Dist: opencv-python>=4.5.0,<5.0.0
 Requires-Dist: pillow>=8.0.0,<11.0.0
 Requires-Dist: pyopengl>=3.1.0,<4.0.0
 Requires-Dist: pyglet>=1.5.0,<2.0.0
-Requires-Dist: black>=22.0,<25.0 ; extra == 'dev'
-Requires-Dist: isort>=5.10,<6.0 ; extra == 'dev'
-Requires-Dist: flake8>=4.0,<7.0 ; extra == 'dev'
 Requires-Dist: ruff>=0.1.0,<1.0.0 ; extra == 'dev'
 Requires-Dist: build>=0.8.0,<2.0.0 ; extra == 'dev'
 Requires-Dist: twine>=4.0.0,<6.0.0 ; extra == 'dev'
@@ -83,6 +80,18 @@ pip install miniworld-maze
 
 ## Usage
 
+### Registered Environments
+
+This package registers the following gymnasium environments:
+
+| Environment ID | Description | Rooms | Max Steps |
+|---|---|---|---|
+| `NineRooms-v0` | Standard 3×3 grid with adjacent room connections | 9 | 1000 |
+| `SpiralNineRooms-v0` | 3×3 grid with spiral connection pattern | 9 | 1000 |
+| `TwentyFiveRooms-v0` | Large 5×5 grid with complex navigation | 25 | 1000 |
+
+All environments use `TOP_DOWN_PARTIAL` observation level and factory default room/door sizes by default.
+
 ### Basic Usage
 
 See `examples/basic_usage.py` for a complete working example:
@@ -95,12 +104,13 @@ Basic usage example for miniworld-maze environments.
 This is a minimal example showing how to create and interact with the environment.
 """
 
-from miniworld_maze import NineRoomsEnvironmentWrapper
+import gymnasium as gym
+import miniworld_maze  # noqa: F401
 
 
 def main():
-    # Create environment
-    env = NineRoomsEnvironmentWrapper(variant="NineRooms", size=64)
+    # Create environment using gymnasium registry
+    env = gym.make("NineRooms-v0", obs_width=64, obs_height=64)
     obs, info = env.reset()
 
     # obs is a dictionary containing:
@@ -212,14 +222,15 @@ Each environment supports three different observation modes:
 All environments can be customized with the following parameters:
 
 ```python
-from miniworld_maze import NineRoomsEnvironmentWrapper
-from miniworld_maze.core import ObservationLevel
+import gymnasium as gym
+from miniworld_maze import ObservationLevel
+import miniworld_maze  # noqa: F401
 
-env = NineRoomsEnvironmentWrapper(
-    variant="NineRooms",                    # "NineRooms", "SpiralNineRooms", "TwentyFiveRooms"
+env = gym.make(
+    "NineRooms-v0",                        # Environment variant
     obs_level=ObservationLevel.TOP_DOWN_PARTIAL,  # Observation type
-    continuous=False,                       # Use continuous actions
-    size=64,                               # Observation image size (64x64)
+    obs_width=64,                          # Observation image width
+    obs_height=64,                         # Observation image height
     room_size=5,                           # Size of each room in environment units
     door_size=2,                           # Size of doors between rooms  
     agent_mode="empty",                    # Agent rendering: "empty", "circle", "triangle"

{miniworld_maze-1.1.0.dist-info → miniworld_maze-1.2.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-miniworld_maze/__init__.py,sha256=kz5QqyvwIV_XkjXw_yHRkhqlPSl8X1Usra3DF0Zy4_E,1053
+miniworld_maze/__init__.py,sha256=Dfq3558bJ5kgxDZxPxvlHu1531zfBhtiDfKbVL_4zCE,1430
 miniworld_maze/core/__init__.py,sha256=5BA4WKXQjrG55TNaEid2JGrnf1KQniJZ1HhRqovM1Q0,293
-miniworld_maze/core/constants.py,sha256=GX1pSnaWGOkangYStxaBy7gIQhWxVKIbXnTSd-eA_vs,3962
+miniworld_maze/core/constants.py,sha256=UXqmuvsT9ww1GljW74lWPPP9XxVmvti-8JfM_RBSoWQ,4314
 miniworld_maze/core/miniworld_gymnasium/README.md,sha256=kkZgkRKBdgixpot3uHuiBFlRIKRFIVBVfXwu68XTEv0,74
-miniworld_maze/core/miniworld_gymnasium/__init__.py,sha256=zgqRxYBKT9Jo06kqWusZ6OjHyz25AyW03gkyrpZqY1I,151
+miniworld_maze/core/miniworld_gymnasium/__init__.py,sha256=ALOqr4SCVk9I9bmxyoU0Du8LUPE_57jIyZuV4QhOcBc,159
 miniworld_maze/core/miniworld_gymnasium/base_env.py,sha256=heoJxEw_GGEHSzU75MWgqRkWARY3lgTgwNE9Zp1P_YA,1795
 miniworld_maze/core/miniworld_gymnasium/entities/__init__.py,sha256=gbMJcFeasvlRSIuXWyOYO-MhW0JKKY5ZNxF5TMsWJ5c,262
 miniworld_maze/core/miniworld_gymnasium/entities/agent.py,sha256=U3Zt2Hk21rJSdzPCBj46-N930n7XAkA9qo_fKbezn2k,3153
@@ -260,19 +260,18 @@ miniworld_maze/core/miniworld_gymnasium/textures/white_1.png,sha256=wRrgs92I_Ids
 miniworld_maze/core/miniworld_gymnasium/textures/wood_1.png,sha256=XRZyIN34HFo14olbxRcsHGrzCAFqUlowc6nLR22IFBE,184713
 miniworld_maze/core/miniworld_gymnasium/textures/wood_2.png,sha256=qSDHB-ZO11JJLQuiQse-0edpbuTg1YO-eIBhdTvNUhc,93121
 miniworld_maze/core/miniworld_gymnasium/textures/wood_planks_1.png,sha256=E4SNN1s4yOtkLfZFQy905eip6KvDWnnPUrpS82FxMAg,847259
-miniworld_maze/core/miniworld_gymnasium/unified_env.py,sha256=oY2YXCZ-ro8kl6ie0h8TEBooWjB6bvmQu42-1tDsrw4,46689
+miniworld_maze/core/miniworld_gymnasium/unified_env.py,sha256=B7kfG6axiL05o3kLiBvE6O1Q7kB8PaLdlAt1-Sksv0I,46529
 miniworld_maze/core/miniworld_gymnasium/utils.py,sha256=9cfpg4qYz-Esxvu8nTMPFJc-Tl0TRxTrX6cfg0YuK_o,1007
 miniworld_maze/core/miniworld_gymnasium/wrappers.py,sha256=cD0nGSJYNU96zoWv63aEiKd986POhtHfGGEpNpRL5ec,122
 miniworld_maze/core/observation_types.py,sha256=Co8mEIXzIgk0MLx6tqeBd1EE0PuZOL1gbZwobiEde08,1316
-miniworld_maze/environments/__init__.py,sha256=6O1G4vlhUSn8OuR46u-t4Wz3de8da76Tz21TsVlzBZo,415
-miniworld_maze/environments/base_grid_rooms.py,sha256=kpF6psn0YCfvA-q1vtU2KaqwmfQaPpX0w9jBTxt2qs8,11833
-miniworld_maze/environments/factory.py,sha256=g8qYF6UF9DsKExZIHhMsP8PX3b11kvmkLMwE2IpgBxc,3501
-miniworld_maze/environments/nine_rooms.py,sha256=0CzUkRy2hJZ4JEEj9E-6xCopseZ1u8iGCfKLaxwATGo,2368
-miniworld_maze/environments/spiral_nine_rooms.py,sha256=LB9wKQXp9S8pVd8JhM9zfsc5z4ksxsQxQKoEXrDgPhE,2316
-miniworld_maze/environments/twenty_five_rooms.py,sha256=ExF4Mt0B3pkaVQtBF7oaVxdj_9uaAkTFYCe83Lw8Evk,3448
-miniworld_maze/tools/__init__.py,sha256=PgkKMO21xnwIfJtD437P_RtkguOHoOSFV1ohsO-n7tc,150
-miniworld_maze/tools/generate_observations.py,sha256=-WWoex0KY6PSMs4BenMTepeE4tA2NYZ26jIQL2tYfZY,6781
-miniworld_maze-1.1.0.dist-info/WHEEL,sha256=NHRAbdxxzyL9K3IO2LjmlNqKSyPZnKv2BD16YYVKo18,79
-miniworld_maze-1.1.0.dist-info/entry_points.txt,sha256=Ue03NHCOQCiJ87tqfJSns29C3Dw02jsZXL_Auzw2pb4,91
-miniworld_maze-1.1.0.dist-info/METADATA,sha256=atsdko20fA_iqS8y2muB0dQkLDnmLpP4ppuTuNLfcxA,9270
-miniworld_maze-1.1.0.dist-info/RECORD,,
+miniworld_maze/environments/__init__.py,sha256=DKld5MQU7x9eNL6BlxIettA44bCiIn2zIpYECDCNxoQ,331
+miniworld_maze/environments/base_grid_rooms.py,sha256=j4LnyUv0YjHlCLfjqX3fyoXUOOyCr4e3_Pdj-sM3FHo,14753
+miniworld_maze/environments/factory.py,sha256=Zk26JawsMgSLMgvSnQxFhQCD8yMH76HgqFtogzWFfqY,1333
+miniworld_maze/environments/nine_rooms.py,sha256=Ct96cKtSt1_nLNI5RBUhwqdNUQq1rHfBJ3aB5Igbdow,1794
+miniworld_maze/environments/spiral_nine_rooms.py,sha256=a_pUuv-ghez8h76Z7YsHkQoLXsQ-w9azKLjEjO4uKmA,1749
+miniworld_maze/environments/twenty_five_rooms.py,sha256=MewKPDHDilscQGTT3aGRrSHvo4uFgHHAOrnJMrHaezQ,2598
+miniworld_maze/tools/__init__.py,sha256=XiReXrJIcBKvDVyPZrKPq1mckJs0_WC7q_RmdXXcKHs,55
+miniworld_maze/utils.py,sha256=HTOkfRq72oOC844gVXjWMH1ox7wdSxfCS6oTrWBw05Q,7523
+miniworld_maze-1.2.0.dist-info/WHEEL,sha256=NHRAbdxxzyL9K3IO2LjmlNqKSyPZnKv2BD16YYVKo18,79
+miniworld_maze-1.2.0.dist-info/METADATA,sha256=QHJBCKSCHQr2u-Utcck1qMOffK1Cc6T0sV2k6_H7OAE,9657
+miniworld_maze-1.2.0.dist-info/RECORD,,

miniworld_maze/tools/generate_observations.py

@@ -1,199 +0,0 @@
-#!/usr/bin/env python3
-"""
-Generate comprehensive observations for Nine Rooms environment variants.
-Supports: NineRooms, SpiralNineRooms, TwentyFiveRooms
-"""
-
-import argparse
-import os
-
-import numpy as np
-from PIL import Image
-
-from ..core import FrameBuffer
-from ..environments.factory import NineRoomsEnvironmentWrapper
-
-
-def generate_observations(variant, output_dir=None, high_res_full_views=False):
-    """Generate comprehensive observations for the specified environment variant."""
-    if output_dir is None:
-        output_dir = f"{variant.lower()}_observations"
-
-    os.makedirs(output_dir, exist_ok=True)
-
-    # Create environment
-    env = NineRoomsEnvironmentWrapper(variant=variant, size=64)
-
-    # Get base environment for direct render access
-    base_env = getattr(env, "env", getattr(env, "_env", env))
-    while hasattr(base_env, "env") or hasattr(base_env, "_env"):
-        if hasattr(base_env, "env"):
-            base_env = base_env.env
-        elif hasattr(base_env, "_env"):
-            base_env = base_env._env
-        else:
-            break
-
-    # Reset environment
-    obs, _ = env.reset(seed=42)
-
-    # Create high-resolution frame buffer if requested
-    high_res_fb = None
-    if high_res_full_views:
-        high_res_fb = FrameBuffer(512, 512, 8)
-
-    # === FULL ENVIRONMENT OBSERVATIONS ===
-
-    # 1. Full view with agent at starting position
-    if high_res_full_views:
-        full_view_start = base_env.render_top_view(
-            frame_buffer=high_res_fb, POMDP=False
-        )
-    else:
-        full_view_start = base_env.render_top_view(POMDP=False)
-    Image.fromarray(full_view_start).save(f"{output_dir}/full_view_start.png")
-
-    # 2. Full view without agent (clean maze view)
-    if high_res_full_views:
-        full_view_clean = base_env.render_top_view(
-            frame_buffer=high_res_fb, POMDP=False, render_ag=False
-        )
-    else:
-        full_view_clean = base_env.render_top_view(POMDP=False, render_ag=False)
-    Image.fromarray(full_view_clean).save(f"{output_dir}/full_view_clean.png")
-
-    # 3. Full view with agent in center
-    center_x = (base_env.min_x + base_env.max_x) / 2
-    center_z = (base_env.min_z + base_env.max_z) / 2
-    base_env.place_agent(pos=[center_x, 0.0, center_z])
-    if high_res_full_views:
-        full_view_center = base_env.render_top_view(
-            frame_buffer=high_res_fb, POMDP=False
-        )
-    else:
-        full_view_center = base_env.render_top_view(POMDP=False)
-    Image.fromarray(full_view_center).save(f"{output_dir}/full_view_center.png")
-
-    # === PARTIAL OBSERVATIONS ===
-
-    # Reset agent to start position
-    base_env.place_agent(pos=[2.5, 0.0, 2.5])
-
-    # 1. Partial view from starting position
-    partial_start = base_env.render_top_view(POMDP=True)
-    Image.fromarray(partial_start).save(f"{output_dir}/partial_start.png")
-
-    # 2. Partial view from center
-    base_env.place_agent(pos=[center_x, 0.0, center_z])
-    partial_center = base_env.render_top_view(POMDP=True)
-    Image.fromarray(partial_center).save(f"{output_dir}/partial_center.png")
-
-    # 3. Partial view from corner/edge
-    corner_x = base_env.max_x - 2.5
-    corner_z = base_env.max_z - 2.5
-    base_env.place_agent(pos=[corner_x, 0.0, corner_z])
-    partial_corner = base_env.render_top_view(POMDP=True)
-    Image.fromarray(partial_corner).save(f"{output_dir}/partial_corner.png")
-
-    # 4. Partial view at strategic location
-    if variant == "NineRooms":
-        strategic_x, strategic_z = 15.0, 7.5  # Room boundary
-    elif variant == "SpiralNineRooms":
-        strategic_x, strategic_z = 22.5, 15.0  # Center of spiral
-    else:  # TwentyFiveRooms
-        strategic_x, strategic_z = 37.5, 37.5  # Mid-outer area
-
-    base_env.place_agent(pos=[strategic_x, 0.0, strategic_z])
-    partial_strategic = base_env.render_top_view(POMDP=True)
-    Image.fromarray(partial_strategic).save(f"{output_dir}/partial_strategic.png")
-
-    # === WRAPPED OBSERVATIONS ===
-
-    # Reset environment
-    obs, _ = env.reset(seed=42)
-
-    # 1. Standard gymnasium observation
-    obs_hwc = np.transpose(obs, (1, 2, 0))
-    Image.fromarray(obs_hwc).save(f"{output_dir}/gymnasium_standard.png")
-
-    # 2. Observations after movement
-    actions = [2, 2, 1]  # move_forward, move_forward, turn_right
-    action_names = ["move_forward", "move_forward", "turn_right"]
-
-    for i, action in enumerate(actions):
-        obs, _, _, _, _ = env.step(action)
-        obs_hwc = np.transpose(obs, (1, 2, 0))
-        Image.fromarray(obs_hwc).save(
-            f"{output_dir}/gymnasium_step_{i + 1}_{action_names[i]}.png"
-        )
-
-    # === RENDER_ON_POS EXAMPLES ===
-
-    # Define test positions based on variant
-    if variant == "NineRooms":
-        test_positions = [
-            [7.5, 0.0, 7.5],  # top-middle room center
-            [37.5, 0.0, 37.5],  # bottom-right room center
-            [22.5, 0.0, 22.5],  # environment center
-            [7.5, 0.0, 22.5],  # middle-left room center
-        ]
-    elif variant == "SpiralNineRooms":
-        test_positions = [
-            [7.5, 0.0, 7.5],  # top-left room (spiral start)
-            [37.5, 0.0, 37.5],  # bottom-right room (spiral end)
-            [22.5, 0.0, 7.5],  # top-right room
-            [7.5, 0.0, 37.5],  # bottom-left room
-        ]
-    else:  # TwentyFiveRooms
-        test_positions = [
-            [37.5, 0.0, 37.5],  # room (1,1) - near corner
-            [112.5, 0.0, 112.5],  # room (4,4) - far corner
-            [75.0, 0.0, 75.0],  # center room (2,2)
-            [37.5, 0.0, 112.5],  # room (1,4) - opposite corner
-        ]
-
-    for i, pos in enumerate(test_positions):
-        render_obs = env.render_on_pos(pos)
-
-        # Convert CHW to HWC for PIL
-        if len(render_obs.shape) == 3 and render_obs.shape[0] == 3:
-            render_obs = np.transpose(render_obs, (1, 2, 0))
-
-        Image.fromarray(render_obs).save(f"{output_dir}/render_on_pos_{i + 1}.png")
-
-    env.close()
-    return output_dir
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Generate observations for Nine Rooms environment variants"
-    )
-    parser.add_argument(
-        "variant",
-        choices=["NineRooms", "SpiralNineRooms", "TwentyFiveRooms"],
-        help="Environment variant to use",
-    )
-    parser.add_argument(
-        "--output-dir",
-        type=str,
-        default=None,
-        help="Output directory for images (default: {variant}_observations)",
-    )
-    parser.add_argument(
-        "--high-res-full",
-        action="store_true",
-        help="Generate 512x512 high-resolution full environment views",
-    )
-
-    args = parser.parse_args()
-
-    output_dir = generate_observations(
-        args.variant, args.output_dir, args.high_res_full
-    )
-
-    return output_dir
-
-
-if __name__ == "__main__":
-    main()

miniworld_maze-1.1.0.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-generate-observations = miniworld_maze.tools.generate_observations:main
-