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

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.3.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.3.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.3.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-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/base_env.py,sha256=heoJxEw_GGEHSzU75MWgqRkWARY3lgTgwNE9Zp1P_YA,1795
+miniworld_maze/core/miniworld_gymnasium/__init__.py,sha256=ALOqr4SCVk9I9bmxyoU0Du8LUPE_57jIyZuV4QhOcBc,159
+miniworld_maze/core/miniworld_gymnasium/base_env.py,sha256=K2L5r4gG2k4fEknFqRJ7f-b2S0Uj5QhanS-MLi6ncVc,1927
 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
 miniworld_maze/core/miniworld_gymnasium/entities/base_entity.py,sha256=ox2k3rf64Y2mp4S0mcpNpPUg0QeUuJ7LVoduvBuLXDg,3657
@@ -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=7A4sAmMpopLfKMXtZ4jzbMlFJbzeu9Abv7hGYVbvOIA,46925
 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=--tm6t9cHn444xJX9N3Md-4YApK38a2dQi7mnggevbI,14885
+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.3.0.dist-info/WHEEL,sha256=NHRAbdxxzyL9K3IO2LjmlNqKSyPZnKv2BD16YYVKo18,79
+miniworld_maze-1.3.0.dist-info/METADATA,sha256=qKeYDRC9Evc7PtegEs0PVFYy7fMgKlqNZPiFf3GnZkk,9657
+miniworld_maze-1.3.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
-