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

miniworld_maze/__init__.py

@@ -15,21 +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,
-    create_drstrategy_env,
-    create_nine_rooms_env,
-)
 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__ = [
-    "create_drstrategy_env",
-    "create_nine_rooms_env",  # deprecated but kept for backward compatibility
-    "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

@@ -3,6 +3,7 @@
 import math
 from ctypes import POINTER
 from enum import IntEnum
+from typing import List, Optional
 
 import gymnasium as gym
 import numpy as np
@@ -10,6 +11,7 @@ import pyglet
 from gymnasium import spaces
 from pyglet.gl import *
 
+from ..observation_types import ObservationLevel
 from .entities import *
 from .math import *
 from .objmesh import *
@@ -95,6 +97,7 @@ class UnifiedMiniWorldEnv(gym.Env):
         window_height=DEFAULT_WINDOW_HEIGHT,
         params=DEFAULT_PARAMS,
         domain_rand=False,
+        info_obs: Optional[List[ObservationLevel]] = None,
     ):
         """
         Initialize unified MiniWorld environment.
@@ -110,6 +113,7 @@ class UnifiedMiniWorldEnv(gym.Env):
             window_height: Window height for human rendering
             params: Environment parameters for domain randomization
             domain_rand: Whether to enable domain randomization
+            info_obs: List of observation levels to include in info dictionary
         """
         # Store configuration
         self.obs_level = obs_level
@@ -118,6 +122,7 @@ class UnifiedMiniWorldEnv(gym.Env):
         self.max_episode_steps = max_episode_steps
         self.params = params
         self.domain_rand = domain_rand
+        self.info_obs = info_obs
 
         # Setup action space
         self._setup_action_space()
@@ -327,22 +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:
+                # 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, {}
+        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
@@ -354,33 +369,21 @@ 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 get_observation(self, render_agent: bool = None):
-        """Public method to generate observation with optional agent rendering control.
-
-        Args:
-            render_agent: Whether to render the agent in the observation.
-                         If None, uses default behavior based on observation level.
-
-        Returns:
-            np.ndarray: Generated observation image
-        """
-        return self._generate_observation(render_agent=render_agent)
-
     def _calculate_carried_object_position(self, agent_pos, ent):
         """Compute the position at which to place an object being carried."""
         dist = self.agent.radius + ent.radius + self.max_forward_step
@@ -502,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)
@@ -577,21 +580,34 @@ class UnifiedMiniWorldEnv(gym.Env):
         if self.obs_level != 2:  # Not TOP_DOWN_FULL
             topdown = self.render_top_view(POMDP=False, frame_buffer=self.topdown_fb)
 
+        # Generate additional observations for info dictionary if specified
+        info = {}
+        if self.info_obs is not None:
+            for obs_level in self.info_obs:
+                # 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
+
         # Check termination
         if self.step_count >= self.max_episode_steps:
             terminated = True
             reward = 0
-            info = {
-                "pos": self.agent.pos,
-                "mdp_view": topdown if topdown is not None else observation,
-            }
+            info.update(
+                {
+                    "pos": self.agent.pos,
+                    "mdp_view": topdown if topdown is not None else observation,
+                }
+            )
         else:
             reward = 0
             terminated = False
-            info = {
-                "pos": self.agent.pos,
-                "mdp_view": topdown if topdown is not None else observation,
-            }
+            info.update(
+                {
+                    "pos": self.agent.pos,
+                    "mdp_view": topdown if topdown is not None else observation,
+                }
+            )
 
         return reward, terminated, info
 

miniworld_maze/environments/__init__.py

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

miniworld_maze/environments/base_grid_rooms.py

@@ -2,6 +2,8 @@
 
 from typing import List, Optional, Tuple, Union
 
+import cv2
+import numpy as np
 from gymnasium import spaces
 
 from ..core import COLORS, Box, ObservationLevel
@@ -35,6 +37,7 @@ class GridRoomsEnvironment(UnifiedMiniWorldEnv):
         grid_size: int,
         connections: List[Tuple[int, int]],
         textures: List[str],
+        goal_positions: List[List[List[float]]],
         placed_room: Optional[int] = None,
         obs_level: ObservationLevel = ObservationLevel.TOP_DOWN_PARTIAL,
         continuous: bool = False,
@@ -52,6 +55,7 @@ class GridRoomsEnvironment(UnifiedMiniWorldEnv):
             grid_size: Size of the grid (e.g., 3 for 3x3 grid)
             connections: List of (room1, room2) tuples for connections
             textures: List of texture names for each room
