vuer-cli 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

vuer_cli/scripts/minimap.py

@@ -1,41 +1,22 @@
-"""Minimap visualization with GLB model, camera frustums, and depth point clouds."""
+"""Minimap visualization with GLB model and depth point clouds."""
 
+import asyncio
 import warnings
 from dataclasses import dataclass
 from pathlib import Path
 from textwrap import dedent
 from typing import List, Optional
 
+from vuer.schemas import (
+  DepthPointCloudProvider,
+  InPlaceDepthPointCloud,
+)
+
 from ..utils import print_error
 
 warnings.filterwarnings("ignore", category=RuntimeWarning)
 
 
-def create_camera_positions_around_center(radius=1.0, height=0.0):
-  """Create four camera positions around a center point at 90-degree intervals."""
-  import numpy as np
-
-  positions = []
-  for angle in [0, np.pi / 2, np.pi, 3 * np.pi / 2]:
-    x = radius * np.cos(angle)
-    y = radius * np.sin(angle)
-    z = height
-    positions.append([x, y, z])
-  return positions
-
-
-def create_camera_rotations_looking_at_center():
-  """Create rotations for cameras to look at the center point."""
-  import numpy as np
-
-  return [
-    [0, -np.pi / 2, np.pi / 2],
-    [np.pi / 2, 0, 0],
-    [-np.pi / 2, np.pi / 2, 0],
-    [np.pi / 2, -np.pi, np.pi],
-  ]
-
-
 def collect_depth_frames(
   data_dir: str,
   camera_names: Optional[List[str]] = None,
@@ -107,15 +88,23 @@ def collect_depth_frames(
         flip_xy = np.array([[-1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
         t_final = flip_xy @ t_ref
 
-        # Extract position and rotation
+        # Extract camera position and rotation
         position = t_final[:3, 3].tolist()
 
-        # Convert rotation matrix to euler angles (XYZ order)
         from scipy.spatial.transform import Rotation
 
         rot_matrix = t_final[:3, :3]
         rotation = Rotation.from_matrix(rot_matrix).as_euler("xyz").tolist()
 
+        # Compute baselink transform (robot base, not camera)
+        t_base_ref = np.linalg.inv(first_camera_transform) @ t_world_to_base
+        t_base_final = flip_xy @ t_base_ref
+        baselink_position = t_base_final[:3, 3].tolist()
+        baselink_rot_matrix = t_base_final[:3, :3]
+        baselink_rotation = (
+          Rotation.from_matrix(baselink_rot_matrix).as_euler("xyz").tolist()
+        )
+
         frames.append(
           {
             "depth_file": pair["depth_file"],
@@ -123,6 +112,8 @@ def collect_depth_frames(
             "timestamp_s": pair["timestamp_s"],
             "position": position,
             "rotation": rotation,
+            "baselink_position": baselink_position,
+            "baselink_rotation": baselink_rotation,
             "intrinsics": generator.intrinsics,
           }
         )
@@ -133,111 +124,48 @@ def collect_depth_frames(
   return frames
 
 
-def create_proxie_group(
-  group_id: int,
-  initial_position=None,
-  initial_rotation=None,
-  opacity: float = 1.0,
-  glb_url: str = None,
-):
-  """Create a group containing a GLB model with four camera frustums."""
-  from vuer.schemas import Frustum, Glb, Group
-
-  if initial_position is None:
-    initial_position = [0, 0, 0]
-  if initial_rotation is None:
-    initial_rotation = [0, 0, 0]
-
-  camera_positions = create_camera_positions_around_center(radius=0.1, height=1.625)
-  camera_rotations = create_camera_rotations_looking_at_center()
-
-  frustums = []
-  for i, (pos, rot) in enumerate(zip(camera_positions, camera_rotations, strict=False)):
-    offsets = {0: (0.20, 0.008), 1: (0.17, -0.025), 2: (0.18, 0.005), 3: (0.185, 0.02)}
-    if i in offsets:
-      pos[0] += offsets[i][0]
-      pos[1] += offsets[i][1]
-
-    frustums.append(
-      Frustum(
-        key=f"frustum-{group_id}-{i}",
-        position=pos,
-        rotation=rot,
-        scale=0.1,
-        fov=60,
-        aspect=16 / 9,
-        near=0.1,
-        far=0.2,
-        showFrustum=True,
-        showImagePlane=True,
-        showFocalPlane=False,
-        colorFrustum="cyan",
-      )
-    )
-
-  initial_position[0] += 0
-  initial_position[1] += 2
-  initial_position[2] += 0
-  initial_rotation[0] += -1.57
-
-  return Group(
-    Glb(
-      src=glb_url,
-      position=[0, 0, 0],
-      rotation=[1.57, 0, 0],
-      scale=0.01,
-      opacity=opacity,
-      key=f"model-{group_id}",
-    ),
-    *frustums,
-    position=initial_position,
-    rotation=initial_rotation,
-    scale=1.0,
-    key=f"group-{group_id}",
-  )
-
-
 async def main_viz(
   sess,
-  workspace,
+  app,
+  scene_store,
   depth_frames: List[dict],
   cmap: str = "turbo",
   color_mode: str = "depth",
   fov: float = 58.0,
   max_depth: float = 10.0,
-  num_groups: int = 3,
-  group_spacing: float = 2.0,
-  base_position: Optional[List[float]] = None,
   glb_url: str = None,
+  fps: float = 10.0,
+  loop: bool = True,
 ):
-  """Main visualization with DepthPointCloud components."""
-  import cv2
+  """Main visualization with frame-by-frame depth point cloud and robot model playback."""
+  import math
 
-  from vuer.schemas import DepthPointCloud, DepthPointCloudProvider, Scene
+  from vuer.schemas import Glb
 
-  # png encoder for depth images
-  def png_encode(image):
-    """Encode image as PNG bytes."""
-    _, buffer = cv2.imencode(".png", image)
-    return buffer.tobytes()
+  print("Setting up scene...")
 
-  print("Loading scene...")
+  # Link all depth files upfront
+  for i, frame in enumerate(depth_frames):
+    depth_filename = f"depth/{i}.png"
+    app.workspace.link(Path(frame["depth_file"]), f"/{depth_filename}")
 
-  # Create virtual file endpoints for each depth frame
-  depth_point_clouds = []
+  # Construct proper GLB URL using workspace prefix
+  glb_full_url = str(app.localhost_prefix / glb_url)
 
-  for i, frame in enumerate(depth_frames):
-    depth_path = f"/depth/{i}.png"
+  # clear the default scene (removes lighting / grid)
+  # scene_store.set @ Scene(up=[0, 1, 0])
+  # Set initial scene from the scene store
+  # sess.upsert @ scene_store.scene
+  await asyncio.sleep(0.01)
 
-    # Link the depth file to a virtual endpoint
-    def make_loader(frame_info):
-      def load_depth():
-        depth = cv2.imread(str(frame_info["depth_file"]), cv2.IMREAD_UNCHANGED)
-        return png_encode(depth)
+  frame_delay = 1.0 / fps
+  frame_idx = 0
 
-      return load_depth
+  print(f"Starting playback: {len(depth_frames)} frames at {fps} FPS (loop={loop})")
 
-    workspace.link(make_loader(frame), depth_path)
+  while True:
+    frame = depth_frames[frame_idx]
+    depth_filename = f"depth/{frame_idx}.png"
 
     # Compute FOV from intrinsics if available
     frame_fov = fov
@@ -245,56 +173,47 @@ async def main_viz(
       fx = frame["intrinsics"].get("fx", None)
       height = frame["intrinsics"].get("height", None)
       if fx and height:
-        import numpy as np
-
-        frame_fov = 2 * np.arctan(height / (2 * fx)) * 180 / np.pi
-
-    depth_point_clouds.append(
-      DepthPointCloud(
-        key=f"depth-pc-{i}",
-        depth=depth_path,
-        cmap=cmap,
-        colorMode=color_mode,
-        fov=frame_fov,
-        position=frame["position"],
-        rotation=frame["rotation"],
-        maxDepth=max_depth,
-      )
-    )
-
-  print(f"Created {len(depth_point_clouds)} depth point clouds")
-
-  # Create robot model groups
-  if num_groups > 1:
-    opacity_values = [1.0 - (0.3 * i / (num_groups - 1)) for i in range(num_groups)]
-  else:
-    opacity_values = [1.0]
-
-  groups = [
-    create_proxie_group(
-      i,
-      [base_position[0], base_position[1], base_position[2] - i * group_spacing],
-      [0, 0, 0],
-      opacity_values[i],
-      glb_url=glb_url,
+        frame_fov = 2 * math.atan(height / (2 * fx)) * 180 / math.pi
+
+    depth_pc = InPlaceDepthPointCloud(
+      key="depth-pc-current",
+      depth=app.localhost_prefix / depth_filename,
+      cmap=cmap,
+      colorMode=color_mode,
+      fov=frame_fov,
+      position=frame["position"],
+      rotation=frame["rotation"],
+      maxDepth=max_depth,
     )
-    for i in range(num_groups)
-  ]
 
-  # Build scene with DepthPointCloudProvider for high performance
-  print("Setting up scene...")
-  sess.upsert @ Scene(
-    *groups,
-    DepthPointCloudProvider(
-      *depth_point_clouds,
+    scene_store.upsert @ DepthPointCloudProvider(
+      depth_pc,
       key="depth-provider",
       frustumCulling=True,
-    ),
-    up=[0, 1, 0],
-  )
+    )
+
+    # Update robot model position based on baselink transform
+    baselink_pos = frame["baselink_position"]
+    baselink_rot = frame["baselink_rotation"]
+
+    scene_store.upsert @ Glb(
+      src=glb_full_url,
+      position=[baselink_pos[0], baselink_pos[1] + 2, baselink_pos[2]],
+      rotation=[baselink_rot[0] - 1.57, baselink_rot[1], baselink_rot[2]],
+      scale=[0.01, 0.01, 0.01],
+      key="proxie-model",
+    )
+
+    await asyncio.sleep(frame_delay)
+
+    frame_idx += 1
+    if frame_idx >= len(depth_frames):
+      if loop:
+        frame_idx = 0
+      else:
+        break
 
-  print("Ready! Open browser to view.")
-  await sess.forever()
+  print("Playback complete.")
 
 
 @dataclass
@@ -303,13 +222,13 @@ class Minimap:
 
   DESCRIPTION
       Creates an interactive 3D visualization combining a GLB robot model with
-      camera frustums and depth-based point clouds using DepthPointCloud components.
-      Uses Workspace virtual files for efficient depth image serving.
+      depth-based point clouds using DepthPointCloud components. The robot model
+      moves frame-by-frame following the baselink trajectory.
+      Uses Workspace path linking for efficient depth image streaming.
 
       Features:
       - High-performance depth point cloud rendering with frustum culling
-      - Multiple robot model instances with configurable spacing
-      - Four camera frustums per robot showing sensor coverage
+      - Robot model that follows the trajectory frame-by-frame
       - Colormap support (turbo, viridis, inferno, jet)
       - Multiple color modes (depth, camZ, camDist, localY, worldY)
 
@@ -333,9 +252,6 @@ class Minimap:
       # Sparse sampling for faster loading
       vuer minimap --data-dir /path/to/data --frame-step 10
 
-      # Custom robot model groups
-      vuer minimap --data-dir /path/to/data --num-groups 5 --group-spacing 1.0
-
   DEPENDENCIES
       Requires: pip install 'vuer-cli[viz]'
   """
@@ -347,25 +263,26 @@ class Minimap:
   max_frames: int = None  # Max frames per camera
   frame_step: int = 5  # Process every Nth frame
   cmap: str = "turbo"  # Colormap (turbo, viridis, inferno, jet)
-  color_mode: str = "depth"  # Color mode (depth, camZ, camDist, localY, worldY)
+  color_mode: str = "worldY"  # Color mode (depth, camZ, camDist, localY, worldY)
   fov: float = 58.0  # Default camera FOV (RealSense D435)
   max_depth: float = 10.0  # Maximum depth in meters
 
   # Model options
-  assets_folder: str = None  # Static assets folder for GLB model
   glb_url: str = "proxie.glb"  # GLB model URL
-  num_groups: int = 10  # Number of robot groups to create
-  group_spacing: float = 0.5  # Spacing between groups along Z-axis
-  base_position: str = "-2.0,-2.2,0"  # Starting position [x,y,z]
+
+  # Playback options
+  fps: float = 10.0  # Frames per second for playback
+  loop: bool = True  # Loop playback
 
   # Server options
   host: str = "0.0.0.0"
   port: int = 8012
 
-  def run(self) -> int:
+  def __call__(self) -> int:
     """Execute minimap command."""
     try:
-      from vuer import Vuer, Workspace
+      from vuer import Vuer
+      from vuer.rtc.scene_store import SceneStore
     except ImportError as e:
       print_error(
         f"Missing dependencies for minimap command: {e}\n\n"
@@ -384,8 +301,6 @@ class Minimap:
       if self.cameras:
         camera_list = [c.strip() for c in self.cameras.split(",")]
 
-      base_pos_list = [float(x.strip()) for x in self.base_position.split(",")]
-
       # Collect depth frames
       print("Collecting depth frames...")
       depth_frames = collect_depth_frames(
@@ -401,26 +316,8 @@ class Minimap:
 
       print(f"Found {len(depth_frames)} depth frames")
 
-      # Create workspace for virtual files
-      workspace = Workspace()
-
-      # Set up assets folder
-      assets_folder = self.assets_folder
-      if not assets_folder:
-        import vuer_cli
-
-        assets_folder = Path(vuer_cli.__file__).parent.parent.parent / "assets"
-        if not assets_folder.exists():
-          assets_folder = None
-
-      if assets_folder:
-        print(f"Using assets folder: {assets_folder}")
-        app = Vuer(host=self.host, port=self.port, workspace=assets_folder)
-      else:
-        app = Vuer(host=self.host, port=self.port)
-
-      # Merge workspace into app
-      app.workspace = workspace
+      # Use current working directory as workspace
+      app = Vuer(host=self.host, port=self.port, workspace=Path.cwd())
 
       print(
         dedent(f"""
@@ -429,25 +326,31 @@ class Minimap:
           Depth frames: {len(depth_frames)}
           Colormap: {self.cmap}
           Color mode: {self.color_mode}
+          FPS: {self.fps}
+          Loop: {self.loop}
       """).strip()
       )
 
+      scene_store = SceneStore()
+
       @app.spawn(start=True)
       async def main_with_args(sess):
         print("Session started, loading data...")
-        await main_viz(
-          sess,
-          workspace=workspace,
-          depth_frames=depth_frames,
-          cmap=self.cmap,
-          color_mode=self.color_mode,
-          fov=self.fov,
-          max_depth=self.max_depth,
-          num_groups=self.num_groups,
-          group_spacing=self.group_spacing,
-          base_position=base_pos_list,
-          glb_url=self.glb_url,
-        )
+        async with scene_store.subscribe(sess):
+          await main_viz(
+            sess,
+            app=app,
+            scene_store=scene_store,
+            depth_frames=depth_frames,
+            cmap=self.cmap,
+            color_mode=self.color_mode,
+            fov=self.fov,
+            max_depth=self.max_depth,
+            glb_url=self.glb_url,
+            fps=self.fps,
+            loop=self.loop,
+          )
+          await sess.forever()
 
       return 0
 

vuer_cli/scripts/viz_ptc_cams.py

@@ -552,7 +552,7 @@ class VizPtcCams:
   max_depth: float = 10.0  # Maximum depth in meters
   no_animation: bool = False  # Show complete point cloud at once
 
-  def run(self) -> int:
+  def __call__(self) -> int:
     """Execute viz_ptc_cams command."""
     try:
       import cv2

vuer_cli/scripts/viz_ptc_proxie.py

@@ -403,7 +403,7 @@ class VizPtcProxie:
   host: str = "0.0.0.0"  # Server host
   port: int = 8012  # Server port
 
-  def run(self) -> int:
+  def __call__(self) -> int:
     """Execute viz_ptc_proxie command."""
     try:
       import cv2