update camera_position/camera_target_position -> eye/lookat

Author: matthewtrepte

docs/source/features/visualization.rst

@@ -109,12 +109,12 @@ You can also configure custom visualizers in the code by defining ``VisualizerCf
                 dock_position="SAME",
                 window_width=1280,
                 window_height=720,
-                camera_position=(0.0, 0.0, 20.0), # high top down view
-                camera_target=(0.0, 0.0, 0.0),
+                eye=(0.0, 0.0, 20.0), # high top down view
+                lookat=(0.0, 0.0, 0.0),
             ),
             NewtonVisualizerCfg(
-                camera_position=(5.0, 5.0, 5.0), # closer quarter view
-                camera_target=(0.0, 0.0, 0.0),
+                eye=(5.0, 5.0, 5.0), # closer quarter view
+                lookat=(0.0, 0.0, 0.0),
                 show_joints=True,
             ),
             RerunVisualizerCfg(
@@ -201,8 +201,8 @@ Omniverse Visualizer
         window_height=720,                        # Viewport height in pixels
 
         # Camera settings
-        camera_position=(8.0, 8.0, 3.0),         # Initial camera position (x, y, z)
-        camera_target=(0.0, 0.0, 0.0),           # Camera look-at target
+        eye=(8.0, 8.0, 3.0),                     # Initial camera position (x, y, z)
+        lookat=(0.0, 0.0, 0.0),                  # Camera look-at target
 
         # Feature toggles
         enable_markers=True,                      # Enable visualization markers
@@ -255,8 +255,8 @@ Newton Visualizer
         window_height=1080,                       # Window height in pixels
 
         # Camera settings
-        camera_position=(8.0, 8.0, 3.0),         # Initial camera position (x, y, z)
-        camera_target=(0.0, 0.0, 0.0),           # Camera look-at target
+        eye=(8.0, 8.0, 3.0),                     # Initial camera position (x, y, z)
+        lookat=(0.0, 0.0, 0.0),                  # Camera look-at target
 
         # Performance tuning
         update_frequency=1,                       # Update every N frames (1=every frame)
@@ -303,8 +303,8 @@ Rerun Visualizer
         bind_address="0.0.0.0",                  # Endpoint host formatting/reuse checks
 
         # Camera settings
-        camera_position=(8.0, 8.0, 3.0),         # Initial camera position (x, y, z)
-        camera_target=(0.0, 0.0, 0.0),           # Camera look-at target
+        eye=(8.0, 8.0, 3.0),                     # Initial camera position (x, y, z)
+        lookat=(0.0, 0.0, 0.0),                  # Camera look-at target
 
         # History settings
         keep_historical_data=False,               # Keep transforms for time scrubbing

source/isaaclab/isaaclab/app/app_launcher.py

@@ -189,6 +189,8 @@ def __init__(self, launcher_args: argparse.Namespace | dict | None = None, **kwa
         self._offscreen_render: bool  # 0: Disabled, 1: Enabled
         self._sim_experience_file: str  # Experience file to load
         self._visualizer_max_worlds: int | None  # Optional max worlds override for Newton-based visualizers
+        self._video_enabled: bool  # Whether --video recording is enabled
+        self._video_auto_start_kit: bool  # Whether headless video should auto-inject Kit visualizer
 
         # Exposed to train scripts
         self.device_id: int  # device ID for GPU simulation (defaults to 0)
@@ -858,14 +860,28 @@ def _resolve_xr_settings(self, launcher_args: dict):
 
     def _resolve_viewport_settings(self, launcher_args: dict):
         """Resolve viewport related settings."""
+        self._video_enabled = bool(launcher_args.get("video", False))
         # Check if we can disable the viewport to improve performance
         #   This should only happen if we are running headless and do not require livestreaming or video recording
         #   This is different from offscreen_render because this only affects the default viewport and
         #   not other render-products in the scene
         self._render_viewport = True
-        if self._headless and not self._livestream and not launcher_args.get("video", False):
+        if self._headless and not self._livestream and not self._video_enabled:
             self._render_viewport = False
 
+        # Auto-start a headless Kit visualizer when recording video without an explicit
+        # visualizer selection. This ensures app.update() is pumped and camera updates
+        # can be forwarded from viewer settings.
+        has_explicit_kit = self._cli_visualizer_explicit and "kit" in set(self._cli_visualizer_types)
+        self._video_auto_start_kit = (
+            self._video_enabled
+            and self._headless
+            and not self._livestream
+            and not self._xr
+            and not self._cli_visualizer_disable_all
+            and not has_explicit_kit
+        )
+
         # hide_ui flag
         launcher_args["hide_ui"] = False
         if self._headless and not self._livestream:
@@ -1085,6 +1101,9 @@ def _load_extensions(self):
         # (no Kit GUI) the AR profile must be enabled programmatically so that
         # the OpenXR session starts without user interaction
         settings.set_bool("/isaaclab/xr/auto_start", self._headless and self._xr)
+        # set setting to indicate video recording mode and optional Kit auto-start
+        settings.set_bool("/isaaclab/video/enabled", self._video_enabled)
+        settings.set_bool("/isaaclab/video/auto_start_kit", self._video_auto_start_kit)
 
         # set setting to indicate no RTX sensors are used (set to True when RTX sensor is created)
         settings.set_bool("/isaaclab/render/rtx_sensors", False)

source/isaaclab/isaaclab/envs/common.py

@@ -21,10 +21,10 @@
 class ViewerCfg:
     """Configuration of the scene viewport camera."""
 
-    position: tuple[float, float, float] = (7.5, 17.5, 17.5)
+    eye: tuple[float, float, float] = (7.5, 7.5, 117.5)
     """Initial camera position (in m). Default is (7.5, 7.5, 7.5)."""
 
-    target_position: tuple[float, float, float] = (0.0, 0.0, 5.0)
+    lookat: tuple[float, float, float] = (0.0, 0.0, 0.0)
     """Initial camera target position (in m). Default is (0.0, 0.0, 0.0)."""
 
     cam_prim_path: str = "/OmniverseKit_Persp"
@@ -38,7 +38,7 @@ class ViewerCfg:
     """
 
     origin_type: Literal["world", "env", "asset_root", "asset_body"] = "world"
-    """The frame in which the camera position and target are defined in. Default is "world".
+    """The frame in which the camera eye and lookat are defined in. Default is "world".
 
     Available options are:
 

source/isaaclab/isaaclab/envs/manager_based_env.py

@@ -168,7 +168,9 @@ def _init_sim(self):
         # non-rendering modes.
         # Initialize when GUI is available OR when visualizers are active (headless rendering)
         # Visualizers support camera updates via sim.set_camera_view() which forwards to all active visualizers
-        has_visualizers = bool(self.sim.get_setting("/isaaclab/visualizer/types"))
+        has_visualizers = bool(self.sim.get_setting("/isaaclab/visualizer/types")) or bool(
+            self.sim.get_setting("/isaaclab/video/auto_start_kit")
+        )
         if self.sim.has_gui or has_visualizers:
             self.viewport_camera_controller = ViewportCameraController(self, self.cfg.viewer)
         else:

source/isaaclab/isaaclab/envs/mdp/commands/velocity_command.py

@@ -8,8 +8,6 @@
 from __future__ import annotations
 
 import logging
-import os
-import re
 from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
@@ -28,7 +26,6 @@
 
 # import logger
 logger = logging.getLogger(__name__)
-_VIS_DEBUG_ENABLED = os.getenv("ISAACLAB_VIS_DEBUG", "0").lower() in {"1", "true", "yes", "on"}
 
 
 class UniformVelocityCommand(CommandTerm):
@@ -87,9 +84,6 @@ def __init__(self, cfg: UniformVelocityCommandCfg, env: ManagerBasedEnv):
         self.heading_target = torch.zeros(self.num_envs, device=self.device)
         self.is_heading_env = torch.zeros(self.num_envs, dtype=torch.bool, device=self.device)
         self.is_standing_env = torch.zeros_like(self.is_heading_env)
-        self._debug_vis_callback_count = 0
-        self._debug_env0_probe_body_path: str | None = None
-        self._debug_env0_probe_status: str = "uninitialized"
         # -- metrics
         self.metrics["error_vel_xy"] = torch.zeros(self.num_envs, device=self.device)
         self.metrics["error_vel_yaw"] = torch.zeros(self.num_envs, device=self.device)
@@ -207,83 +201,6 @@ def _debug_vis_callback(self, event):
         # display markers
         self.goal_vel_visualizer.visualize(base_pos_w, vel_des_arrow_quat, vel_des_arrow_scale)
         self.current_vel_visualizer.visualize(base_pos_w, vel_arrow_quat, vel_arrow_scale)
-        self._debug_vis_callback_count += 1
-        if _VIS_DEBUG_ENABLED and (
-            self._debug_vis_callback_count <= 3 or self._debug_vis_callback_count % 120 == 0
-        ):
-            mean_cmd = float(torch.linalg.norm(self.command[:, :2], dim=-1).mean().item())
-            mean_vel = float(torch.linalg.norm(wp.to_torch(self.robot.data.root_lin_vel_b)[:, :2], dim=-1).mean().item())
-            tensor_root_pos = wp.to_torch(self.robot.data.root_pos_w)[0].detach().cpu()
-            fabric_root_pos = self._get_env0_fabric_probe_position()
-            root_view_pos = self._get_env0_root_view_position()
-            robot_root = self._resolve_env0_robot_root_path()
-            fabric_base_pos = self._get_fabric_position_for_path(f"{robot_root}/base") if robot_root else None
-            fabric_trunk_pos = self._get_fabric_position_for_path(f"{robot_root}/trunk") if robot_root else None
-            if fabric_root_pos is not None:
-                fabric_root_pos_t = torch.tensor(fabric_root_pos, dtype=tensor_root_pos.dtype)
-                delta = torch.linalg.norm(tensor_root_pos - fabric_root_pos_t).item()
-                root_view_delta = None
-                if root_view_pos is not None:
-                    root_view_pos_t = torch.tensor(root_view_pos, dtype=tensor_root_pos.dtype)
-                    root_view_delta = torch.linalg.norm(tensor_root_pos - root_view_pos_t).item()
-                logger.warning(
-                    "[VIS-DEBUG][UniformVelocityCommand._debug_vis_callback] count=%d mean_cmd_xy=%.4f "
-                    "mean_vel_xy=%.4f env0_tensor_root=(%.3f, %.3f, %.3f) env0_fabric_root=(%.3f, %.3f, %.3f) "
-                    "tensor_fabric_delta=%.5f root_view_delta=%s fabric_base=%s fabric_trunk=%s "
-                    "probe_path=%s probe_status=%s",
-                    self._debug_vis_callback_count,
-                    mean_cmd,
-                    mean_vel,
-                    float(tensor_root_pos[0]),
-                    float(tensor_root_pos[1]),
-                    float(tensor_root_pos[2]),
-                    float(fabric_root_pos_t[0]),
-                    float(fabric_root_pos_t[1]),
-                    float(fabric_root_pos_t[2]),
-                    float(delta),
-                    f"{root_view_delta:.5f}" if root_view_delta is not None else "<unavailable>",
-                    (
-                        f"({fabric_base_pos[0]:.3f}, {fabric_base_pos[1]:.3f}, {fabric_base_pos[2]:.3f})"
-                        if fabric_base_pos is not None
-                        else "<unavailable>"
-                    ),
-                    (
-                        f"({fabric_trunk_pos[0]:.3f}, {fabric_trunk_pos[1]:.3f}, {fabric_trunk_pos[2]:.3f})"
-                        if fabric_trunk_pos is not None
-                        else "<unavailable>"
-                    ),
-                    self._debug_env0_probe_body_path or "<unresolved>",
-                    self._debug_env0_probe_status,
-                )
-            else:
-                logger.warning(
-                    "[VIS-DEBUG][UniformVelocityCommand._debug_vis_callback] count=%d mean_cmd_xy=%.4f "
-                    "mean_vel_xy=%.4f env0_tensor_root=(%.3f, %.3f, %.3f) env0_fabric_root=<unavailable> "
-                    "root_view=%s fabric_base=%s fabric_trunk=%s probe_path=%s probe_status=%s",
-                    self._debug_vis_callback_count,
-                    mean_cmd,
-                    mean_vel,
-                    float(tensor_root_pos[0]),
-                    float(tensor_root_pos[1]),
-                    float(tensor_root_pos[2]),
-                    (
-                        f"({root_view_pos[0]:.3f}, {root_view_pos[1]:.3f}, {root_view_pos[2]:.3f})"
-                        if root_view_pos is not None
-                        else "<unavailable>"
-                    ),
-                    (
-                        f"({fabric_base_pos[0]:.3f}, {fabric_base_pos[1]:.3f}, {fabric_base_pos[2]:.3f})"
-                        if fabric_base_pos is not None
-                        else "<unavailable>"
-                    ),
-                    (
-                        f"({fabric_trunk_pos[0]:.3f}, {fabric_trunk_pos[1]:.3f}, {fabric_trunk_pos[2]:.3f})"
-                        if fabric_trunk_pos is not None
-                        else "<unavailable>"
-                    ),
-                    self._debug_env0_probe_body_path or "<unresolved>",
-                    self._debug_env0_probe_status,
-                )
 
     """
     Internal helpers.
@@ -306,110 +223,6 @@ def _resolve_xy_velocity_to_arrow(self, xy_velocity: torch.Tensor) -> tuple[torc
 
         return arrow_scale, arrow_quat
 
-    def _resolve_env0_robot_root_path(self) -> str | None:
-        """Best-effort resolve env_0 robot root path from articulation cfg prim path."""
-        prim_path = getattr(self.robot.cfg, "prim_path", None)
-        if not isinstance(prim_path, str) or not prim_path:
-            return None
-        path = prim_path
-        if "{ENV_REGEX_NS}" in path:
-            path = path.replace("{ENV_REGEX_NS}", "/World/envs/env_0")
-        path = path.replace("env_.*", "env_0")
-        path = re.sub(r"\.\*$", "0", path)
-        return path
-
-    def _resolve_env0_fabric_probe_body_path(self) -> str | None:
-        """Resolve a rigid-body prim path for env_0 suitable for Fabric world-matrix probing."""
-        if self._debug_env0_probe_body_path is not None:
-            return self._debug_env0_probe_body_path
-        try:
-            from pxr import UsdPhysics
-
-            stage = self._env.sim.stage
-            if stage is None:
-                self._debug_env0_probe_status = "no_stage"
-                return None
-            robot_root = self._resolve_env0_robot_root_path()
-            if not robot_root:
-                self._debug_env0_probe_status = "no_robot_root_path"
-                return None
-            root_prim = stage.GetPrimAtPath(robot_root)
-            if not root_prim.IsValid():
-                self._debug_env0_probe_status = f"invalid_robot_root:{robot_root}"
-                return None
-
-            # First try common body names directly under Robot to avoid brittle traversal assumptions.
-            fallback_candidates = [
-                f"{robot_root}/base",
-                f"{robot_root}/base_link",
-                f"{robot_root}/trunk",
-                f"{robot_root}/pelvis",
-            ]
-            for candidate in fallback_candidates:
-                prim = stage.GetPrimAtPath(candidate)
-                if prim.IsValid() and prim.HasAPI(UsdPhysics.RigidBodyAPI):
-                    self._debug_env0_probe_body_path = candidate
-                    self._debug_env0_probe_status = "resolved_fallback_candidate"
-                    return self._debug_env0_probe_body_path
-
-            preferred_names = {"base", "base_link", "trunk", "pelvis"}
-            for prim in root_prim.Traverse():
-                if not prim.IsValid() or not prim.HasAPI(UsdPhysics.RigidBodyAPI):
-                    continue
-                if prim.GetName() in preferred_names:
-                    self._debug_env0_probe_body_path = prim.GetPath().pathString
-                    self._debug_env0_probe_status = "resolved_traverse_preferred"
-                    return self._debug_env0_probe_body_path
-            for prim in root_prim.Traverse():
-                if prim.IsValid() and prim.HasAPI(UsdPhysics.RigidBodyAPI):
-                    self._debug_env0_probe_body_path = prim.GetPath().pathString
-                    self._debug_env0_probe_status = "resolved_traverse_first_rigidbody"
-                    return self._debug_env0_probe_body_path
-            self._debug_env0_probe_status = "no_rigidbody_under_robot_root"
-        except Exception:
-            self._debug_env0_probe_status = "resolve_exception"
-            return None
-        return None
-
-    def _get_env0_fabric_probe_position(self) -> tuple[float, float, float] | None:
-        """Read env_0 probe body world translation from Fabric backend."""
-        body_path = self._resolve_env0_fabric_probe_body_path()
-        if not body_path:
-            return None
-        return self._get_fabric_position_for_path(body_path)
-
-    def _get_fabric_position_for_path(self, body_path: str) -> tuple[float, float, float] | None:
-        """Read a body world translation from Fabric backend."""
-        try:
-            import isaacsim.core.experimental.utils.backend as backend_utils
-            import isaacsim.core.experimental.utils.prim as prim_utils
-            import numpy as np
-
-            with backend_utils.use_backend("fabric"):
-                world_matrix = prim_utils.get_prim_attribute_value(body_path, "omni:fabric:worldMatrix")
-            translation = np.array(world_matrix.ExtractTranslation(), dtype=float)
-            self._debug_env0_probe_status = "fabric_read_ok"
-            return (float(translation[0]), float(translation[1]), float(translation[2]))
-        except Exception:
-            self._debug_env0_probe_status = "fabric_read_exception"
-            return None
-
-    def _get_env0_root_view_position(self) -> tuple[float, float, float] | None:
-        """Read env_0 articulation root position directly from PhysX root_view."""
-        try:
-            root_transforms = self.robot.root_view.get_root_transforms()
-            root_transforms_t = wp.to_torch(root_transforms)
-            if root_transforms_t.ndim >= 2 and root_transforms_t.shape[1] >= 3 and root_transforms_t.shape[0] > 0:
-                return (
-                    float(root_transforms_t[0, 0].item()),
-                    float(root_transforms_t[0, 1].item()),
-                    float(root_transforms_t[0, 2].item()),
-                )
-        except Exception:
-            return None
-        return None
-
-
 class NormalVelocityCommand(UniformVelocityCommand):
     """Command generator that generates a velocity command in SE(2) from a normal distribution.
 

source/isaaclab/isaaclab/envs/ui/base_env_window.py

@@ -225,14 +225,14 @@ def _build_viewer_frame(self):
                 self.ui_window_elements["viewer_eye"] = isaacsim.gui.components.ui_utils.xyz_builder(
                     label="Camera Eye",
                     tooltip="Modify the XYZ location of the viewer eye.",
-                    default_val=self.env.cfg.viewer.position,
+                    default_val=self.env.cfg.viewer.eye,
                     step=0.1,
                     on_value_changed_fn=[self._set_viewer_location_fn] * 3,
                 )
                 self.ui_window_elements["viewer_lookat"] = isaacsim.gui.components.ui_utils.xyz_builder(
                     label="Camera Target",
                     tooltip="Modify the XYZ location of the viewer target.",
-                    default_val=self.env.cfg.viewer.target_position,
+                    default_val=self.env.cfg.viewer.lookat,
                     step=0.1,
                     on_value_changed_fn=[self._set_viewer_location_fn] * 3,
                 )

source/isaaclab/isaaclab/envs/ui/viewport_camera_controller.py

@@ -50,9 +50,9 @@ def __init__(self, env: ManagerBasedEnv | DirectRLEnv, cfg: ViewerCfg):
         # store inputs
         self._env = env
         self._cfg = copy.deepcopy(cfg)
-        # cast viewer position and target to numpy arrays
-        self.default_cam_eye = np.array(self._cfg.position, dtype=float)
-        self.default_cam_lookat = np.array(self._cfg.target_position, dtype=float)
+        # cast viewer eye and look-at to numpy arrays
+        self.default_cam_eye = np.array(self._cfg.eye, dtype=float)
+        self.default_cam_lookat = np.array(self._cfg.lookat, dtype=float)
 
         # set the camera origins
         if self.cfg.origin_type == "env":