+            goal_positions: List of goal positions for each room
             placed_room: Initial room index (defaults to 0)
             obs_level: Observation level (defaults to 1)
             continuous: Whether to use continuous actions (defaults to False)
@@ -73,10 +77,14 @@ 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
 
+        # Set goal positions
+        self.goal_positions = goal_positions
+
         # Set placed room
         if placed_room is None:
             self.placed_room = 0  # Start in the first room
@@ -101,6 +109,10 @@ class GridRoomsEnvironment(UnifiedMiniWorldEnv):
         # Mark this as a custom environment for background color handling
         self._is_custom_env = True
 
+        # Store observation dimensions for rendering (needed before super().__init__)
+        self.obs_width = obs_width
+        self.obs_height = obs_height
+
         super().__init__(
             obs_level=obs_level,
             max_episode_steps=MAX_EPISODE_STEPS,
@@ -114,6 +126,18 @@ class GridRoomsEnvironment(UnifiedMiniWorldEnv):
         if not self.continuous:
             self.action_space = spaces.Discrete(self.actions.move_forward + 1)
 
+        # Store original observation space before updating
+        original_obs_space = self.observation_space
+
+        # Update observation space to include desired_goal and achieved_goal
+        self.observation_space = spaces.Dict(
+            {
+                "observation": original_obs_space,
+                "desired_goal": original_obs_space,
+                "achieved_goal": original_obs_space,
+            }
+        )
+
     def _generate_world_layout(self, pos=None):
         rooms = []
 
@@ -201,4 +225,191 @@ class GridRoomsEnvironment(UnifiedMiniWorldEnv):
 
     def step(self, action):
         obs, reward, terminated, truncated, info = super().step(action)
-        return obs, reward, terminated, truncated, info
+
+        # Check if goal is 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 = self._build_observation_dict(obs)
+        return obs_dict, reward, terminated, truncated, info
+
+    def reset(self, seed=None, options=None, pos=None):
+        """
+        Reset the environment and generate a new goal.
+
+        Args:
+            seed: Random seed
+            options: Additional options
+            pos: Agent starting position
+
+        Returns:
+            tuple: (observation, info)
+        """
+        # Call parent reset
+        obs, info = super().reset(seed=seed, options=options, pos=pos)
+
+        # Generate 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 = self._build_observation_dict(obs)
+        return obs_dict, info
+
+    def _get_goal(self):
+        """
+        Generate a goal by randomly selecting a room and goal position.
+
+        Returns:
+            np.ndarray: Rendered goal image
+        """
+        # Select random room
+        room_idx = np.random.randint(len(self.goal_positions))
+
+        # Select random goal within room
+        goal_idx = np.random.randint(len(self.goal_positions[room_idx]))
+
+        # Get goal position
+        goal_position = self.goal_positions[room_idx][goal_idx]
+        self._current_goal_position = goal_position
+        self._current_goal_room = room_idx
+        self._current_goal_idx = goal_idx
+
+        # Render goal image
+        goal_image = self.render_on_pos(goal_position)
+
+        return goal_image
+
+    def render_on_pos(self, pos):
+        """
+        Render observation from a specific position.
+
+        Args:
+            pos: Position to render from [x, y, z]
+
+        Returns:
+            np.ndarray: Rendered observation
+        """
+        # Store current agent position
+        current_pos = self.agent.pos.copy()
+
+        # Move agent to target position
+        self.place_agent(pos=pos)
+
+        # Render observation from this position
+        obs = self.render_top_view(POMDP=True, render_ag=False)
+
+        # Resize to match observation dimensions if needed
+        if obs.shape[:2] != (self.obs_height, self.obs_width):
+            obs = cv2.resize(
+                obs, (self.obs_width, self.obs_height), interpolation=cv2.INTER_AREA
+            )
+
+        # Restore agent position
+        self.place_agent(pos=current_pos)
+
+        return obs
+
+    def _is_goal_achieved(self, pos=None, threshold=0.5):
+        """
+        Check if the agent has achieved the current goal.
+
+        Args:
+            pos: Agent position to check (uses current agent pos if None)
+            threshold: Distance threshold for goal achievement
+
+        Returns:
+            bool: True if goal is achieved
+        """
+        if pos is None:
+            pos = self.agent.pos
+
+        if not hasattr(self, "_current_goal_position"):
+            return False
+
+        # Convert to numpy arrays and calculate distance
+        pos_array = np.array(pos)
+        goal_array = np.array(self._current_goal_position)
+        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,
+        }