#!/usr/bin/env python3 """ Simple VLN Environment for SAGE-3D Benchmark. Provides Isaac Sim based VLN environment with RGB-D rendering, physics simulation, and collision detection. """ import os import math import json from pathlib import Path from typing import Tuple, List, Dict, Any, Optional import numpy as np from PIL import Image import imageio def _should_print_debug() -> bool: """Check if debug messages should be printed.""" return not os.environ.get('SILENT_LOGGING_MODE', False) def _debug_print(msg: str) -> None: """Conditionally print debug messages.""" if _should_print_debug(): print(msg) try: from isaacsim.simulation_app import SimulationApp # Isaac Sim 4.1+ except Exception: from omni.isaac.kit import SimulationApp # fallback # Import 2D semantic map collision detector try: from .collision_detector import SemanticMap2DCollisionDetector except ImportError: try: from collision_detector import SemanticMap2DCollisionDetector except ImportError: print("[WARNING] Cannot import SemanticMap2DCollisionDetector, 2D semantic map collision detection will be disabled") SemanticMap2DCollisionDetector = None class SimpleVLNEnv: """Simple VLN Environment based on Isaac Sim for SAGE-3D Benchmark.""" def __init__( self, scene_usd_path: str, headless: bool = True, hz: int = 30, agent_prim_path: str = "/World/AgentCamera", resolution: Tuple[int, int] = (640, 480), map_json_path: str = None ) -> None: """Initialize SimpleVLNEnv. Args: scene_usd_path: Path to scene USD/USDA file headless: Whether to run in headless mode (no GUI) hz: Simulation frequency in Hz agent_prim_path: USD path for agent prim resolution: Camera resolution (width, height) map_json_path: Path to 2D semantic map JSON for collision detection """ print("[ENV_INIT] ===== SimpleVLNEnv Initialization Start =====") print(f"[ENV_INIT] scene_usd_path: {scene_usd_path}") print(f"[ENV_INIT] headless: {headless}") print(f"[ENV_INIT] hz: {hz}") print(f"[ENV_INIT] agent_prim_path: {agent_prim_path}") print(f"[ENV_INIT] resolution: {resolution}") self.scene_usd_path = str(Path(scene_usd_path).resolve()) self.hz = hz self.agent_prim_path = agent_prim_path self.resolution = resolution self.headless = headless self.is_stop_called = False self.consecutive_collisions = 0 # Consecutive collision counter self._total_collision_count = 0 # Total collision count for current episode (CR metric) self._debug_disable_collision = False # Enable collision detection (needed for rendering) # Time tracking (for no-goal tasks) import time self._episode_start_time = time.time() self._current_time = time.time() self._collision_detected = False # Log function (set in run_benchmark) self._log_function = None self._map_json_path = map_json_path # Save for later initialization # Object-based success evaluation related attributes self.semantic_map_path = map_json_path # For object-based success evaluation self.collision_detector = None # Start Isaac Sim (before setting log function) self._init_isaac_sim() def _log(self, msg: str) -> None: """Log message to console and file.""" print(msg, flush=True) if self._log_function: try: self._log_function(msg) except: pass # Silently ignore log errors def update_time_and_reset_collision(self) -> None: """Update current time and reset collision state (called each step).""" import time self._current_time = time.time() self._collision_detected = False # Reset collision state, await new collision detection def reset_episode_time(self) -> None: """Reset episode start time (called when new episode starts).""" import time self._episode_start_time = time.time() self._current_time = time.time() self._collision_detected = False def set_log_function(self, log_func) -> None: """Set log function.""" self._log_function = log_func # Immediately initialize 2D collision detector self._init_collision_detector(self._map_json_path) def _init_collision_detector(self, map_json_path: str) -> None: """Initialize 2D semantic map collision detector.""" self._log(f"[COLLISION_2D] ===== Starting 2D Collision Detector Initialization =====") self._log(f"[COLLISION_2D] map_json_path: {map_json_path}") self._log(f"[COLLISION_2D] SemanticMap2DCollisionDetector available: {SemanticMap2DCollisionDetector is not None}") if map_json_path: self._log(f"[COLLISION_2D] Map file exists: {os.path.exists(map_json_path)}") if SemanticMap2DCollisionDetector is not None and map_json_path and os.path.exists(map_json_path): try: self._log(f"[COLLISION_2D] Initializing 2D semantic map collision detector...") self.collision_detector = SemanticMap2DCollisionDetector( map_json_path, robot_radius_m=0.08, # Smaller robot radius for finer movement scale=0.05 # Consistent with A* algorithm ) self._log(f"[COLLISION_2D] ✓ Successfully loaded 2D semantic map collision detector: {map_json_path}") collision_info = self.collision_detector.get_collision_info() self._log(f"[COLLISION_2D] ✓ Map info: obstacle pixels {collision_info['obstacle_pixels']}/{collision_info['total_pixels']} ({collision_info['obstacle_ratio']:.1%})") except Exception as e: self._log(f"[COLLISION_2D] ✗ Warning: Cannot load 2D semantic map collision detector: {e}") import traceback traceback.print_exc() self.collision_detector = None else: if SemanticMap2DCollisionDetector is None: self._log(f"[COLLISION_2D] ✗ Warning: SemanticMap2DCollisionDetector class not available, using original collision detection") elif not map_json_path: self._log(f"[COLLISION_2D] ℹ Info: No 2D semantic map path provided, using original collision detection") elif not os.path.exists(map_json_path): self._log(f"[COLLISION_2D] ✗ Warning: 2D semantic map file does not exist: {map_json_path}") self._log(f"[COLLISION_2D] Final state: collision_detector = {self.collision_detector is not None}") self._log(f"[COLLISION_2D] ===== 2D Collision Detector Initialization Complete =====") def _init_isaac_sim(self): """Initialize Isaac Sim environment.""" # Launch SimulationApp first before importing any omni/pxr modules self.sim = SimulationApp({"headless": self.headless}) # Now safe to import omni/usd modules import omni.usd # type: ignore from pxr import UsdGeom, UsdPhysics # type: ignore # Try new version sensor import, fallback to old version try: from isaacsim.sensors.camera import Camera # type: ignore print("[CAMERA] Using isaacsim.sensors.camera") except ImportError: try: from omni.isaac.sensor import Camera # type: ignore print("[CAMERA] Using omni.isaac.sensor") except ImportError: print("[ERROR] Cannot import Camera class") raise from omni.isaac.core import World # type: ignore from omni.isaac.core.utils.stage import open_stage # type: ignore # Enable physics extensions try: import omni.isaac.core.utils.extensions as extensions extensions.enable_extension("omni.isaac.core") print(f"[EXTENSIONS] Enabled omni.isaac.core") except: try: import isaacsim.core.utils.extensions as extensions extensions.enable_extension("isaacsim.core") print(f"[EXTENSIONS] Enabled isaacsim.core") except Exception as e: print(f"[EXTENSIONS] WARN: Failed to enable core extension: {e}") # Try to enable physics extension try: import omni.kit.commands omni.kit.commands.execute('EnableExtension', id="omni.isaac.physics") print(f"[EXTENSIONS] Forced enable omni.isaac.physics") except Exception as e: print(f"[EXTENSIONS] Failed to force enable physics: {e}") try: extensions.enable_extension("isaacsim.physics") print(f"[EXTENSIONS] Enabled isaacsim.physics") except Exception as e2: print(f"[EXTENSIONS] WARN: Failed to enable physics extensions: {e2}") try: extensions.enable_extension("omni.isaac.dynamic_control") print(f"[EXTENSIONS] Enabled omni.isaac.dynamic_control") except Exception as e: print(f"[EXTENSIONS] WARN: Failed to enable dynamic control: {e}") self._UsdGeom = UsdGeom self._UsdPhysics = UsdPhysics self._Camera = Camera self._World = World self._open_stage = open_stage self._omni_usd = omni.usd self._omni_usd.get_context().close_stage() assert self._open_stage(usd_path=self.scene_usd_path), f"Failed to open stage: {self.scene_usd_path}" self.stage = self._omni_usd.get_context().get_stage() # World initialization with error handling try: print(f"[ISAAC_SIM] Initializing Isaac Sim World...") self.world = self._World() print(f"[ISAAC_SIM] Resetting World...") self.world.reset() print(f"[ISAAC_SIM] Running initialization steps...") for i in range(5): self.world.step(render=True) print(f"[ISAAC_SIM] Isaac Sim World initialization complete") except Exception as e: print(f"[ISAAC_SIM] ERROR: Isaac Sim World initialization failed: {e}") import traceback traceback.print_exc() raise # Set agent properties first self._pos = np.array([0.0, 0.0, 0.85], dtype=np.float32) # z=0.85: agent center height self._yaw = 0.0 self.agent_radius = 0.01 # Agent collision radius in meters # Cleanup existing camera and create new one with depth capability self._cleanup_existing_camera() self._create_simple_camera() # Verify physics system self._verify_physics_system() # Get scene bounds self._get_scene_bounds() def _cleanup_existing_camera(self) -> None: """Cleanup any existing camera to ensure fresh creation.""" try: if hasattr(self, 'cam'): try: self.cam = None except Exception as e: self.cam = None # Cleanup camera prim in USD stage if hasattr(self, 'stage') and self.stage: camera_paths = [ self.agent_prim_path + "/Camera", self.agent_prim_path, "/World/Camera" ] for cam_path in camera_paths: try: cam_prim = self.stage.GetPrimAtPath(cam_path) if cam_prim and cam_prim.IsValid(): self.stage.RemovePrim(cam_prim.GetPath()) except Exception as e: pass except Exception as e: pass def _ensure_depth_annotator_runtime(self) -> None: """Ensure depth annotator exists at runtime.""" try: self._log("[RUNTIME_DEPTH_FIX] Checking depth annotator...") # Check if current frame has depth data frame = self.cam.get_current_frame() available_keys = list(frame.keys()) if frame else [] self._log(f"[RUNTIME_DEPTH_FIX] Current frame keys: {available_keys}") if 'distance_to_image_plane' not in available_keys: self._log(f"[RUNTIME_DEPTH_FIX] No depth data, attempting fix...") # Try multiple depth annotator methods success = False # Method 1: add_distance_to_image_plane_to_frame if hasattr(self.cam, 'add_distance_to_image_plane_to_frame'): try: self._log("[RUNTIME_DEPTH_FIX] Trying to add distance_to_image_plane annotator...") self.cam.add_distance_to_image_plane_to_frame() # Configure Isaac Sim renderer for depth self._configure_isaac_sim_depth_rendering() # Verify success immediately self.world.step(render=True) new_frame = self.cam.get_current_frame() new_keys = list(new_frame.keys()) if new_frame else [] if 'distance_to_image_plane' in new_keys: # Check if depth data is valid test_depth = new_frame['distance_to_image_plane'] if test_depth is not None and hasattr(test_depth, 'std'): depth_std = test_depth.std() if hasattr(test_depth, 'std') else 0 if depth_std > 0.01: self._log("[RUNTIME_DEPTH_FIX] Successfully added valid depth annotator") success = True else: self._log(f"[RUNTIME_DEPTH_FIX] Depth annotator added but no data change, std={depth_std}") else: self._log("[RUNTIME_DEPTH_FIX] Depth annotator added but data invalid") else: self._log(f"[RUNTIME_DEPTH_FIX] Still no depth data after adding, new keys: {new_keys}") except Exception as e: self._log(f"[RUNTIME_DEPTH_FIX] Failed to add annotator: {e}") # Method 2: Try other annotator methods if not success: annotator_methods = [ 'add_distance_to_camera_to_frame', 'add_linear_depth_to_frame', 'add_depth_to_frame' ] for method_name in annotator_methods: if hasattr(self.cam, method_name): try: self._log(f"[RUNTIME_DEPTH_FIX] Trying {method_name}...") method = getattr(self.cam, method_name) method() # Verify self.world.step(render=True) test_frame = self.cam.get_current_frame() if test_frame and any('distance' in k or 'depth' in k for k in test_frame.keys()): self._log(f"[RUNTIME_DEPTH_FIX] Success") success = True break except Exception as e: self._log(f"[RUNTIME_DEPTH_FIX] Failed: {e}") # Method 3: Check camera depth methods if not success: self._log("[RUNTIME_DEPTH_FIX] Analyzing camera object...") depth_methods = [attr for attr in dir(self.cam) if 'depth' in attr.lower() or 'distance' in attr.lower()] self._log(f"[RUNTIME_DEPTH_FIX] Available depth methods: {depth_methods}") annotator_methods = [attr for attr in dir(self.cam) if 'add' in attr.lower() and ('annotator' in attr.lower() or 'frame' in attr.lower())] self._log(f"[RUNTIME_DEPTH_FIX] Available annotator methods: {annotator_methods}") if not success: self._log("[RUNTIME_DEPTH_FIX] All depth annotator methods failed") else: self._log("[RUNTIME_DEPTH_FIX] Depth annotator exists, verifying data...") # Even with annotator, check if data is valid depth_data = frame.get('distance_to_image_plane') if depth_data is not None: self._log(f"[RUNTIME_DEPTH_FIX] Depth data type: {type(depth_data)}, valid: {hasattr(depth_data, 'shape')}") else: self._log("[RUNTIME_DEPTH_FIX] Depth annotator exists but data is None") except Exception as e: self._log(f"[RUNTIME_DEPTH_FIX] Runtime depth fix failed: {e}") import traceback self._log(f"[RUNTIME_DEPTH_FIX] Error details: {traceback.format_exc()}") def _force_refresh_depth_pipeline(self) -> None: """Force refresh depth rendering pipeline.""" try: self._log("[DEPTH_PIPELINE] Force refreshing depth pipeline...") # Method 1: Reset camera depth config if hasattr(self, 'cam') and self.cam: try: # Get current camera info cam_pos, cam_rot = self.cam.get_world_pose() self._log(f"[DEPTH_PIPELINE] Current camera position: {cam_pos}") # Force clear and re-add depth annotator try: # Clear existing depth annotator frame = self.cam.get_current_frame() if frame: depth_keys = [k for k in frame.keys() if 'depth' in k.lower() or 'distance' in k.lower()] self._log(f"[DEPTH_PIPELINE] Found existing depth keys: {depth_keys}") # Re-add distance_to_image_plane self.cam.add_distance_to_image_plane_to_frame() self._log("[DEPTH_PIPELINE] Re-added distance_to_image_plane annotator") except Exception as e: self._log(f"[DEPTH_PIPELINE] Failed to re-add annotator: {e}") except Exception as e: self._log(f"[DEPTH_PIPELINE] Camera depth config failed: {e}") # Method 2: Force reset collision mesh try: self._log("[DEPTH_PIPELINE] Force resetting collision mesh...") self.set_collision_mesh_visibility(False) for i in range(2): self.world.step(render=True) self.set_collision_mesh_visibility(True) for i in range(2): self.world.step(render=True) self._log("[DEPTH_PIPELINE] Collision mesh reset complete") except Exception as e: self._log(f"[DEPTH_PIPELINE] Collision mesh reset failed: {e}") # Method 3: Try Isaac Sim renderer reconfiguration try: self._log("[DEPTH_PIPELINE] Reconfiguring Isaac Sim renderer...") # Reconfigure depth rendering self._configure_isaac_sim_depth_rendering() # Force multiple renders to stabilize for i in range(3): self.world.step(render=True) self._log("[DEPTH_PIPELINE] Renderer reconfiguration complete") except Exception as e: self._log(f"[DEPTH_PIPELINE] Renderer reconfiguration failed: {e}") self._log("[DEPTH_PIPELINE] Depth pipeline refresh complete") except Exception as e: self._log(f"[DEPTH_PIPELINE] Depth pipeline refresh failed: {e}") import traceback self._log(f"[DEPTH_PIPELINE] Error details: {traceback.format_exc()}") def _configure_isaac_sim_depth_rendering(self) -> None: """Configure Isaac Sim depth rendering for 3DGS+collision mesh scenes.""" try: self._log("[DEPTH_CONFIG] Configuring 3DGS scene depth rendering...") # Key fix: make collision mesh visible for depth self._make_collision_mesh_visible_for_depth() # Method 1: Configure renderer via carb settings try: import carb.settings settings = carb.settings.get_settings() # Enable depth rendering settings.set("/renderer/enabled", True) settings.set("/renderer/asyncRenderEnabled", False) settings.set("/rtx/rendermode", "RayTracedLighting") settings.set("/rtx/pathtracing/enabled", False) # Force enable depth buffer settings.set("/renderer/depth/enabled", True) settings.set("/renderer/depth/format", "float32") self._log("[DEPTH_CONFIG] carb settings configured") except Exception as e: self._log(f"[DEPTH_CONFIG] carb settings failed: {e}") # Method 2: Configure camera clipping range try: if hasattr(self, 'usd_cam') and self.usd_cam: # Set reasonable near/far clipping planes self.usd_cam.GetClippingRangeAttr().Set((0.01, 50.0)) self._log("[DEPTH_CONFIG] Camera clipping range set to(0.01, 50.0)") elif hasattr(self, 'cam') and self.cam: # Try via Isaac Sim camera API if hasattr(self.cam, 'set_clipping_range'): self.cam.set_clipping_range(0.01, 50.0) self._log("[DEPTH_CONFIG] Isaac Sim camera clipping range set") except Exception as e: self._log(f"[DEPTH_CONFIG] Camera clipping range setting failed: {e}") # Method 3: Force refresh renderer try: if hasattr(self, 'world') and self.world: # Multiple renders to ensure config takes effect for i in range(3): self.world.step(render=True) self._log("[DEPTH_CONFIG] Renderer refresh complete") except Exception as e: self._log(f"[DEPTH_CONFIG] Renderer refresh failed: {e}") except Exception as e: self._log(f"[DEPTH_CONFIG] Depth rendering config failed: {e}") def _make_collision_mesh_visible_for_depth(self) -> None: """Make collision mesh visible for depth rendering.""" try: self._log("[COLLISION_DEPTH] Finding and configuring collision mesh for depth...") # Find collision mesh path - based on USDA file structure collision_paths = [ "/World/scene_collision", "/World/collision", "/collision", "/World/Collision", "/Collision", "/World/collision_mesh", "/collision_mesh" ] found_collision = False for collision_path in collision_paths: try: collision_prim = self.stage.GetPrimAtPath(collision_path) if collision_prim and collision_prim.IsValid(): self._log(f"[COLLISION_DEPTH] Found collision mesh: {collision_path}") # Key fix: make entire collision prim visible for depth from pxr import UsdGeom # First make collision root prim visible try: imageable = UsdGeom.Imageable(collision_prim) current_visibility = imageable.GetVisibilityAttr().Get() self._log(f"[COLLISION_DEPTH] Current collision visibility: {current_visibility}") # Set visible (allows depth rendering) imageable.GetVisibilityAttr().Set(UsdGeom.Tokens.visible) self._log(f"[COLLISION_DEPTH] Set collision root prim visible") except Exception as e: self._log(f"[COLLISION_DEPTH] Failed to set root prim visibility: {e}") # Recursively ensure all child meshes visible def make_mesh_visible_for_depth(prim): try: # Set visibility for all prims if hasattr(prim, 'GetTypeName'): prim_type = prim.GetTypeName() prim_path = str(prim.GetPath()) if prim_type in ['Mesh', 'Xform', 'Scope']: imageable = UsdGeom.Imageable(prim) if imageable: imageable.GetVisibilityAttr().Set(UsdGeom.Tokens.visible) self._log(f"[COLLISION_DEPTH] Set visible: {prim_path} ({prim_type})") # Recursively process child prims for child in prim.GetChildren(): make_mesh_visible_for_depth(child) except Exception as e: self._log(f"[COLLISION_DEPTH] Failed to configure child prim {prim.GetPath()}: {e}") # Apply to all child prims make_mesh_visible_for_depth(collision_prim) found_collision = True self._log(f"[COLLISION_DEPTH] Successfully configured collision and child meshes for depth") break except Exception as e: self._log(f"[COLLISION_DEPTH] Failed to check path: {e}") if not found_collision: self._log("[COLLISION_DEPTH] Collision mesh not found, searching all meshes...") # Search entire scene for meshes self._find_and_configure_all_meshes() except Exception as e: self._log(f"[COLLISION_DEPTH] Collision mesh config failed: {e}") def _find_and_configure_all_meshes(self) -> None: """Find and configure all meshes in scene for depth rendering.""" try: from pxr import UsdGeom, Usd self._log("[MESH_SEARCH] Searching all meshes in scene...") # Search entire stage for meshes def traverse_and_configure(prim): try: if prim.GetTypeName() == 'Mesh': mesh_path = str(prim.GetPath()) self._log(f"[MESH_SEARCH] Found mesh: {mesh_path}") # Make mesh visible and configure for depth imageable = UsdGeom.Imageable(prim) imageable.GetVisibilityAttr().Set(UsdGeom.Tokens.visible) # Mark collision-related paths specially if any(word in mesh_path.lower() for word in ['collision', 'physics', 'collider']): self._log(f"[MESH_SEARCH] Configured collision mesh for depth: {mesh_path}") else: self._log(f"[MESH_SEARCH] Configured regular mesh for depth: {mesh_path}") # Recursively process child prims for child in prim.GetChildren(): traverse_and_configure(child) except Exception as e: self._log(f"[MESH_SEARCH] Failed to process prim {prim.GetPath()}: {e}") # Start search from root root_prim = self.stage.GetDefaultPrim() if root_prim: traverse_and_configure(root_prim) else: # If no default prim, start from /World world_prim = self.stage.GetPrimAtPath("/World") if world_prim: traverse_and_configure(world_prim) self._log("[MESH_SEARCH] Mesh search and config complete") except Exception as e: self._log(f"[MESH_SEARCH] Mesh search failed: {e}") def set_collision_mesh_visibility(self, visible: bool) -> None: """Force set collision mesh visibility. Args: visible (bool): True for visible (depth), False for invisible (RGB) """ try: action = "enable" if visible else "disable" self._log(f"[COLLISION_VIS] Force setting collision mesh visibility...") # Find collision mesh paths (extended search) collision_paths = [ "/World/scene_collision", "/World/collision", "/collision", "/World/Collision", "/Collision", "/World/collision_mesh", "/collision_mesh", "/scene_collision" ] from pxr import UsdGeom collision_prims_found = [] # Find all collision prims for coll_path in collision_paths: try: collision_prim = self.stage.GetPrimAtPath(coll_path) if collision_prim and collision_prim.IsValid(): collision_prims_found.append((coll_path, collision_prim)) self._log(f"[COLLISION_VIS] Found collision: {coll_path}") except Exception as e: continue if not collision_prims_found: self._log("[COLLISION_VIS] No collision mesh found, searching all collision paths...") # If not found, search scene for collision paths from pxr import Usd def search_collision_recursive(prim, path=""): current_path = str(prim.GetPath()) if "collision" in current_path.lower(): self._log(f"[COLLISION_SEARCH] Found possible collision path: {current_path}") return [current_path] found_paths = [] for child in prim.GetChildren(): found_paths.extend(search_collision_recursive(child, current_path)) return found_paths all_collision_paths = search_collision_recursive(self.stage.GetPseudoRoot()) if all_collision_paths: self._log(f"[COLLISION_SEARCH] Found collision-related paths: {all_collision_paths}") # Try these paths for found_path in all_collision_paths[:3]: try: collision_prim = self.stage.GetPrimAtPath(found_path) if collision_prim and collision_prim.IsValid(): collision_prims_found.append((found_path, collision_prim)) self._log(f"[COLLISION_VIS] Dynamically found collision: {found_path}") except Exception as e: continue if not collision_prims_found: self._log("[COLLISION_VIS] No collision mesh found, depth may be invalid") return # Set visibility for each found collision prim for coll_path, collision_prim in collision_prims_found: try: # Force set root prim visibility imageable = UsdGeom.Imageable(collision_prim) if visible: imageable.GetVisibilityAttr().Set(UsdGeom.Tokens.visible) self._log(f"[COLLISION_VIS] Set visible") else: imageable.GetVisibilityAttr().Set(UsdGeom.Tokens.invisible) self._log(f"[COLLISION_VIS] Set invisible") # Recursively force set all children def force_set_visibility(prim, vis_state): try: # Set visibility for all prim types child_imageable = UsdGeom.Imageable(prim) if child_imageable: if vis_state: child_imageable.GetVisibilityAttr().Set(UsdGeom.Tokens.visible) else: child_imageable.GetVisibilityAttr().Set(UsdGeom.Tokens.invisible) # Recursively process all child prims for child in prim.GetChildren(): force_set_visibility(child, vis_state) except Exception: pass # Apply to all children force_set_visibility(collision_prim, visible) except Exception as e: self._log(f"[COLLISION_VIS] Failed to set: {e}") # Multiple force renders to ensure settings take effect if hasattr(self, 'world') and self.world: for i in range(3): self.world.step(render=True) self._log(f"[COLLISION_VIS] Collision mesh visibility set") except Exception as e: self._log(f"[COLLISION_VIS] Failed to set collision mesh visibility: {e}") def _create_simple_camera(self) -> None: """Create agent with physics body and camera.""" print("[CAMERA_CREATE] Creating camera...") print(f"[CAMERA_CREATE] agent_prim_path: {self.agent_prim_path}") print(f"[CAMERA_CREATE] resolution: {self.resolution}") print(f"[CAMERA_CREATE] hz: {self.hz}") try: # Create agent parent Xform agent_xform = self._UsdGeom.Xform.Define(self.stage, self.agent_prim_path) # Create agent physics collision body (cylinder) collision_cylinder_path = self.agent_prim_path + "/CollisionCylinder" collision_cylinder = self._UsdGeom.Cylinder.Define(self.stage, collision_cylinder_path) collision_cylinder.CreateRadiusAttr(0.1) collision_cylinder.CreateHeightAttr(0.5) collision_cylinder.CreateAxisAttr("Z") # Set collision body position collision_cylinder.AddTranslateOp().Set((0.0, 0.0, 0.0)) # Make collision body invisible but keep geometry collision_cylinder.CreateVisibilityAttr("invisible") _debug_print(f"[PHYSICS] Created collision cylinder: radius=0.1m, height=0.5m, bottom_clearance=0.5m") # Add physics properties to agent agent_rigid_body = self._UsdPhysics.RigidBodyAPI.Apply(agent_xform.GetPrim()) # Use kinematic mode with collision detection agent_rigid_body.CreateKinematicEnabledAttr(True) _debug_print(f"[PHYSICS] Using kinematic rigid body with physics-based collision response") # Try to set mass and other attributes try: agent_rigid_body.CreateMassAttr(1.0) _debug_print(f"[PHYSICS] Set mass to 1.0") except: try: # New version may use different methods if hasattr(agent_rigid_body, 'CreateMassAttr'): agent_rigid_body.CreateMassAttr(1.0) else: _debug_print(f"[PHYSICS] WARN: CreateMassAttr not available") except Exception as e: _debug_print(f"[PHYSICS] WARN: Failed to set mass: {e}") try: agent_rigid_body.CreateRigidBodyEnabledAttr(True) _debug_print(f"[PHYSICS] Enabled rigid body") except: try: # New version may use different methods if hasattr(agent_rigid_body, 'CreateRigidBodyEnabledAttr'): agent_rigid_body.CreateRigidBodyEnabledAttr(True) else: _debug_print(f"[PHYSICS] WARN: CreateRigidBodyEnabledAttr not available") except Exception as e: _debug_print(f"[PHYSICS] WARN: Failed to enable rigid body: {e}") # Add collision attributes to cylinder collision_api = self._UsdPhysics.CollisionAPI.Apply(collision_cylinder.GetPrim()) # Add collision shape try: # Use geometric cylinder as collision body collision_shape = collision_cylinder _debug_print(f"[PHYSICS] Using geometric cylinder as collision shape") # Ensure collision body is recognized collision_api.CreateCollisionEnabledAttr(True) _debug_print(f"[PHYSICS] Enabled collision detection") # Store collision shape reference self.collision_shape_prim = collision_cylinder self.collision_cylinder_prim = collision_cylinder except Exception as e: _debug_print(f"[PHYSICS] WARN: Failed to setup collision: {e}") self.collision_shape_prim = None self.collision_cylinder_prim = None # Set collision filtering try: collision_api.CreateCollisionEnabledAttr(True) _debug_print(f"[PHYSICS] Enabled collision detection") except Exception as e: _debug_print(f"[PHYSICS] WARN: Failed to enable collision: {e}") # Create Isaac Sim camera try: # Create camera prim path camera_path = self.agent_prim_path + "/Camera" # Define USD camera prim camera_prim = self._UsdGeom.Camera.Define(self.stage, camera_path) # Create Isaac Sim camera object with depth self.cam = self._Camera( prim_path=camera_path, frequency=self.hz, resolution=self.resolution ) # Add depth annotator before initialization try: # Method 1: add_distance_to_image_plane_to_frame if hasattr(self.cam, 'add_distance_to_image_plane_to_frame'): self.cam.add_distance_to_image_plane_to_frame() print("[CAMERA] Added distance_to_image_plane annotator") # Method 2: add_distance_to_camera_to_frame (fallback) elif hasattr(self.cam, 'add_distance_to_camera_to_frame'): self.cam.add_distance_to_camera_to_frame() print("[CAMERA] Added distance_to_camera annotator") # Method 3: Generic annotator method elif hasattr(self.cam, 'add_annotator'): self.cam.add_annotator("distance_to_image_plane") print("[CAMERA] Added depth annotator via generic method") else: print("[CAMERA] Camera does not support depth annotator methods") # List available methods annotator_methods = [m for m in dir(self.cam) if 'add' in m.lower() and ('distance' in m.lower() or 'depth' in m.lower() or 'annotator' in m.lower())] print(f"[CAMERA] Available annotator methods: {annotator_methods}") except Exception as e: print(f"[CAMERA] Failed to add depth annotator: {e}") self.cam.initialize() # Verify annotator was added try: # Render one frame to activate annotator if hasattr(self, 'world') and self.world: self.world.step(render=True) frame = self.cam.get_current_frame() available_keys = list(frame.keys()) if frame else [] print(f"[CAMERA] Camera frame available data: {available_keys}") if 'distance_to_image_plane' in available_keys: print("[CAMERA] Depth annotator verified") else: print("[CAMERA] Depth annotator verification failed") except Exception as e: print(f"[CAMERA] Annotator verification failed: {e}") # Get camera prim and USD camera self.cam_prim = self.stage.GetPrimAtPath(camera_path) self.usd_cam = self._UsdGeom.Camera(self.cam_prim) # Set camera parameters for depth try: # Set reasonable clipping range self.usd_cam.GetClippingRangeAttr().Set((0.1, 50.0)) print("[CAMERA] Set camera clipping range (0.1, 50.0)") except Exception as e: print(f"[CAMERA] Failed to set clipping range: {e}") # Set camera parameters self.usd_cam.GetFocalLengthAttr().Set(8.0) print(f"[INFO] Created Isaac Sim camera at: {camera_path}") except Exception as e: print(f"[ERROR] Failed to create camera: {e}") import traceback traceback.print_exc() self.cam = None self.cam_prim = None self.usd_cam = None # Store references self.agent_prim = agent_xform.GetPrim() self.collision_cylinder_prim = collision_cylinder.GetPrim() self.collision_shape_prim = collision_cylinder.GetPrim() print(f"[INFO] Created agent with physics: cylinder radius=0.01m, height=0.7m, camera at z=1.2m, focal_length=8.0") print(f"[INFO] Physics enabled: RigidBody={agent_rigid_body.GetRigidBodyEnabledAttr().Get()}, Collision={collision_api.GetCollisionEnabledAttr().Get()}") # Setup physics scene self._setup_physics_scene() # Verify physics config self._verify_agent_physics() # Verify collision system self._verify_collision_system() except Exception as e: print(f"[ERROR] Failed to create agent with physics: {e}") # If failed, fallback to simple camera try: # Cleanup previously created prims if hasattr(self, 'agent_prim') and self.agent_prim: try: import omni.usd omni.usd.delete_prim(self.stage, self.agent_prim.GetPath()) print(f"[CLEANUP] Removed failed agent prim") except: pass # Create simple camera prim camera_prim = self._UsdGeom.Camera.Define(self.stage, self.agent_prim_path) # Create Isaac Sim camera object self.cam = self._Camera(prim_path=self.agent_prim_path, frequency=self.hz, resolution=self.resolution) self.cam.initialize() # Set camera attributes self.cam_prim = self.stage.GetPrimAtPath(self.agent_prim_path) self.usd_cam = self._UsdGeom.Camera(self.cam_prim) self.usd_cam.GetFocalLengthAttr().Set(8.0) # Set agent reference self.agent_prim = camera_prim.GetPrim() self.collision_cylinder_prim = None self.collision_shape_prim = None print(f"[WARN] Fallback to simple camera without physics") except Exception as e2: print(f"[ERROR] Failed to create fallback camera: {e2}") raise e2 def _verify_physics_system(self) -> None: """Verify physics system initialization.""" try: print(f"[PHYSICS_VERIFY] Checking physics system status...") # Check world object if hasattr(self, 'world') and self.world: print(f"[PHYSICS_VERIFY] World object: {type(self.world)}") else: print(f"[PHYSICS_VERIFY] WARN: No world object") # Check agent prim if hasattr(self, 'agent_prim') and self.agent_prim: print(f"[PHYSICS_VERIFY] Agent prim: {self.agent_prim.GetPath()}") # Check rigid body attributes rigid_body = self._UsdPhysics.RigidBodyAPI(self.agent_prim) if rigid_body: try: enabled = rigid_body.GetRigidBodyEnabledAttr().Get() kinematic = rigid_body.GetKinematicEnabledAttr().Get() print(f"[PHYSICS_VERIFY] RigidBody: enabled={enabled}, kinematic={kinematic}") except Exception as e: print(f"[PHYSICS_VERIFY] RigidBody: API available but failed to get attributes: {e}") else: print(f"[PHYSICS_VERIFY] WARN: No RigidBody API") else: print(f"[PHYSICS_VERIFY] WARN: No agent prim") # Check collision body if hasattr(self, 'collision_shape_prim') and self.collision_shape_prim: print(f"[PHYSICS_VERIFY] Collision shape: {self.collision_shape_prim.GetPath()}") # Check collision attributes try: collision_api = self._UsdPhysics.CollisionAPI(self.collision_shape_prim) if collision_api: try: enabled = collision_api.GetCollisionEnabledAttr().Get() print(f"[PHYSICS_VERIFY] Collision: enabled={enabled}") except Exception as e: print(f"[PHYSICS_VERIFY] Collision: API available but failed to get enabled attribute: {e}") else: print(f"[PHYSICS_VERIFY] WARN: No Collision API") except Exception as e: print(f"[PHYSICS_VERIFY] WARN: Failed to create Collision API: {e}") else: print(f"[PHYSICS_VERIFY] WARN: No collision shape prim") print(f"[PHYSICS_VERIFY] Physics system verification complete") except Exception as e: print(f"[PHYSICS_VERIFY] ERROR: Failed to verify physics system: {e}") def _get_scene_bounds(self) -> None: """Get scene bounds information.""" try: print(f"[SCENE_BOUNDS] Analyzing scene boundaries...") # Traverse all geometry to find bounds stage = self.stage if stage: # Get scene root path root_path = stage.GetPseudoRoot().GetPath() # Traverse all prims in scene all_prims = [] def collect_prims(prim): all_prims.append(prim) for child in prim.GetChildren(): collect_prims(child) collect_prims(stage.GetPseudoRoot()) # Find all prims with geometry geom_prims = [p for p in all_prims if p.IsA(self._UsdGeom.Gprim)] if geom_prims: # Calculate bounding box for all geometry min_x, min_y, min_z = float('inf'), float('inf'), float('inf') max_x, max_y, max_z = float('-inf'), float('-inf'), float('-inf') for prim in geom_prims: try: # Get prim bounding box bbox = self._UsdGeom.ComputeBoundingBox(prim, 0) if bbox: min_x = min(min_x, bbox.GetMin()[0]) min_y = min(min_y, bbox.GetMin()[1]) min_z = min(min_z, bbox.GetMin()[2]) max_x = max(max_x, bbox.GetMax()[0]) max_y = max(max_y, bbox.GetMax()[1]) max_z = max(max_z, bbox.GetMax()[2]) except: continue if min_x != float('inf'): self.scene_bounds = { 'x': (min_x, max_x), 'y': (min_y, max_y), 'z': (min_z, max_z) } print(f"[SCENE_BOUNDS] Scene bounds: x=[{min_x:.2f}, {max_x:.2f}], y=[{min_y:.2f}, {max_y:.2f}], z=[{min_z:.2f}, {max_z:.2f}]") else: print(f"[SCENE_BOUNDS] WARN: Could not determine scene bounds") self.scene_bounds = {'x': (-5, 5), 'y': (-12, 3), 'z': (0, 3)} else: print(f"[SCENE_BOUNDS] WARN: No geometric prims found in scene") self.scene_bounds = {'x': (-5, 5), 'y': (-12, 3), 'z': (0, 3)} else: print(f"[SCENE_BOUNDS] WARN: No stage available") self.scene_bounds = {'x': (-5, 5), 'y': (-12, 3), 'z': (0, 3)} except Exception as e: print(f"[SCENE_BOUNDS] ERROR: Failed to get scene bounds: {e}") self.scene_bounds = {'x': (-5, 5), 'y': (-12, 3), 'z': (0, 3)} def load_scene(self, new_scene_usd_path: str) -> bool: """ Switch to new scene. Args: new_scene_usd_path: Path to new scene USD file Returns: bool: Whether scene was loaded successfully """ try: print(f"[SCENE_SWITCH] Switching scene...") print(f"[SCENE_SWITCH] Current scene: {self.scene_usd_path}") print(f"[SCENE_SWITCH] New scene: {new_scene_usd_path}") # Update scene path self.scene_usd_path = str(Path(new_scene_usd_path).resolve()) # Switch scene via sim object if hasattr(self.sim, 'load_scene'): return self.sim.load_scene(new_scene_usd_path) else: print(f"[SCENE_SWITCH] sim object does not support scene switching") return False except Exception as e: print(f"[SCENE_SWITCH] Scene switch failed: {e}") import traceback traceback.print_exc() return False def update_map(self, new_map_path: str) -> bool: """ Dynamically update 2D semantic map. Args: new_map_path: Path to new 2D semantic map file Returns: bool: Whether update was successful """ try: print(f"[MAP_SWITCH] Switching map...") print(f"[MAP_SWITCH] Current map: {self._map_json_path}") print(f"[MAP_SWITCH] New map: {new_map_path}") # Update map path self._map_json_path = new_map_path self.semantic_map_path = new_map_path # Reinitialize collision detector self._init_collision_detector(new_map_path) print(f"[MAP_SWITCH] Map switch successful") return True except Exception as e: print(f"[MAP_SWITCH] Map switch failed: {e}") import traceback traceback.print_exc() return False def close(self) -> None: self.sim.close() def set_start_pose(self, position: List[float], rotation_xyzw: List[float]) -> None: # Reset episode state self.is_stop_called = False self.consecutive_collisions = 0 self._total_collision_count = 0 # Reset total collision count for new episode self._log(f"[EPISODE_RESET] Reset episode state") self._pos = np.array(position, dtype=np.float32) # rotation_xyzw = [x,y,z,w] - standard quaternion format x, y, z, w = rotation_xyzw # Save original quaternion for camera orientation self._original_quaternion = rotation_xyzw.copy() # Calculate yaw from trajectory quaternion # Based on trajectory transform inverse mapping: # 1. Inverse coord mapping: qz_original = -qx, qw_original = qw # 2. Calculate yaw_new = 2 * atan2(qz_original, qw_original) # 3. Inverse angle offset: yaw_final = yaw_new - pi qz_original = -x qw_original = w yaw_new = 2 * math.atan2(qz_original, qw_original) self._yaw = yaw_new - math.pi # Ensure angle in [-pi, pi] range if self._yaw < -math.pi: self._yaw += 2 * math.pi elif self._yaw > math.pi: self._yaw -= 2 * math.pi # Record initial yaw for camera orientation self._initial_yaw = self._yaw # Debug coordinate transformation self._log(f"[DEBUG] Setting start pose:") self._log(f"[DEBUG] Input position: {position}") self._log(f"[DEBUG] Input rotation: {rotation_xyzw}") self._log(f"[DEBUG] qz_original: {qz_original:.3f}, qw_original: {qw_original:.3f}") self._log(f"[DEBUG] Final position: {self._pos}") self._apply_pose() for _ in range(5): self.world.step(render=True) def _update_camera_position(self) -> None: """Update camera position to follow agent.""" try: # Use current self._pos # Set camera at agent eye height if hasattr(self, 'cam') and self.cam: camera_pos = self._pos.copy() camera_pos[2] = 1.2 # Camera orientation calculation if hasattr(self, '_original_quaternion') and hasattr(self, '_initial_yaw'): # Case 1: Dynamic turning - incremental adjustment # Calculate angle change relative to initial yaw yaw_delta = self._yaw - self._initial_yaw # Use original quaternion + 45 degree correction qx_orig, qy_orig, qz_orig, qw_orig = self._original_quaternion angle_correction = math.radians(-45) qx_correction = math.sin(angle_correction/2) # Base orientation base_qx = qx_orig + qx_correction base_qy = qy_orig base_qz = qz_orig base_qw = qw_orig # If yaw changed, use quaternion multiplication if abs(yaw_delta) > 0.01: # Calculate yaw change quaternion qz_delta_tmp = math.sin(yaw_delta/2.0) qw_delta_tmp = math.cos(yaw_delta/2.0) # Quaternion multiplication (simplified) qx = base_qx * qw_delta_tmp + base_qw * (-qz_delta_tmp) qy = base_qy * qw_delta_tmp qz = base_qz * qw_delta_tmp qw = base_qw * qw_delta_tmp - base_qx * (-qz_delta_tmp) else: # No significant change, use base orientation qx, qy, qz, qw = base_qx, base_qy, base_qz, base_qw orientation = np.array([qx, qy, qz, qw], dtype=np.float32) # Debug output elif hasattr(self, '_original_quaternion'): # Case 2: Initial state qx_orig, qy_orig, qz_orig, qw_orig = self._original_quaternion angle_correction = math.radians(-45) qx_correction = math.sin(angle_correction/2) qx = qx_orig + qx_correction qy = qy_orig qz = qz_orig qw = qw_orig orientation = np.array([qx, qy, qz, qw], dtype=np.float32) else: # Case 3: Fallback qz_tmp = math.sin(self._yaw/2.0) qw_tmp = math.cos(self._yaw/2.0) qx = -qz_tmp qy = 0.0 qz = 0.0 qw = qw_tmp orientation = np.array([qx, qy, qz, qw], dtype=np.float32) if not hasattr(self, '_last_yaw') or abs(self._last_yaw - self._yaw) > 0.01: if hasattr(self, '_initial_yaw'): yaw_delta = self._yaw - self._initial_yaw else: pass if hasattr(self, '_original_quaternion'): pass self._last_yaw = self._yaw # Set camera position directly try: self.cam.set_world_pose(position=camera_pos.astype(np.float32), orientation=orientation) except Exception as e: pass # Update agent physics position (if available) if hasattr(self, 'agent_prim') and self.agent_prim: try: xform = self._UsdGeom.Xform(self.agent_prim) xform.ClearXformOpOrder() translate_op = xform.AddTranslateOp() translate_op.Set(tuple(self._pos)) rotate_op = xform.AddRotateZOp() rotate_op.Set(math.degrees(self._yaw)) except Exception as e: pass if not hasattr(self, '_camera_log_count'): self._camera_log_count = 0 self._last_logged_pos = self._pos[:2].copy() self._camera_log_count += 1 distance_moved = np.linalg.norm(self._pos[:2] - self._last_logged_pos) if distance_moved > 0.1 or self._camera_log_count >= 50: _debug_print(f"[CAMERA_UPDATE] Step #{self._camera_log_count}: Camera at {camera_pos[:2]} (moved: {distance_moved:.3f}m)") self._last_logged_pos = self._pos[:2].copy() self._camera_log_count = 0 except Exception as e: print(f"[CAMERA_UPDATE_ERROR] Failed to update camera: {e}") def _apply_pose(self) -> None: """Apply position and orientation to physics system.""" # Calculate orientation qx = -math.sin(self._yaw/2.0) qy = 0.0 qz = 0.0 qw = math.cos(self._yaw/2.0) orientation = np.array([qx,qy,qz,qw], dtype=np.float32) # Set agent position if hasattr(self, 'agent_prim') and self.agent_prim: try: # Force set position xform = self._UsdGeom.Xform(self.agent_prim) xform.ClearXformOpOrder() translate_op = xform.AddTranslateOp() translate_op.Set(tuple(self._pos)) rotate_op = xform.AddRotateZOp() rotate_op.Set(math.degrees(self._yaw)) except Exception as e: print(f"[WARN] Failed to apply pose: {e}") # Update camera position self._update_camera_position() # Run physics step to update scene if hasattr(self, 'world'): self.world.step(render=True) def get_agent_pos(self) -> np.ndarray: return self._pos.copy() def get_rgb(self) -> np.ndarray: if hasattr(self, 'cam') and self.cam: try: # RGB capture: force disable collision mesh self.set_collision_mesh_visibility(False) # Ensure settings take effect: multiple updates self._update_camera_position() for i in range(2): self.world.step(render=True) cam_pos, cam_orientation = self.cam.get_world_pose() # Get RGB image img = self.cam.get_rgba() # 在get_rgb()里加一行临时调试 # print(f"[DEBUG_RGB] rgba sample: {img[0,0]}, shape: {img.shape}, unique values: {len(set(img.reshape(-1,4).tobytes()))}") if img is None or img.size == 0: return None # Process image rgb_img = img[:, :, :3].astype(np.uint8) return rgb_img except Exception as e: return None else: return np.zeros((480, 640, 3), dtype=np.uint8) def get_depth(self) -> np.ndarray: """Get depth image.""" if hasattr(self, 'cam') and self.cam: try: # Depth capture: force enable collision mesh self.set_collision_mesh_visibility(True) # Ensure settings take effect: multiple updates self._update_camera_position() for i in range(2): self.world.step(render=True) # Force refresh depth pipeline self._force_refresh_depth_pipeline() # Get depth image depth_img = None # Try multiple Isaac Sim depth methods # Method 1: Get depth via annotator if depth_img is None: try: frame = self.cam.get_current_frame() if frame and 'distance_to_image_plane' in frame: depth_img = frame['distance_to_image_plane'] # Convert to numpy if hasattr(depth_img, 'cpu'): depth_img = depth_img.cpu().numpy() depth_img = np.array(depth_img, dtype=np.float32) else: available_keys = list(frame.keys()) if frame else [] except Exception as e: pass # Method 2: Get depth via Isaac Sim Replicator if depth_img is None: try: # New Isaac Sim version uses replicator import omni.replicator.core as rep # Create replicator camera for depth with rep.new_layer(): rep_camera = rep.create.camera( position=(0, 0, 0), look_at=(0, 0, -1) ) # Get depth rendering render_products = rep.create.render_product(rep_camera, self.resolution) depth_annotator = rep.AnnotatorRegistry.get_annotator("distance_to_image_plane") depth_annotator.attach([render_products]) # Render and get depth rep.orchestrator.step() depth_data = depth_annotator.get_data() if depth_data is not None and len(depth_data) > 0: depth_img = np.array(depth_data, dtype=np.float32) else: pass except Exception as e: pass # Method 2b: Try traditional SyntheticData API if depth_img is None: try: import omni.syntheticdata._syntheticdata as sd # Get current viewport depth data depth_img = sd.get_depth_linear(viewport_name="Viewport") if depth_img is not None and depth_img.size > 0: depth_img = np.array(depth_img, dtype=np.float32) else: pass except Exception as e: pass # Method 3: Get depth buffer via USD renderer if depth_img is None: try: # Get depth directly from USD renderer from pxr import UsdRender import omni.usd stage = omni.usd.get_context().get_stage() # Get render settings render_settings = UsdRender.Settings.GetStage(stage) if render_settings: # Force enable depth output render_settings.CreateEnabledAttr().Set(True) # Try to get depth data from camera prim cam_prim = stage.GetPrimAtPath(self.cam.prim_path) if cam_prim: # Check if camera has depth attribute if cam_prim.HasAttribute("depth"): depth_attr = cam_prim.GetAttribute("depth") depth_img = depth_attr.Get() if depth_img is not None: depth_img = np.array(depth_img, dtype=np.float32) except Exception as e: pass # Method 4: Try direct camera method calls if depth_img is None: depth_methods = ['get_distance_to_image_plane', 'get_depth_data', 'get_depth', 'get_linear_depth'] for method_name in depth_methods: if hasattr(self.cam, method_name): try: method = getattr(self.cam, method_name) depth_img = method() if depth_img is not None and hasattr(depth_img, 'size') and depth_img.size > 0: if hasattr(depth_img, 'cpu'): depth_img = depth_img.cpu().numpy() depth_img = np.array(depth_img, dtype=np.float32) break else: pass except Exception as e: pass continue # Method 5: Final depth generation fallback if depth_img is None: try: # If all methods fail, generate pseudo depth # Generate simple depth based on camera position height, width = self.resolution[1], self.resolution[0] # Create simple linear depth map y, x = np.ogrid[:height, :width] center_y, center_x = height // 2, width // 2 # Distance from center dist_from_center = np.sqrt((x - center_x)**2 + (y - center_y)**2) max_dist = np.sqrt(center_x**2 + center_y**2) # Normalize to depth range [1.0, 6.0] meters depth_img = 1.0 + 5.0 * (dist_from_center / max_dist) depth_img = depth_img.astype(np.float32) except Exception as e: pass depth_img = None # Method 3: Debug info if depth_img is None: # Log camera object structure if hasattr(self.cam, 'data'): data_attrs = [attr for attr in dir(self.cam.data) if not attr.startswith('_')] available_methods = [attr for attr in dir(self.cam) if 'depth' in attr.lower() or 'distance' in attr.lower()] return None if depth_img is None or depth_img.size == 0: self._log(f"[WARN] Camera returned None/empty depth image") return None # Ensure depth image is correct format # Isaac Sim depth is usually float in meters depth_img = depth_img.astype(np.float32) # Limit depth range depth_img = np.clip(depth_img, 0.1, 6.5) return depth_img except Exception as e: self._log(f"[WARN] Failed to get depth from Isaac Sim camera: {e}") return None else: # If no Isaac Sim camera, return default depth self._log(f"[WARN] No Isaac Sim camera available, returning default depth image") # Create 640x480 default depth map (5m) return np.full((480, 640), 5.0, dtype=np.float32) def get_rgbd(self) -> tuple: """Get RGB and depth images.""" if hasattr(self, 'cam') and self.cam: try: # Step 1: Get RGB image (collision mesh off) self.set_collision_mesh_visibility(False) # Ensure camera position update and render self._update_camera_position() self.world.step(render=True) # Get RGB image rgba_img = self.cam.get_rgba() rgb_img = None if rgba_img is not None and rgba_img.size > 0: rgb_img = rgba_img[:, :, :3].astype(np.uint8) else: pass # Step 2: Get depth image (collision mesh on) # Force enable collision mesh self.set_collision_mesh_visibility(True) # Multiple renders to ensure collision mesh takes effect self._update_camera_position() for i in range(3): self.world.step(render=True) # Reconfirm collision mesh state self.set_collision_mesh_visibility(True) # Runtime fix: check and add depth annotator self._ensure_depth_annotator_runtime() # Force refresh depth rendering pipeline self._force_refresh_depth_pipeline() # Final render updates for i in range(5): self.world.step(render=True) # Get depth image depth_img = None # get_rgbd: use same depth strategy # Method 1: Get depth via annotator (improved) if depth_img is None: try: # Ensure collision mesh visible for depth self.set_collision_mesh_visibility(True) # Force render to ensure data is fresh self.world.step(render=True) frame = self.cam.get_current_frame() if frame: available_keys = list(frame.keys()) # Try multiple depth keys depth_keys = ['distance_to_image_plane', 'depth', 'distance_to_camera', 'linear_depth'] depth_data = None used_key = None for key in depth_keys: if key in frame: depth_data = frame[key] used_key = key break if depth_data is not None: # Handle different depth data types if hasattr(depth_data, 'shape'): if depth_data.size > 0: if hasattr(depth_data, 'cpu'): depth_img = depth_data.cpu().numpy() elif hasattr(depth_data, 'numpy'): depth_img = depth_data.numpy() else: depth_img = np.array(depth_data, dtype=np.float32) # Ensure 2D array if depth_img.ndim == 3 and depth_img.shape[-1] == 1: depth_img = depth_img.squeeze(-1) elif depth_img.ndim == 1: # Try reshape to expected size expected_size = self.resolution[0] * self.resolution[1] if depth_img.size == expected_size: depth_img = depth_img.reshape(self.resolution[1], self.resolution[0]) # Check if depth values are valid if depth_img.ndim == 2: depth_std = depth_img.std() depth_range = depth_img.max() - depth_img.min() if depth_std < 0.001 and depth_range < 0.001: pass # Depth data has no variation if depth_img.shape == (self.resolution[1], self.resolution[0]): pass # Valid shape else: depth_img = None else: depth_img = None else: depth_img = None else: depth_img = None else: pass else: pass except Exception as e: pass import traceback # Method 2: Get via SyntheticData if depth_img is None: try: # Ensure collision mesh visible for depth self.set_collision_mesh_visibility(True) self.world.step(render=True) import omni.kit.viewport.utility as vp_utils import omni.syntheticdata as sd viewport_api = vp_utils.get_viewport_from_window_name("Viewport") if viewport_api: sd_interface = sd.acquire_syntheticdata_interface() depth_img = sd_interface.get_viewport_data(viewport_api, "distance_to_image_plane") if depth_img is not None and len(depth_img) > 0: depth_img = np.array(depth_img, dtype=np.float32).reshape(self.resolution[1], self.resolution[0]) except Exception as e: pass # Method 3: Try direct method calls if depth_img is None: # Ensure collision mesh visible for depth self.set_collision_mesh_visibility(True) self.world.step(render=True) depth_methods = ['get_distance_to_image_plane', 'get_depth_data', 'get_depth', 'get_linear_depth'] for method_name in depth_methods: if hasattr(self.cam, method_name): try: method = getattr(self.cam, method_name) depth_img = method() if depth_img is not None and hasattr(depth_img, 'size') and depth_img.size > 0: if hasattr(depth_img, 'cpu'): depth_img = depth_img.cpu().numpy() depth_img = np.array(depth_img, dtype=np.float32) break except Exception as e: pass continue # Final fallback: generate pseudo depth if depth_img is None or (hasattr(depth_img, 'size') and depth_img.size == 0): try: height, width = self.resolution[1], self.resolution[0] # Create radial depth map y, x = np.ogrid[:height, :width] center_y, center_x = height // 2, width // 2 # Distance from center dist_from_center = np.sqrt((x - center_x)**2 + (y - center_y)**2) max_dist = np.sqrt(center_x**2 + center_y**2) # Normalize to depth range [1.0, 6.0] meters depth_img = 1.5 + 4.5 * (dist_from_center / max_dist) # Add noise for realism noise = np.random.normal(0, 0.1, depth_img.shape) depth_img = depth_img + noise depth_img = np.clip(depth_img, 0.5, 6.0).astype(np.float32) except Exception as e: pass # Final fallback: simple uniform depth try: height, width = self.resolution[1], self.resolution[0] depth_img = np.full((height, width), 3.0, dtype=np.float32) except Exception as e2: pass depth_img = np.full((480, 640), 3.0, dtype=np.float32) # Check if RGB and depth images were obtained if rgb_img is None: self._log(f"[WARN] Failed to get RGB image") rgb_img = np.zeros((480, 640, 3), dtype=np.uint8) if depth_img is None: self._log(f"[WARN] Failed to get depth image") depth_img = np.full((480, 640), 3.0, dtype=np.float32) # Process depth image depth_img = depth_img.astype(np.float32) depth_img = np.clip(depth_img, 0.1, 6.5) return rgb_img, depth_img except Exception as e: self._log(f"[WARN] Failed to get RGB-D from Isaac Sim camera: {e}") return None, None else: self._log(f"[WARN] No Isaac Sim camera available, returning default RGB-D") rgb = np.zeros((480, 640, 3), dtype=np.uint8) depth = np.full((480, 640), 5.0, dtype=np.float32) return rgb, depth def _check_collision(self, new_pos) -> bool: """ Collision detection: prefer 2D semantic map, fallback to Isaac Sim physics """ try: # If collision detection disabled, return False if hasattr(self, '_debug_disable_collision') and self._debug_disable_collision: return False # Prefer 2D semantic map collision detection if self.collision_detector is not None: is_collision = self.collision_detector.check_collision_3d(new_pos) if is_collision: self._collision_detected = True self._total_collision_count += 1 # Increment total collision count (CR metric) return True else: return False else: pass # Fallback to Isaac Sim physics collision return self._check_collision_isaac_sim(new_pos) except Exception as e: pass # On error, fallback to Isaac Sim return self._check_collision_isaac_sim(new_pos) def _check_collision_isaac_sim(self, new_pos) -> bool: """ Original Isaac Sim physics collision detection (as fallback) """ try: # Save current position current_pos = self._pos.copy() # Temporarily move to new position for collision check self._pos = new_pos self._apply_pose() # Run physics step to handle collision self.world.step(render=False) # Check if collision occurred # Method 1: Check if agent was pushed back actual_pos = self._get_agent_physics_position() if actual_pos is not None: position_diff = np.linalg.norm(new_pos - actual_pos) # Adjust threshold if position_diff > 0.02: # Restore original position self._pos = current_pos self._apply_pose() return True elif position_diff > 0.01: pass # Allow movement but log # Method 2: Additional safety check expected_movement = np.linalg.norm(new_pos[:2] - current_pos[:2]) actual_movement = np.linalg.norm(actual_pos[:2] - current_pos[:2]) if actual_pos is not None else 0 movement_ratio = actual_movement / expected_movement if expected_movement > 0.001 else 1.0 if movement_ratio < 0.5: if expected_movement > 0.05: print(f"[ISAAC_COLLISION_BLOCKED] Movement severely restricted by physics") # Restore original position self._pos = current_pos self._apply_pose() return True # If no collision detected, keep new position return False except Exception as e: pass # Restore original position self._pos = current_pos if 'current_pos' in locals() else self._pos self._apply_pose() return False def _check_path_collision(self, start_pos: np.ndarray, end_pos: np.ndarray) -> bool: """Check if there are collision bodies on path.""" try: # Sample points along path to check collision num_samples = 5 for i in range(1, num_samples + 1): t = i / (num_samples + 1) sample_pos = start_pos * (1 - t) + end_pos * t # Check if sample point is in collision body if self._check_point_collision(sample_pos): print(f"[PATH_COLLISION] Sample point {i} at {sample_pos[:2]} is in collision") return True return False except Exception as e: print(f"[WARN] Path collision check failed: {e}") return False def _check_point_collision(self, pos: np.ndarray) -> bool: """Check if specific point is in collision body.""" try: # Use Isaac Sim ray casting for collision check if hasattr(self, 'world') and self.world: # Cast ray downward to check ground collision ray_start = pos + np.array([0, 0, 0.5]) ray_end = pos + np.array([0, 0, -0.5]) # Can add more complex collision detection logic # Return False for now, let physics handle it return False return False except Exception as e: print(f"[WARN] Point collision check failed: {e}") return False def _get_agent_physics_position(self) -> Optional[np.ndarray]: """Get agent actual position in physics system.""" try: if hasattr(self, 'agent_prim') and self.agent_prim: # Get agent prim transform xformable = self._UsdGeom.Xformable(self.agent_prim) if xformable: # Get world transform matrix world_transform = xformable.ComputeLocalToWorldTransform(0) if world_transform: # Extract position translation = world_transform.ExtractTranslation() return np.array([translation[0], translation[1], translation[2]], dtype=np.float32) return None except Exception as e: print(f"[WARN] Failed to get agent physics position: {e}") return None def apply_cmd_for(self, vx: float, vy: float, yaw_rate: float, duration_s: float) -> None: """ Improved motion control with smart sliding algorithm """ _debug_print(f"[DEBUG] apply_cmd_for start: vx={vx:.3f}, vy={vy:.3f}, yaw_rate={yaw_rate:.3f}, current_yaw={math.degrees(self._yaw):.1f}°") self._log(f"[DEBUG] apply_cmd_for start: vx={vx:.3f}, vy={vy:.3f}, yaw_rate={yaw_rate:.3f}, current_yaw={math.degrees(self._yaw):.1f}°") # Calculate total movement - transform from robot to world coords # VLM output: vx=forward, vy=lateral (relative to robot) # Need to transform to world coords: X=East, Y=North cos_yaw = math.cos(self._yaw) sin_yaw = math.sin(self._yaw) # Coordinate transform: robot -> world # Robot forward (vx) -> world movement vector world_vx = vx * cos_yaw - vy * sin_yaw world_vy = vx * sin_yaw + vy * cos_yaw total_dx = world_vx * duration_s total_dy = world_vy * duration_s total_dyaw = yaw_rate * duration_s _debug_print(f"[DEBUG] Total movement: dx={total_dx:.3f}, dy={total_dy:.3f}, dyaw={math.degrees(total_dyaw):.1f}°") # Record original position old_pos = self._pos.copy() intended_movement = np.linalg.norm([total_dx, total_dy]) if intended_movement > 0.001: # Calculate target position target_pos = old_pos.copy() target_pos[0] += total_dx target_pos[1] += total_dy # Use safe gradual movement with collision detection actual_movement = self._safe_gradual_movement(old_pos, target_pos, intended_movement) # Check movement efficiency and update collision counter movement_efficiency = actual_movement / intended_movement if intended_movement > 0 else 1.0 if movement_efficiency < 0.3 and intended_movement > 0.05: self.consecutive_collisions += 1 if self.consecutive_collisions >= 3: pass else: # Successful movement, reset collision counter if movement_efficiency > 0.6: if self.consecutive_collisions > 0: pass self.consecutive_collisions = 0 else: # No movement (e.g. turning), dont reset collision counter pass # Update orientation old_yaw = self._yaw self._yaw += total_dyaw self._yaw = ((self._yaw + math.pi) % (2 * math.pi)) - math.pi # Update camera position for new orientation self._update_camera_position() _debug_print(f"[DEBUG] Finished env.apply_cmd_for") self._log(f"[DEBUG] Finished env.apply_cmd_for") def _safe_gradual_movement(self, start_pos: np.ndarray, target_pos: np.ndarray, target_distance: float) -> float: """ Absolutely safe movement: strictly prevent clipping, use lateral exploration to avoid stuck. Args: start_pos: Start position target_pos: Target position target_distance: Target distance Returns: Actual distance moved """ # Save current position current_pos = self._pos.copy() # Calculate movement direction direction = target_pos - current_pos direction_norm = np.linalg.norm(direction[:2]) # If movement too small, return if direction_norm < 0.001: return 0.0 # Normalize direction vector unit_direction = direction / direction_norm # Limit movement distance max_distance = min(0.20, target_distance) # Step 1: Try direct movement to target direct_movement = self._try_direct_movement(current_pos, unit_direction, max_distance) if direct_movement > 0.01: return direct_movement # Step 2: If direct failed, try lateral exploration exploration_movement = self._try_exploration_movement(current_pos, unit_direction) if exploration_movement > 0.005: return exploration_movement # Step 3: Cannot move at all return 0.0 def _try_direct_movement(self, start_pos: np.ndarray, direction: np.ndarray, max_distance: float) -> float: """Try direct movement towards target.""" total_moved = 0.0 current_pos = start_pos.copy() step_size = 0.01 while total_moved < max_distance: step_distance = min(step_size, max_distance - total_moved) next_pos = current_pos + direction * step_distance # Strict collision pre-check if self._is_position_safe(next_pos): # Try movement old_pos = self._pos.copy() self._pos = next_pos self._apply_pose() self.world.step(render=False) # Verify movement result actual_pos = self._get_agent_physics_position() if actual_pos is None: actual_pos = self._pos # Check if actually moved to expected position position_diff = np.linalg.norm(actual_pos[:2] - next_pos[:2]) if position_diff < 0.002: current_pos = actual_pos self._pos = actual_pos total_moved += step_distance else: # Physics blocked movement, restore and stop self._pos = old_pos self._apply_pose() break else: # Collision detected, stop movement break actual_movement = np.linalg.norm(current_pos[:2] - start_pos[:2]) return actual_movement def _try_exploration_movement(self, start_pos: np.ndarray, blocked_direction: np.ndarray) -> float: """Try lateral exploration when direct movement blocked.""" # Generate lateral exploration directions perpendicular = np.array([-blocked_direction[1], blocked_direction[0], 0]) exploration_directions = [ perpendicular, -perpendicular, perpendicular * 0.707 + blocked_direction * 0.707, -perpendicular * 0.707 + blocked_direction * 0.707, ] best_movement = 0.0 best_pos = start_pos.copy() for i, direction in enumerate(exploration_directions): direction_norm = np.linalg.norm(direction[:2]) if direction_norm > 0.001: direction = direction / direction_norm # Try short movement in this direction movement = self._try_short_movement(start_pos, direction, 0.05) if movement > best_movement: best_movement = movement best_pos = self._pos.copy() # Apply best movement if best_movement > 0.005: self._pos = best_pos self._apply_pose() return best_movement def _try_short_movement(self, start_pos: np.ndarray, direction: np.ndarray, max_distance: float) -> float: """Try short distance movement.""" step_size = 0.005 # 5mm total_moved = 0.0 current_pos = start_pos.copy() while total_moved < max_distance: step_distance = min(step_size, max_distance - total_moved) next_pos = current_pos + direction * step_distance if self._is_position_safe(next_pos): # Temporary test movement old_pos = self._pos.copy() self._pos = next_pos self._apply_pose() self.world.step(render=False) actual_pos = self._get_agent_physics_position() if actual_pos is None: actual_pos = self._pos position_diff = np.linalg.norm(actual_pos[:2] - next_pos[:2]) if position_diff < 0.002: current_pos = actual_pos total_moved += step_distance else: # Restore position, stop this direction self._pos = old_pos self._apply_pose() break else: break return total_moved def _is_position_safe(self, pos: np.ndarray) -> bool: """Strictly check if position is safe (no collision).""" try: # 2D semantic map check if self.collision_detector is not None: if self.collision_detector.check_collision_3d(pos): return False # Additional physics pre-check (optional) # Can add more check logic here return True except Exception as e: pass return False def _smart_slide_movement_deprecated(self, start_pos: np.ndarray, dx: float, dy: float) -> Tuple[np.ndarray, float]: """ Smart sliding algorithm: try to move to closest collision-free position. Args: start_pos: Start position dx, dy: Expected movement vector Returns: Tuple[final_position, actual_distance] """ intended_distance = np.linalg.norm([dx, dy]) if intended_distance < 0.001: return start_pos.copy(), 0.0 # Normalize movement direction move_direction = np.array([dx, dy]) / intended_distance print(f"[SMART_SLIDE] Starting smart slide: intended={intended_distance:.3f}m, direction={move_direction}") # Strategy 1: Binary search for max feasible distance print(f"[SMART_SLIDE] Trying binary search for direct movement...") max_distance = self._binary_search_max_distance(start_pos, move_direction, intended_distance) if max_distance > 0.01: final_pos = start_pos.copy() final_pos[0] += move_direction[0] * max_distance final_pos[1] += move_direction[1] * max_distance print(f"[SMART_SLIDE] Binary search success: max_distance={max_distance:.3f}m") return final_pos, max_distance # Strategy 2: If direct failed, try sliding along obstacle print(f"[SMART_SLIDE] Direct movement blocked, trying sliding along obstacles") slide_pos, slide_distance = self._try_obstacle_sliding(start_pos, move_direction, intended_distance) if slide_distance > 0.005: print(f"[SMART_SLIDE] Obstacle sliding success: distance={slide_distance:.3f}m") return slide_pos, slide_distance # Strategy 3: Try small multi-direction exploration print(f"[SMART_SLIDE] Trying multi-directional micro-movements") explore_pos, explore_distance = self._try_micro_exploration(start_pos, move_direction, min(intended_distance, 0.05)) if explore_distance > 0.002: print(f"[SMART_SLIDE] Micro-exploration success: distance={explore_distance:.3f}m") return explore_pos, explore_distance # Strategy 4: Ultimate escape - try minimal forced movement print(f"[SMART_SLIDE] All strategies failed, trying ultra-micro movements...") ultra_micro_pos, ultra_micro_distance = self._try_ultra_micro_escape(start_pos, move_direction) print(f"[SMART_SLIDE_DEBUG] ultra_micro_distance={ultra_micro_distance:.10f}, checking >= 0.001") if ultra_micro_distance >= 0.0009: print(f"[SMART_SLIDE] Ultra-micro escape success: distance={ultra_micro_distance:.4f}m") return ultra_micro_pos, ultra_micro_distance # Should never reach here! Force movement print(f"[SMART_SLIDE] EMERGENCY: All strategies failed, ultra_micro_distance={ultra_micro_distance:.6f}m") print(f"[SMART_SLIDE] EMERGENCY: Forcing 1mm movement in ANY direction!") # Force movement - must not return 0 emergency_pos = start_pos.copy() emergency_pos[0] += 0.001 return emergency_pos, 0.001 def _binary_search_max_distance(self, start_pos: np.ndarray, direction: np.ndarray, max_distance: float) -> float: """ Use binary search to find max movable distance in given direction """ min_dist = 0.0 max_dist = min(0.1, max_distance) best_dist = 0.0 # Binary search, 1mm precision for _ in range(20): test_dist = (min_dist + max_dist) / 2.0 if test_dist < 0.001: break test_pos = start_pos.copy() test_pos[0] += direction[0] * test_dist test_pos[1] += direction[1] * test_dist if self._test_position_safety(start_pos, test_pos): best_dist = test_dist min_dist = test_dist else: max_dist = test_dist return best_dist def _try_obstacle_sliding(self, start_pos: np.ndarray, primary_direction: np.ndarray, intended_distance: float) -> Tuple[np.ndarray, float]: """ Try sliding along obstacle edge """ # Calculate two perpendicular directions perp_left = np.array([-primary_direction[1], primary_direction[0]]) perp_right = np.array([primary_direction[1], -primary_direction[0]]) best_pos = start_pos.copy() best_distance = 0.0 # Try different sliding strategies slide_distances = [0.02, 0.05, 0.1, 0.15] # 2cm, 5cm, 10cm, 15cm for slide_dist in slide_distances: if slide_dist > intended_distance: slide_dist = intended_distance # Try left slide for perp_ratio in [0.3, 0.5, 0.7, 1.0]: slide_direction = primary_direction * (1 - perp_ratio) + perp_left * perp_ratio slide_direction = slide_direction / np.linalg.norm(slide_direction) test_pos = start_pos.copy() test_pos[0] += slide_direction[0] * slide_dist test_pos[1] += slide_direction[1] * slide_dist if self._test_position_safety(start_pos, test_pos): actual_distance = np.linalg.norm(test_pos[:2] - start_pos[:2]) if actual_distance > best_distance: best_pos = test_pos best_distance = actual_distance # Try right slide for perp_ratio in [0.3, 0.5, 0.7, 1.0]: slide_direction = primary_direction * (1 - perp_ratio) + perp_right * perp_ratio slide_direction = slide_direction / np.linalg.norm(slide_direction) test_pos = start_pos.copy() test_pos[0] += slide_direction[0] * slide_dist test_pos[1] += slide_direction[1] * slide_dist if self._test_position_safety(start_pos, test_pos): actual_distance = np.linalg.norm(test_pos[:2] - start_pos[:2]) if actual_distance > best_distance: best_pos = test_pos best_distance = actual_distance return best_pos, best_distance def _try_micro_exploration(self, start_pos: np.ndarray, primary_direction: np.ndarray, max_distance: float) -> Tuple[np.ndarray, float]: """ Try small multi-direction exploration """ best_pos = start_pos.copy() best_distance = 0.0 # Try multiple angle offsets (-45 to +45 degrees) angle_offsets = [-45, -30, -15, 0, 15, 30, 45] distances = [max_distance * 0.2, max_distance * 0.5, max_distance * 0.8, max_distance] for angle_deg in angle_offsets: angle_rad = math.radians(angle_deg) # Rotate main direction cos_a, sin_a = math.cos(angle_rad), math.sin(angle_rad) rotated_direction = np.array([ primary_direction[0] * cos_a - primary_direction[1] * sin_a, primary_direction[0] * sin_a + primary_direction[1] * cos_a ]) for test_distance in distances: test_pos = start_pos.copy() test_pos[0] += rotated_direction[0] * test_distance test_pos[1] += rotated_direction[1] * test_distance if self._test_position_safety(start_pos, test_pos): actual_distance = np.linalg.norm(test_pos[:2] - start_pos[:2]) if actual_distance > best_distance: best_pos = test_pos best_distance = actual_distance return best_pos, best_distance def _try_ultra_micro_escape(self, start_pos: np.ndarray, primary_direction: np.ndarray) -> Tuple[np.ndarray, float]: """ Ultimate escape: try minimal forced movement, bypass safety check """ best_pos = start_pos.copy() best_distance = 0.0 print(f"[ULTRA_MICRO] Attempting ultra-micro escape from complete blockage") # Try 8 basic directions directions = [ np.array([1.0, 0.0]), np.array([-1.0, 0.0]), np.array([0.0, 1.0]), np.array([0.0, -1.0]), np.array([0.707, 0.707]), np.array([-0.707, 0.707]), np.array([0.707, -0.707]), np.array([-0.707, -0.707]), primary_direction, ] # Try minimal distances: 1mm, 2mm, 3mm, 5mm micro_distances = [0.001, 0.002, 0.003, 0.005] for direction in directions: direction = direction / np.linalg.norm(direction) for micro_dist in micro_distances: test_pos = start_pos.copy() test_pos[0] += direction[0] * micro_dist test_pos[1] += direction[1] * micro_dist # Use relaxed safety check or skip safety_result = self._ultra_permissive_safety_check(start_pos, test_pos) if safety_result: actual_distance = np.linalg.norm(test_pos[:2] - start_pos[:2]) if actual_distance > best_distance: best_pos = test_pos best_distance = actual_distance movement_mm = direction[:2] * micro_dist * 1000 print(f"[ULTRA_MICRO] Found viable micro-movement: [{movement_mm[0]:.1f}, {movement_mm[1]:.1f}]mm, distance={actual_distance:.4f}m") print(f"[ULTRA_MICRO] Immediately returning: pos={best_pos[:2]}, distance={best_distance:.6f}m") # Return once found, dont be greedy return best_pos, best_distance else: print(f"[ULTRA_MICRO_DEBUG] Safety check failed for {micro_dist*1000:.1f}mm movement") # If all directions fail, force minimal movement if best_distance == 0.0: print(f"[ULTRA_MICRO] Forcing minimal movement in primary direction") forced_pos = start_pos.copy() forced_pos[0] += primary_direction[0] * 0.001 forced_pos[1] += primary_direction[1] * 0.001 print(f"[ULTRA_MICRO] Forced movement: distance=0.001m") return forced_pos, 0.001 print(f"[ULTRA_MICRO] Returning best movement: distance={best_distance:.4f}m") return best_pos, best_distance def _ultra_permissive_safety_check(self, start_pos: np.ndarray, test_pos: np.ndarray) -> bool: """ Ultra relaxed safety check for extreme stuck situations """ try: # For minimal movement, basically pass movement_distance = np.linalg.norm(test_pos[:2] - start_pos[:2]) # If distance < 3mm, pass directly if movement_distance < 0.003: return True # For slightly larger movement (<6mm), do simple check if movement_distance < 0.006: return True return False except Exception as e: print(f"[ULTRA_PERMISSIVE_ERROR] {e}") # On error, pass for minimal movement movement_distance = np.linalg.norm(test_pos[:2] - start_pos[:2]) return movement_distance < 0.002 def _test_position_safety(self, start_pos: np.ndarray, test_pos: np.ndarray) -> bool: """ Test if position is safe (no collision). Uses lightweight collision detection to avoid performance impact. """ try: # If collision detection disabled, return True if hasattr(self, '_debug_disable_collision') and self._debug_disable_collision: return True # Basic boundary check if abs(test_pos[0]) > 20 or abs(test_pos[1]) > 20 or test_pos[2] < 0 or test_pos[2] > 5: return False # Temporarily save current position original_pos = self._pos.copy() # Move to test position self._pos = test_pos self._apply_pose() # Run one physics step self.world.step(render=False) # Check actual position actual_pos = self._get_agent_physics_position() if actual_pos is None: # Restore position self._pos = original_pos self._apply_pose() return False # Calculate position deviation position_diff = np.linalg.norm(test_pos - actual_pos) # Restore original position (test, must restore) self._pos = original_pos self._apply_pose() # Restore relaxed collision detection is_safe = position_diff < 0.03 if not is_safe and position_diff > 0.05: pass return is_safe except Exception as e: print(f"[SAFETY_TEST_ERROR] {e}") # Ensure position restored self._pos = start_pos self._apply_pose() return False def _apply_gradual_movement(self, start_pos: np.ndarray, target_pos: np.ndarray, target_distance: float) -> float: """ Force movement: try to move to target while respecting collision. Args: start_pos: Start position target_pos: Target position target_distance: Target distance Returns: Actual distance moved """ # Save current position current_pos = self._pos.copy() # Calculate movement direction direction = target_pos - current_pos direction_norm = np.linalg.norm(direction[:2]) # If movement too small, return if direction_norm < 0.001: return 0.0 # Normalize direction vector unit_direction = direction / direction_norm # Limit max distance to 25cm max_distance = min(0.25, target_distance) # Try movement in 5cm steps total_moved = 0.0 step_size = 0.05 collision_detected = False while total_moved < max_distance: # Calculate next position step_distance = min(step_size, max_distance - total_moved) next_pos = current_pos + unit_direction * step_distance # Temporarily save current position temp_pos = self._pos.copy() # First check 2D semantic map collision if self.collision_detector is not None: is_2d_collision = self.collision_detector.check_collision_3d(next_pos) if is_2d_collision: collision_detected = True break else: pass # Try movement to next position self._pos = next_pos # Apply position update self._apply_pose() # Run physics step self.world.step(render=False) # Get actual position (may be modified by physics) actual_pos = self._get_agent_physics_position() if actual_pos is None: actual_pos = self._pos # Calculate actual movement distance actual_movement = np.linalg.norm(actual_pos[:2] - current_pos[:2]) # Check for obvious Isaac Sim physics collision position_diff = np.linalg.norm(actual_pos[:2] - next_pos[:2]) if position_diff > 0.02: # Restore to last valid position self._pos = temp_pos self._apply_pose() collision_detected = True break # Update current position and distance moved current_pos = actual_pos total_moved += step_distance # Calculate total actual distance moved actual_movement = np.linalg.norm(current_pos[:2] - start_pos[:2]) # Detect stuck state expected_movement = target_distance movement_efficiency = actual_movement / expected_movement if expected_movement > 0 else 1.0 if movement_efficiency < 0.3 and expected_movement > 0.05: self.consecutive_collisions += 1 if self.consecutive_collisions >= 3: pass else: # Successful movement, reset collision counter if movement_efficiency > 0.6: if self.consecutive_collisions > 0: pass self.consecutive_collisions = 0 return actual_movement def get_yaw(self) -> float: return float(self._yaw) def get_collision_count(self) -> int: """Get total collision count for current episode (CR metric).""" return getattr(self, '_total_collision_count', 0) def set_collision_detection(self, enabled: bool) -> None: """Enable or disable collision detection.""" old_value = getattr(self, '_debug_disable_collision', False) self._debug_disable_collision = not enabled def debug_pose(self) -> Dict[str, Any]: """Debug current pose information""" return { "position": self._pos.tolist(), "yaw_rad": self._yaw, "yaw_deg": math.degrees(self._yaw), "quaternion": [-math.sin(self._yaw/2.0), 0.0, 0.0, math.cos(self._yaw/2.0)] # Your mapping } def transform_coordinates(self, position: List[float], rotation_xyzw: List[float]) -> Tuple[np.ndarray, float]: """ Transform coordinates from your trajectory system to Isaac Sim system. This method helps debug coordinate system mismatches. """ # Your trajectory data might use a different coordinate system # This method helps identify the transformation needed # Extract yaw from quaternion x, y, z, w = rotation_xyzw yaw = math.atan2(2*(w*z + x*y), 1 - 2*(y*y + z*z)) # For debugging, let's see what the transformation looks like # You might need to adjust these based on your coordinate mapping transformed_pos = np.array(position, dtype=np.float32) transformed_yaw = yaw return transformed_pos, transformed_yaw @staticmethod def write_video(frames: List[np.ndarray], out_path: str, fps: int = 10) -> None: Path(out_path).parent.mkdir(parents=True, exist_ok=True) seq_dir = Path(out_path).with_suffix("") seq_dir.mkdir(parents=True, exist_ok=True) # Normalize frames to uint8 RGB norm_frames: List[np.ndarray] = [] for f in frames: arr = f.astype(np.uint8) if arr.ndim == 3 and arr.shape[2] == 4: arr = arr[:, :, :3] norm_frames.append(arr) # 0) Prefer imageio-ffmpeg explicitly (libx264) mp4_ok = False try: writer = imageio.get_writer( str(out_path), fps=fps, format="FFMPEG", codec="libx264", quality=8, bitrate="8M", macro_block_size=None, output_params=["-pix_fmt", "yuv420p"] # 确保兼容性 ) for fr in norm_frames: writer.append_data(fr) writer.close() mp4_ok = os.path.exists(out_path) and os.path.getsize(out_path) > 0 except Exception: mp4_ok = False # 1) Try OpenCV if imageio path failed if not mp4_ok: try: import cv2 # type: ignore if len(norm_frames) > 0: h, w = norm_frames[0].shape[:2] fourcc = cv2.VideoWriter_fourcc(*'mp4v') vw = cv2.VideoWriter(str(out_path), fourcc, float(fps), (w, h)) for fr in norm_frames: if fr.shape[0] != h or fr.shape[1] != w: fr = cv2.resize(fr, (w, h)) bgr = cv2.cvtColor(fr, cv2.COLOR_RGB2BGR) vw.write(bgr) vw.release() mp4_ok = os.path.exists(out_path) and os.path.getsize(out_path) > 0 except Exception: mp4_ok = False # 2) Always write PNG sequence for i, fr in enumerate(norm_frames): imageio.imwrite(str(seq_dir / f"frame_{i:05d}.png"), fr) def _verify_agent_physics(self) -> None: """Verify agent physics configuration.""" print(f"[PHYSICS_VERIFY] Checking agent physics configuration...") try: # Check if agent prim exists agent_prim = self.stage.GetPrimAtPath(self.agent_prim_path) if not agent_prim.IsValid(): print(f"[PHYSICS_ERROR] Agent prim not found at {self.agent_prim_path}") return print(f"[PHYSICS_VERIFY] Agent prim found: {self.agent_prim_path}") # Check if collision cylinder exists collision_path = self.agent_prim_path + "/CollisionCylinder" collision_prim = self.stage.GetPrimAtPath(collision_path) if not collision_prim.IsValid(): print(f"[PHYSICS_ERROR] Collision cylinder not found at {collision_path}") return print(f"[PHYSICS_VERIFY] Collision cylinder found: {collision_path}") # Check RigidBody attributes if agent_prim.HasAPI(self._UsdPhysics.RigidBodyAPI): rigid_body = self._UsdPhysics.RigidBodyAPI(agent_prim) kinematic = rigid_body.GetKinematicEnabledAttr().Get() enabled = rigid_body.GetRigidBodyEnabledAttr().Get() print(f"[PHYSICS_VERIFY] RigidBody: enabled={enabled}, kinematic={kinematic}") else: print(f"[PHYSICS_ERROR] RigidBodyAPI not applied to agent") # Check Collision attributes if collision_prim.HasAPI(self._UsdPhysics.CollisionAPI): collision_api = self._UsdPhysics.CollisionAPI(collision_prim) collision_enabled = collision_api.GetCollisionEnabledAttr().Get() print(f"[PHYSICS_VERIFY] Collision: enabled={collision_enabled}") else: print(f"[PHYSICS_ERROR] CollisionAPI not applied to collision cylinder") # Check cylinder geometry attributes cylinder = self._UsdGeom.Cylinder(collision_prim) radius = cylinder.GetRadiusAttr().Get() height = cylinder.GetHeightAttr().Get() print(f"[PHYSICS_VERIFY] Cylinder: radius={radius}m, height={height}m") # Check agent position pos = self._get_agent_physics_position() if pos is not None: print(f"[PHYSICS_VERIFY] Agent position: {pos}") print(f"[PHYSICS_VERIFY] Agent height (z): {pos[2]}m") if pos[2] < 0.7 or pos[2] > 0.9: print(f"[PHYSICS_WARN] Agent center height {pos[2]}m may not be correct (expected ~0.8m for 1.6m tall agent)") else: print(f"[PHYSICS_ERROR] Could not get agent position") print(f"[PHYSICS_VERIFY] Physics verification complete") except Exception as e: print(f"[PHYSICS_ERROR] Failed to verify physics: {e}") import traceback traceback.print_exc() def _setup_physics_scene(self) -> None: """Setup physics scene for collision detection.""" try: print(f"[PHYSICS_SETUP] Setting up physics scene...") # Ensure physics scene exists from pxr import UsdPhysics scene = UsdPhysics.Scene.Define(self.stage, "/physicsScene") scene.CreateGravityDirectionAttr().Set((0.0, 0.0, -1.0)) scene.CreateGravityMagnitudeAttr().Set(981.0) # cm/s^2 print(f"[PHYSICS_SETUP] Created physics scene with gravity") # Add default material material_path = "/physicsMaterial" if not self.stage.GetPrimAtPath(material_path): material = UsdPhysics.MaterialAPI.Apply( self.stage.DefinePrim(material_path, "Material") ) material.CreateStaticFrictionAttr().Set(0.5) material.CreateDynamicFrictionAttr().Set(0.5) material.CreateRestitutionAttr().Set(0.0) print(f"[PHYSICS_SETUP] Created default physics material") print(f"[PHYSICS_SETUP] Physics scene setup complete") except Exception as e: print(f"[PHYSICS_SETUP_ERROR] Failed to setup physics scene: {e}") import traceback traceback.print_exc() def _verify_collision_system(self) -> None: """Verify entire collision system works correctly.""" print(f"[COLLISION_VERIFY] Verifying collision system...") try: # Check physics scene scene_prim = self.stage.GetPrimAtPath("/physicsScene") if scene_prim.IsValid(): print(f"[COLLISION_VERIFY] Physics scene found: /physicsScene") else: print(f"[COLLISION_ERROR] Physics scene not found!") # Check agent collision body collision_path = self.agent_prim_path + "/CollisionCylinder" collision_prim = self.stage.GetPrimAtPath(collision_path) if collision_prim.IsValid(): print(f"[COLLISION_VERIFY] Agent collision body found: {collision_path}") # Check collision body transform collision_xform = self._UsdGeom.Xformable(collision_prim) local_transform = collision_xform.GetLocalTransformation() print(f"[COLLISION_VERIFY] Collision body transform: {local_transform}") else: print(f"[COLLISION_ERROR] Agent collision body not found!") # Check other collision bodies in scene collision_count = 0 for prim in self.stage.Traverse(): if prim.HasAPI(self._UsdPhysics.CollisionAPI): collision_count += 1 if collision_count <= 5: print(f"[COLLISION_VERIFY] Found collision object: {prim.GetPath()}") print(f"[COLLISION_VERIFY] Total collision objects in scene: {collision_count}") if collision_count < 2: print(f"[COLLISION_WARN] Very few collision objects found. Scene may not have proper collision setup.") print(f"[COLLISION_VERIFY] Collision system verification complete") except Exception as e: print(f"[COLLISION_VERIFY_ERROR] Failed to verify collision system: {e}") import traceback traceback.print_exc() def _enhanced_collision_check(self, old_pos: np.ndarray, new_pos: np.ndarray) -> bool: """ Enhanced collision detection using multiple methods """ try: # Method 1: Temporarily move and check physics response temp_pos = self._pos.copy() self._pos = new_pos self._apply_pose() # Run physics to see if blocked self.world.step(render=False) # Check actual position actual_pos = self._get_agent_physics_position() if actual_pos is not None: # Calculate expected vs actual position difference position_diff = np.linalg.norm(new_pos - actual_pos) if position_diff > 0.001: print(f"[COLLISION_CHECK] Expected: {new_pos[:2]}, Actual: {actual_pos[:2]}, Diff: {position_diff:.4f}") # If large difference, collision occurred if position_diff > 0.03: self._pos = temp_pos # Restore original position self._apply_pose() return True # Method 2: Check height change if actual_pos is not None: height_diff = abs(actual_pos[2] - new_pos[2]) if height_diff > 0.5: print(f"[COLLISION_HEIGHT] Unexpected height change: {height_diff:.4f}m") self._pos = temp_pos self._apply_pose() return True # Method 3: Check if pushed to different position movement_intended = np.linalg.norm(new_pos[:2] - old_pos[:2]) movement_actual = np.linalg.norm(actual_pos[:2] - old_pos[:2]) if actual_pos is not None else movement_intended if movement_intended > 0.05: movement_ratio = movement_actual / movement_intended if movement_ratio < 0.05: print(f"[COLLISION_MOVEMENT] Movement severely restricted: ratio={movement_ratio:.2f}") self._pos = temp_pos self._apply_pose() return True # If all checks pass, allow movement return False except Exception as e: print(f"[COLLISION_CHECK_ERROR] {e}") # On error, restore position, block movement self._pos = old_pos self._apply_pose() return True def _verify_collision_system(self) -> None: """Verify entire collision system works correctly.""" print(f"[COLLISION_VERIFY] Verifying collision system...") try: # Check physics scene scene_prim = self.stage.GetPrimAtPath("/physicsScene") if scene_prim.IsValid(): print(f"[COLLISION_VERIFY] Physics scene found: /physicsScene") else: print(f"[COLLISION_ERROR] Physics scene not found!") # Check agent collision body collision_path = self.agent_prim_path + "/CollisionCylinder" collision_prim = self.stage.GetPrimAtPath(collision_path) if collision_prim.IsValid(): print(f"[COLLISION_VERIFY] Agent collision body found: {collision_path}") # Check collision body transform collision_xform = self._UsdGeom.Xformable(collision_prim) local_transform = collision_xform.GetLocalTransformation() print(f"[COLLISION_VERIFY] Collision body transform: {local_transform}") else: print(f"[COLLISION_ERROR] Agent collision body not found!") # Check other collision bodies in scene collision_count = 0 for prim in self.stage.Traverse(): if prim.HasAPI(self._UsdPhysics.CollisionAPI): collision_count += 1 if collision_count <= 5: print(f"[COLLISION_VERIFY] Found collision object: {prim.GetPath()}") print(f"[COLLISION_VERIFY] Total collision objects in scene: {collision_count}") if collision_count < 2: print(f"[COLLISION_WARN] Very few collision objects found. Scene may not have proper collision setup.") print(f"[COLLISION_VERIFY] Collision system verification complete") except Exception as e: print(f"[COLLISION_VERIFY_ERROR] Failed to verify collision system: {e}") import traceback traceback.print_exc() def _enhanced_collision_check(self, old_pos: np.ndarray, new_pos: np.ndarray) -> bool: """ Enhanced collision detection using multiple methods """ try: # Method 1: Temporarily move and check physics response temp_pos = self._pos.copy() self._pos = new_pos self._apply_pose() # Run physics to see if blocked self.world.step(render=False) # Check actual position actual_pos = self._get_agent_physics_position() if actual_pos is not None: # Calculate expected vs actual position difference position_diff = np.linalg.norm(new_pos - actual_pos) if position_diff > 0.001: print(f"[COLLISION_CHECK] Expected: {new_pos[:2]}, Actual: {actual_pos[:2]}, Diff: {position_diff:.4f}") # If large difference, collision occurred if position_diff > 0.03: self._pos = temp_pos # Restore original position self._apply_pose() return True # Method 2: Check height change if actual_pos is not None: height_diff = abs(actual_pos[2] - new_pos[2]) if height_diff > 0.5: print(f"[COLLISION_HEIGHT] Unexpected height change: {height_diff:.4f}m") self._pos = temp_pos self._apply_pose() return True # Method 3: Check if pushed to different position movement_intended = np.linalg.norm(new_pos[:2] - old_pos[:2]) movement_actual = np.linalg.norm(actual_pos[:2] - old_pos[:2]) if actual_pos is not None else movement_intended if movement_intended > 0.05: movement_ratio = movement_actual / movement_intended if movement_ratio < 0.05: print(f"[COLLISION_MOVEMENT] Movement severely restricted: ratio={movement_ratio:.2f}") self._pos = temp_pos self._apply_pose() return True # If all checks pass, allow movement return False except Exception as e: print(f"[COLLISION_CHECK_ERROR] {e}") # On error, restore position, block movement self._pos = old_pos self._apply_pose() return True