Update nano_WaveGen/utils/visualize_training.py

nano_WaveGen/utils/visualize_training.py

@@ -19,6 +19,7 @@ import cv2
 import time
 import webbrowser
 from scipy.spatial.transform import Rotation
+import threading
 
 # 导入深度转点云模块
 try:
@@ -79,6 +80,7 @@ class TrainingVisualizer:
         self.camera_rgb_handle = None
         self.coordinate_frame_handle = None
         self.mesh_handles_pool = {}
+        self.object_label_handles = []  # 物体信息标签
 
         # 当前数据
         self.predictions_npz = None
@@ -95,6 +97,12 @@ class TrainingVisualizer:
         # 播放状态
         self.is_playing = False
 
+        # 视频导出状态
+        self.is_exporting = False
+        self.export_progress = 0
+        self.export_camera_pos = None
+        self.export_camera_wxyz = None
+
         # 设置场景
         self.setup_scene()
 
@@ -112,15 +120,25 @@ class TrainingVisualizer:
 
     def setup_scene(self):
         """设置场景背景和坐标系"""
-        # 设置深蓝色背景
-        bg_color = [13, 13, 38]
-        width, height = 1920, 1080
-        solid_color_image = np.full((height, width, 3), bg_color, dtype=np.uint8)
-        self.server.scene.set_background_image(solid_color_image, format="png")
+        # 设置深蓝色背景（默认）
+        self.update_background(wireframe_mode=False)
 
         # 设置坐标系方向
         self.server.scene.set_up_direction("+y")
 
+    def update_background(self, wireframe_mode: bool):
+        """更新场景背景颜色"""
+        if wireframe_mode:
+            # 线框模式：全黑背景
+            bg_color = [0, 0, 0]
+        else:
+            # 正常模式：深蓝色背景
+            bg_color = [13, 13, 38]
+
+        width, height = 1920, 1080
+        solid_color_image = np.full((height, width, 3), bg_color, dtype=np.uint8)
+        self.server.scene.set_background_image(solid_color_image, format="png")
+
     def scan_training_outputs(self):
         """扫描core_space目录下的训练输出"""
         self.training_outputs = []
@@ -233,6 +251,11 @@ class TrainingVisualizer:
             )
             self.gui_controls['gt_color'].on_update(self._on_color_change)
 
+            self.gui_controls['show_object_info'] = self.server.gui.add_checkbox(
+                "显示物体信息", initial_value=False
+            )
+            self.gui_controls['show_object_info'].on_update(self._on_visibility_change)
+
         # 点云控制
         with self.server.gui.add_folder("点云显示"):
             self.gui_controls['show_pointcloud'] = self.server.gui.add_checkbox(
@@ -257,6 +280,11 @@ class TrainingVisualizer:
             )
             self.gui_controls['show_coordinate'].on_update(self._on_visibility_change)
 
+            self.gui_controls['wireframe_mode'] = self.server.gui.add_checkbox(
+                "线框模式 (黑白边缘)", initial_value=False
+            )
+            self.gui_controls['wireframe_mode'].on_update(self._on_wireframe_mode_change)
+
         # 相机控制
         with self.server.gui.add_folder("相机控制"):
             self.gui_controls['reset_view'] = self.server.gui.add_button("重置视角")
@@ -278,6 +306,29 @@ class TrainingVisualizer:
             self.gui_controls['show_pred_frustum'].on_update(self._on_visibility_change)
             self.gui_controls['show_camera_rgb'].on_update(self._on_visibility_change)
 
+        # 视频导出
+        with self.server.gui.add_folder("视频导出"):
+            self.gui_controls['export_status'] = self.server.gui.add_text(
+                "状态", initial_value="就绪"
+            )
+
+            self.gui_controls['export_resolution'] = self.server.gui.add_slider(
+                "导出分辨率", min=480, max=1080, step=120, initial_value=720
+            )
+
+            self.gui_controls['capture_camera_button'] = self.server.gui.add_button(
+                "📸 捕获当前视角"
+            )
+            self.gui_controls['capture_camera_button'].on_click(self._on_capture_camera)
+
+            self.gui_controls['export_viser_button'] = self.server.gui.add_button(
+                "💾 导出场景(.viser)"
+            )
+            self.gui_controls['export_viser_button'].on_click(self._on_export_viser)
+
+            self.gui_controls['export_button'] = self.server.gui.add_button("🎬 导出视频(MP4)")
+            self.gui_controls['export_button'].on_click(self._on_export_video)
+
         print(f"✅ GUI 已设置 - 创建了 {len(self.gui_controls)} 个控件")
 
     def _on_output_change(self, event):
@@ -426,6 +477,21 @@ class TrainingVisualizer:
         self.mesh_handles_pool.clear()
         self.visualize_frame(self.current_frame)
 
+    def _on_wireframe_mode_change(self, event):
+        """线框模式改变"""
+        wireframe_mode = event.target.value
+
+        # 更新背景颜色
+        self.update_background(wireframe_mode)
+
+        # 清空对象池，强制重新生成mesh（应用线框模式）
+        for mesh in self.mesh_handles_pool.values():
+            mesh.remove()
+        self.mesh_handles_pool.clear()
+
+        # 重新可视���当前帧
+        self.visualize_frame(self.current_frame)
+
     def _on_reset_view(self, event):
         """重置视角"""
         # 设置默认相机位置
@@ -534,7 +600,11 @@ class TrainingVisualizer:
                     except Exception:
                         pass
 
-        if show_pointcloud:
+        # 线框模式下不显示点云（黑背景下点云不清晰）
+        wireframe_mode = self.gui_controls.get('wireframe_mode', None)
+        is_wireframe = wireframe_mode.value if wireframe_mode else False
+
+        if show_pointcloud and not is_wireframe:
             # 点云用同一center/scale做归一化
             self._visualize_pointcloud(frame_idx, scene_center=self.scene_center, scene_scale=self.scene_scale)
 
@@ -558,6 +628,11 @@ class TrainingVisualizer:
                 is_gt=True
             )
 
+            # 显示物体信息（如果启用且不在线框模式）
+            show_info = self.gui_controls['show_object_info'].value
+            if show_info and not is_wireframe:
+                self._visualize_object_labels(frame_idx, targets, is_gt=True)
+
         # 显示坐标系
         if show_coordinate:
             self.coordinate_frame_handle = self.server.scene.add_frame(
@@ -568,8 +643,9 @@ class TrainingVisualizer:
                 axes_radius=0.01
             )
 
-        # 可视化相机椎体/RGB
-        self._visualize_cameras(frame_idx)
+        # 可视化相机椎体/RGB（线框模式下不显示）
+        if not is_wireframe:
+            self._visualize_cameras(frame_idx)
 
     def _extract_predictions(self, frame_idx: int) -> Optional[np.ndarray]:
         """提取预测数据 (新格式)"""
@@ -674,6 +750,62 @@ class TrainingVisualizer:
         label = "GT" if is_gt else "生成"
         print(f"   {label}对象数: {num_active}")
 
+    def _visualize_object_labels(self, frame_idx: int, objects: np.ndarray, is_gt: bool):
+        """在物体上显示信息标签"""
+        # 获取原始字典数据以访问inlier_ratio等
+        if is_gt and self.targets_npz is not None and 'frames' in self.targets_npz:
+            frames = self.targets_npz['frames']
+            if frame_idx >= len(frames):
+                return
+
+            frame_data = frames[frame_idx]
+            if isinstance(frame_data, np.ndarray):
+                frame_data = frame_data.item()
+
+            if 'superquadrics' not in frame_data:
+                return
+
+            superquadrics = frame_data['superquadrics']
+
+            for obj_idx, sq in enumerate(superquadrics):
+                if not sq['exists']:
+                    continue
+
+                # 获取物体位置（用于放置标签）
+                translation = sq['translation']
+                scale = sq['scale']
+
+                # 标签位置：物体中心上方
+                label_position = (
+                    float(translation[0]),
+                    float(translation[1]) + float(scale[1]) * 1.5,  # 在物体上方
+                    float(translation[2])
+                )
+
+                # 构建信息文本
+                inlier_ratio = sq.get('inlier_ratio', 0.0)
+                shape = sq.get('shape', [0, 0])
+
+                info_text = (
+                    f"ID: {obj_idx}\n"
+                    f"Density: {inlier_ratio:.3f}\n"
+                    f"Shape: ε1={shape[0]:.2f}, ε2={shape[1]:.2f}\n"
+                    f"Size: {scale[0]:.2f}×{scale[1]:.2f}×{scale[2]:.2f}"
+                )
+
+                # 添加文本标签
+                # 使用时间戳确保名称唯一，避免冲突
+                label_name = f"/object_label_f{frame_idx}_o{obj_idx}"
+                try:
+                    label_handle = self.server.scene.add_label(
+                        label_name,
+                        text=info_text,
+                        position=label_position
+                    )
+                    self.object_label_handles.append(label_handle)
+                except Exception as e:
+                    print(f"⚠️ 创建标签失败: {e}")
+
     def _visualize_pointcloud(self, frame_idx: int, scene_center: Optional[np.ndarray] = None, scene_scale: Optional[float] = None):
         """可视化点云"""
         if self.current_sample_path is None:
@@ -965,22 +1097,34 @@ class TrainingVisualizer:
 
     def get_or_create_mesh(self, key: str, vertices, faces, color, opacity):
         """获取或创建mesh（对象池）"""
+        # 检查是否启用线框模式
+        wireframe_mode = self.gui_controls.get('wireframe_mode', None)
+        is_wireframe = wireframe_mode.value if wireframe_mode else False
+
+        # 线框模式：强制白色，完全不透明
+        if is_wireframe:
+            display_color = (255, 255, 255)
+            display_opacity = 1.0
+        else:
+            display_color = color
+            display_opacity = opacity
+
         if key in self.mesh_handles_pool:
             mesh = self.mesh_handles_pool[key]
             mesh.vertices = vertices
             mesh.vertex_colors = None
-            mesh.wireframe = False
-            mesh.opacity = opacity
+            mesh.wireframe = is_wireframe
+            mesh.opacity = display_opacity
             mesh.visible = True
 
             # 更新颜色
-            color_array = np.array(color, dtype=np.uint8)
+            color_array = np.array(display_color, dtype=np.uint8)
             if color_array.max() <= 1.0:
                 color_array = (color_array * 255).astype(np.uint8)
             mesh.color = tuple(color_array)
         else:
             # 创建新mesh
-            color_array = np.array(color, dtype=np.uint8)
+            color_array = np.array(display_color, dtype=np.uint8)
             if color_array.max() <= 1.0:
                 color_array = (color_array * 255).astype(np.uint8)
 
@@ -989,8 +1133,8 @@ class TrainingVisualizer:
                 vertices=vertices,
                 faces=faces,
                 color=tuple(color_array),
-                opacity=opacity,
-                wireframe=False,
+                opacity=display_opacity,
+                wireframe=is_wireframe,
                 flat_shading=False
             )
             self.mesh_handles_pool[key] = mesh
@@ -1025,6 +1169,692 @@ class TrainingVisualizer:
             self.coordinate_frame_handle.remove()
             self.coordinate_frame_handle = None
 
+        # 删除物体信息标签
+        for handle in self.object_label_handles:
+            try:
+                handle.remove()
+            except (KeyError, AttributeError):
+                # 标签可能已经被删除，忽略错误
+                pass
+        self.object_label_handles = []
+
+    def _on_capture_camera(self, event):
+        """捕获当前相机视角"""
+        clients = list(self.server.get_clients().values())
+        if not clients:
+            print("⚠️ 没有连接的客户端")
+            self.gui_controls['export_status'].value = "错误: 没有连接的客户端"
+            return
+
+        # 获取第一个客户端的相机参数
+        client = clients[0]
+        self.export_camera_pos = np.array(client.camera.position)
+        self.export_camera_wxyz = np.array(client.camera.wxyz)
+
+        print(f"📸 已捕获相机视角: pos={self.export_camera_pos}, wxyz={self.export_camera_wxyz}")
+        self.gui_controls['export_status'].value = f"已捕获视角: {self.export_camera_pos}"
+
+    def _on_export_viser(self, event):
+        """导出为viser场景文件（可交互）"""
+        if self.current_sample_path is None:
+            print("⚠️ 请先加载样本")
+            self.gui_controls['export_status'].value = "错误: 请先加载样本"
+            return
+
+        if self.original_frame_count <= 0:
+            print("⚠️ 没有帧可以导出")
+            self.gui_controls['export_status'].value = "错误: 没有帧可以导出"
+            return
+
+        # 在后台线程导出
+        threading.Thread(target=self._export_viser_thread, daemon=True).start()
+
+    def _export_viser_thread(self):
+        """导出viser场景文件（带动画）"""
+        try:
+            print(f"\n{'='*60}")
+            print(f"💾 开始导出Viser场景")
+            print(f"{'='*60}")
+
+            # 获取当前客户端的相机参数
+            clients = list(self.server.get_clients().values())
+            camera_params = None
+            if clients:
+                client = clients[0]
+                cam_pos = client.camera.position
+                cam_lookat = client.camera.look_at
+                cam_up = client.camera.up_direction
+
+                # 生成viser URL参数格式
+                camera_params = (
+                    f"&initialCameraPosition={cam_pos[0]:.3f},{cam_pos[1]:.3f},{cam_pos[2]:.3f}"
+                    f"&initialCameraLookAt={cam_lookat[0]:.3f},{cam_lookat[1]:.3f},{cam_lookat[2]:.3f}"
+                    f"&initialCameraUp={cam_up[0]:.3f},{cam_up[1]:.3f},{cam_up[2]:.3f}"
+                )
+                print(f"   📸 记录相机视角:")
+                print(f"      位置: {cam_pos}")
+                print(f"      朝向: {cam_lookat}")
+                print(f"      向上: {cam_up}")
+
+            # 获取FPS
+            fps = int(self.gui_controls['fps_slider'].value)
+
+            # 创建输出目录
+            output_dir = self.core_space_dir / "exports"
+            output_dir.mkdir(exist_ok=True)
+
+            # 生成文件名
+            selected_output = self.gui_controls['output_selector'].value
+            sample_idx = int(self.gui_controls['sample_slider'].value)
+            step_info = "unknown"
+            if "step" in selected_output:
+                try:
+                    step_part = selected_output.split("_step")[1].split("_")[0]
+                    step_info = f"step{step_part}"
+                except:
+                    pass
+
+            timestamp = time.strftime("%Y%m%d_%H%M%S")
+            experiment_name = selected_output.split("_")[0]
+            output_file = output_dir / f"{experiment_name}_{step_info}_sample{sample_idx}_{timestamp}.viser"
+
+            print(f"   输出文件: {output_file}")
+            print(f"   帧数: {self.original_frame_count}")
+            print(f"   FPS: {fps}")
+
+            # 获取场景序列化器
+            serializer = self.server.get_scene_serializer()
+
+            # 记录初始状态（第一帧）
+            self.visualize_frame(0)
+            serializer.insert_sleep(1.0 / fps)
+
+            # 逐帧更新并记录
+            for frame_idx in range(1, self.original_frame_count):
+                self.export_progress = int((frame_idx + 1) / self.original_frame_count * 100)
+                self.gui_controls['export_status'].value = f"导出中... {self.export_progress}%"
+
+                # 更新场景（会自动更新viser场景）
+                self.visualize_frame(frame_idx)
+
+                # 添加帧延迟
+                serializer.insert_sleep(1.0 / fps)
+
+                print(f"   记录帧 {frame_idx+1}/{self.original_frame_count}")
+
+            # 序列化并保存
+            data = serializer.serialize()
+            output_file.write_bytes(data)
+
+            print(f"✅ 场景导出完成: {output_file}")
+            print(f"   文件大小: {len(data) / 1024 / 1024:.2f} MB")
+            print(f"\n📖 查看方式:")
+            print(f"   1. 安装viser客户端: viser-build-client --output-dir viser-client/")
+            print(f"   2. 启动HTTP服务器: python -m http.server 8000")
+
+            # 生成完整URL（带相机参数）
+            base_url = f"http://localhost:8000/viser-client/?playbackPath=http://localhost:8000/exports/{output_file.name}"
+            if camera_params:
+                full_url = base_url + camera_params
+                print(f"   3. 打开浏览器（带相机视角）:")
+                print(f"      {full_url}")
+            else:
+                print(f"   3. 打开浏览器:")
+                print(f"      {base_url}")
+
+            relative_path = output_file.relative_to(self.core_space_dir)
+            self.gui_controls['export_status'].value = f"完成! {relative_path}"
+
+            # 提供下载
+            clients = list(self.server.get_clients().values())
+            if clients:
+                clients[0].send_file_download(output_file.name, data)
+                print(f"   💾 已发送下载到浏览器")
+
+        except Exception as e:
+            print(f"❌ 导出失败: {e}")
+            import traceback
+            traceback.print_exc()
+            self.gui_controls['export_status'].value = f"错误: {str(e)}"
+
+    def _on_export_video(self, event):
+        """导出视频"""
+        if self.is_exporting:
+            print("⚠️ 正在导出中，请等待...")
+            return
+
+        if self.current_sample_path is None:
+            print("⚠️ 请先加载样本")
+            self.gui_controls['export_status'].value = "错误: 请先加载样本"
+            return
+
+        if self.original_frame_count <= 0:
+            print("⚠️ 没有帧可以导出")
+            self.gui_controls['export_status'].value = "错误: 没有帧可以导出"
+            return
+
+        # 检查是否有连接的客户端
+        clients = list(self.server.get_clients().values())
+        if not clients:
+            print("⚠️ 没有连接的客户端")
+            self.gui_controls['export_status'].value = "错误: 请先在浏览器中打开viser界面"
+            return
+
+        # 每次导出都获取最新的相机视角（重要！）
+        # 无论之前是否捕获过，都使用当前最新的视角
+        client = clients[0]
+        self.export_camera_pos = np.array(client.camera.position)
+        self.export_camera_wxyz = np.array(client.camera.wxyz)
+        print(f"📸 使用当前视角: pos={self.export_camera_pos}, wxyz={self.export_camera_wxyz}")
+
+        # 在后台线程导出视频
+        threading.Thread(target=self._export_video_thread_screenshot, daemon=True).start()
+
+    def _export_video_thread(self):
+        """视频导出线程"""
+        try:
+            self.is_exporting = True
+            self.gui_controls['export_status'].value = "正在导出..."
+
+            # 确保场景归一化参数已设置（通过可视化当前帧来初始化）
+            if not hasattr(self, 'scene_center') or self.scene_center is None:
+                print("   初始化场景参数...")
+                self.visualize_frame(self.current_frame)
+
+            # 获取参数
+            fps = int(self.gui_controls['fps_slider'].value)
+            resolution = int(self.gui_controls['export_resolution'].value)
+
+            # 创建输出目录 - 放在core_space根目录下
+            output_dir = self.core_space_dir / "exports"
+            output_dir.mkdir(exist_ok=True)
+
+            # 提取实验信息
+            selected_output = self.gui_controls['output_selector'].value
+            sample_idx = int(self.gui_controls['sample_slider'].value)
+
+            # 从输出名称提取步数 (例如: 20251205_184253_step5_text2wave -> step5)
+            step_info = "unknown"
+            if "step" in selected_output:
+                try:
+                    step_part = selected_output.split("_step")[1].split("_")[0]
+                    step_info = f"step{step_part}"
+                except:
+                    pass
+
+            # 生成输出文件名: {实验名}_{step}_sample{idx}_{timestamp}.mp4
+            timestamp = time.strftime("%Y%m%d_%H%M%S")
+            experiment_name = selected_output.split("_")[0]  # 取日期部分作为实验名
+            output_file = output_dir / f"{experiment_name}_{step_info}_sample{sample_idx}_{timestamp}.mp4"
+
+            print(f"\n{'='*60}")
+            print(f"🎬 开始导出视频")
+            print(f"{'='*60}")
+            print(f"   实验: {selected_output}")
+            print(f"   样本: {sample_idx}")
+            print(f"   输出文件: {output_file}")
+            print(f"   帧数: {self.original_frame_count}")
+            print(f"   FPS: {fps}")
+            print(f"   分辨率: {resolution}x{resolution}")
+            print(f"   相机位置: {self.export_camera_pos}")
+            print(f"   相机旋转: {self.export_camera_wxyz}")
+
+            # 尝试使用imageio（更好的兼容性），如果不可用则使用OpenCV
+            try:
+                import imageio
+                use_imageio = True
+                print("   使用 imageio 进行视频编码（H.264）")
+            except ImportError:
+                use_imageio = False
+                print("   使用 OpenCV 进行视频编码")
+
+            if use_imageio:
+                # 使用imageio-ffmpeg，生成高兼容性的H.264视频
+                # 注意：必须指定format='FFMPEG'来确保使用FFmpeg插件
+                writer = imageio.get_writer(
+                    str(output_file),
+                    format='FFMPEG',
+                    mode='I',
+                    fps=fps,
+                    codec='libx264',
+                    pixelformat='yuv420p',  # 确保兼容性
+                    output_params=['-crf', '18']  # H.264质量参数，18是高质量
+                )
+
+                # 渲染每一帧
+                for frame_idx in range(self.original_frame_count):
+                    self.export_progress = int((frame_idx + 1) / self.original_frame_count * 100)
+                    self.gui_controls['export_status'].value = f"导出中... {self.export_progress}%"
+
+                    # 渲染帧
+                    frame_image = self._render_frame_offline(
+                        frame_idx,
+                        resolution=resolution,
+                        camera_pos=self.export_camera_pos,
+                        camera_wxyz=self.export_camera_wxyz
+                    )
+
+                    # 写入视频（imageio需要RGB格式）
+                    if frame_image is not None:
+                        writer.append_data(frame_image)
+
+                    print(f"   渲染帧 {frame_idx+1}/{self.original_frame_count}")
+
+                writer.close()
+
+            else:
+                # 使用OpenCV，尝试更兼容的编码器
+                # 尝试顺序: H264 -> avc1 -> X264 -> mp4v
+                codecs_to_try = [
+                    ('H264', 'H.264'),
+                    ('avc1', 'H.264 (AVC1)'),
+                    ('X264', 'X264'),
+                    ('mp4v', 'MPEG-4')
+                ]
+
+                writer = None
+                used_codec = None
+
+                for codec_fourcc, codec_name in codecs_to_try:
+                    try:
+                        fourcc = cv2.VideoWriter_fourcc(*codec_fourcc)
+                        test_writer = cv2.VideoWriter(
+                            str(output_file),
+                            fourcc,
+                            fps,
+                            (resolution, resolution)
+                        )
+                        if test_writer.isOpened():
+                            writer = test_writer
+                            used_codec = codec_name
+                            print(f"   使用编码器: {codec_name}")
+                            break
+                        else:
+                            test_writer.release()
+                    except:
+                        continue
+
+                if writer is None:
+                    raise RuntimeError("无法初始化视频编码器")
+
+                # 渲染每一帧
+                for frame_idx in range(self.original_frame_count):
+                    self.export_progress = int((frame_idx + 1) / self.original_frame_count * 100)
+                    self.gui_controls['export_status'].value = f"导出中... {self.export_progress}%"
+
+                    # 渲染帧
+                    frame_image = self._render_frame_offline(
+                        frame_idx,
+                        resolution=resolution,
+                        camera_pos=self.export_camera_pos,
+                        camera_wxyz=self.export_camera_wxyz
+                    )
+
+                    # 写入视频（OpenCV需要BGR格式）
+                    if frame_image is not None:
+                        writer.write(cv2.cvtColor(frame_image, cv2.COLOR_RGB2BGR))
+
+                    print(f"   渲染帧 {frame_idx+1}/{self.original_frame_count}")
+
+                writer.release()
+
+            print(f"✅ 视频导出完成: {output_file}")
+            relative_path = output_file.relative_to(self.core_space_dir)
+            self.gui_controls['export_status'].value = f"完成! {relative_path}"
+
+        except Exception as e:
+            print(f"❌ 导出视频失败: {e}")
+            import traceback
+            traceback.print_exc()
+            self.gui_controls['export_status'].value = f"错误: {str(e)}"
+
+        finally:
+            self.is_exporting = False
+
+    def _export_video_thread_screenshot(self):
+        """视频导出线程（基于截图viser界面）"""
+        try:
+            self.is_exporting = True
+            self.gui_controls['export_status'].value = "正在导出..."
+
+            # 获取参数
+            fps = int(self.gui_controls['fps_slider'].value)
+
+            # 创建输出目录
+            output_dir = self.core_space_dir / "exports"
+            output_dir.mkdir(exist_ok=True)
+
+            # 提取实验信息并生成文件名
+            selected_output = self.gui_controls['output_selector'].value
+            sample_idx = int(self.gui_controls['sample_slider'].value)
+            step_info = "unknown"
+            if "step" in selected_output:
+                try:
+                    step_part = selected_output.split("_step")[1].split("_")[0]
+                    step_info = f"step{step_part}"
+                except:
+                    pass
+
+            timestamp = time.strftime("%Y%m%d_%H%M%S")
+            experiment_name = selected_output.split("_")[0]
+            output_file = output_dir / f"{experiment_name}_{step_info}_sample{sample_idx}_{timestamp}.mp4"
+
+            print(f"\n{'='*60}")
+            print(f"🎬 开始导出视频（截图模式）")
+            print(f"{'='*60}")
+            print(f"   实验: {selected_output}")
+            print(f"   样本: {sample_idx}")
+            print(f"   输出文件: {output_file}")
+            print(f"   帧数: {self.original_frame_count}")
+            print(f"   FPS: {fps}")
+            print(f"   方法: 直接截取Viser显示画面")
+
+            # 检查selenium
+            try:
+                from selenium import webdriver
+                from selenium.webdriver.chrome.options import Options
+                from selenium.webdriver.common.by import By
+                import time as time_module
+                use_selenium = True
+                print("   ✅ 使用 Selenium 截图")
+            except ImportError:
+                print("   ⚠️  Selenium未安装，使用逐帧渲染方法")
+                print("   提示: pip install selenium")
+                use_selenium = False
+
+            if use_selenium:
+                # 使用Selenium截图方法
+                frames = []
+
+                # 配置Chrome
+                chrome_options = Options()
+                chrome_options.add_argument('--headless')  # 无头模式
+                chrome_options.add_argument('--no-sandbox')
+                chrome_options.add_argument('--disable-dev-shm-usage')
+                chrome_options.add_argument('--window-size=1920,1080')
+
+                try:
+                    driver = webdriver.Chrome(options=chrome_options)
+                    url = f"http://localhost:{self.port}"
+                    driver.get(url)
+                    print(f"   📱 打开浏览器: {url}")
+
+                    # 等待页面加载
+                    time_module.sleep(3)
+
+                    # 逐帧截图
+                    for frame_idx in range(self.original_frame_count):
+                        self.export_progress = int((frame_idx + 1) / self.original_frame_count * 100)
+                        self.gui_controls['export_status'].value = f"截图中... {self.export_progress}%"
+
+                        # 通过GUI更新帧
+                        self.gui_controls['frame_slider'].value = frame_idx
+                        time_module.sleep(0.3)  # 等待渲染
+
+                        # 截图
+                        screenshot = driver.get_screenshot_as_png()
+                        img = cv2.imdecode(np.frombuffer(screenshot, np.uint8), cv2.IMREAD_COLOR)
+                        frames.append(img)
+
+                        print(f"   截图帧 {frame_idx+1}/{self.original_frame_count}")
+
+                    driver.quit()
+
+                    # 使用imageio写入视频
+                    try:
+                        import imageio
+                        writer = imageio.get_writer(
+                            str(output_file),
+                            format='FFMPEG',
+                            mode='I',
+                            fps=fps,
+                            codec='libx264',
+                            pixelformat='yuv420p',
+                            output_params=['-crf', '18']
+                        )
+
+                        for frame in frames:
+                            # 转换BGR到RGB
+                            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                            writer.append_data(frame_rgb)
+
+                        writer.close()
+                        print(f"✅ 视频导出完成: {output_file}")
+                        relative_path = output_file.relative_to(self.core_space_dir)
+                        self.gui_controls['export_status'].value = f"完成! {relative_path}"
+
+                    except ImportError:
+                        # 使用OpenCV写入
+                        height, width = frames[0].shape[:2]
+                        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+                        writer = cv2.VideoWriter(str(output_file), fourcc, fps, (width, height))
+                        for frame in frames:
+                            writer.write(frame)
+                        writer.release()
+                        print(f"✅ 视频导出完成: {output_file}")
+                        relative_path = output_file.relative_to(self.core_space_dir)
+                        self.gui_controls['export_status'].value = f"完成! {relative_path}"
+
+                except Exception as e:
+                    print(f"❌ Selenium截图失败: {e}")
+                    import traceback
+                    traceback.print_exc()
+                    # 回退到渲染方法
+                    use_selenium = False
+
+            if not use_selenium:
+                # 回退到原来的渲染方法
+                print("   使用PyRender离线渲染...")
+                self._export_video_thread()
+                return
+
+        except Exception as e:
+            print(f"❌ 导出视频失败: {e}")
+            import traceback
+            traceback.print_exc()
+            self.gui_controls['export_status'].value = f"错误: {str(e)}"
+
+        finally:
+            self.is_exporting = False
+
+    def _render_frame_offline(self, frame_idx: int, resolution: int,
+                              camera_pos: np.ndarray, camera_wxyz: np.ndarray) -> Optional[np.ndarray]:
+        """离线渲染一帧"""
+        # 尝试导入pyrender
+        try:
+            import pyrender
+            import trimesh
+        except ImportError:
+            if frame_idx == 0:
+                print("⚠️ pyrender未安装，使用简化渲染...")
+                print("   提示: 安装 pyrender 以获得完整3D渲染")
+                print("   pip install pyrender trimesh")
+            return self._render_frame_simple(frame_idx, resolution)
+
+        # 设置PyRender使用离屏渲染（EGL或OSMesa）
+        # 优先尝试EGL，如果失败则尝试OSMesa
+        for platform in ['egl', 'osmesa']:
+            try:
+                os.environ['PYOPENGL_PLATFORM'] = platform
+
+                # 创建场景 - 设置深蓝色背景（与viser一致）
+                scene = pyrender.Scene(
+                    ambient_light=[0.3, 0.3, 0.3],
+                    bg_color=[13/255, 13/255, 38/255, 1.0]  # 深蓝色背景
+                )
+
+                # 获取GUI参数
+                show_generated = self.gui_controls['show_generated'].value
+                show_gt = self.gui_controls['show_gt'].value
+                generated_color = np.array(self.gui_controls['generated_color'].value) / 255.0
+                gt_color = np.array(self.gui_controls['gt_color'].value) / 255.0
+                mesh_resolution = int(self.gui_controls['mesh_resolution'].value)
+
+                mesh_count = 0
+
+                # 添加生成的超二次曲面
+                # 重要：需要应用场景归一化，使物体坐标与相机坐标在同一空间
+                if show_generated:
+                    predictions = self._extract_predictions(frame_idx)
+                    if predictions is not None:
+                        for obj_idx, obj_params in enumerate(predictions):
+                            if obj_params[0] > 0.5:
+                                # 复制参数并应用场景归一化到平移部分
+                                obj_params_normalized = obj_params.copy()
+                                # 归一化平移: (translation - scene_center) * scene_scale
+                                translation = obj_params[6:9]
+                                translation_normalized = (translation - self.scene_center) * self.scene_scale
+                                obj_params_normalized[6:9] = translation_normalized
+                                # 归一化缩放: scale * scene_scale
+                                obj_params_normalized[3:6] = obj_params[3:6] * self.scene_scale
+
+                                vertices, faces = self.generate_superquadric_mesh(
+                                    obj_params_normalized, num_samples=mesh_resolution
+                                )
+
+                                if frame_idx == 0 and obj_idx == 0:
+                                    print(f"   物体原始位置: {translation}")
+                                    print(f"   物体归一化位置: {translation_normalized}")
+                                    print(f"   场景中心: {self.scene_center}, 缩放: {self.scene_scale}")
+
+                                mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
+                                # 为每个顶点设置颜色 (N, 4) - RGBA
+                                num_verts = len(vertices)
+                                vertex_colors = np.zeros((num_verts, 4), dtype=np.uint8)
+                                vertex_colors[:, :3] = (generated_color * 255).astype(np.uint8)  # RGB
+                                vertex_colors[:, 3] = 255  # 完全不透明
+                                mesh.visual.vertex_colors = vertex_colors
+
+                                # 创建PyRender材质
+                                material = pyrender.MetallicRoughnessMaterial(
+                                    baseColorFactor=list(generated_color) + [1.0],
+                                    metallicFactor=0.3,
+                                    roughnessFactor=0.7
+                                )
+                                mesh_obj = pyrender.Mesh.from_trimesh(mesh, material=material)
+                                scene.add(mesh_obj)
+                                mesh_count += 1
+
+                # 添加GT超二次曲面
+                if show_gt:
+                    targets = self._extract_targets(frame_idx)
+                    if targets is not None:
+                        for obj_idx, obj_params in enumerate(targets):
+                            if obj_params[0] > 0.5:
+                                # 复制参数并应用场景归一化
+                                obj_params_normalized = obj_params.copy()
+                                translation = obj_params[6:9]
+                                translation_normalized = (translation - self.scene_center) * self.scene_scale
+                                obj_params_normalized[6:9] = translation_normalized
+                                obj_params_normalized[3:6] = obj_params[3:6] * self.scene_scale
+
+                                vertices, faces = self.generate_superquadric_mesh(
+                                    obj_params_normalized, num_samples=mesh_resolution
+                                )
+                                mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
+                                # 为每个顶点设置颜色 (N, 4) - RGBA
+                                num_verts = len(vertices)
+                                vertex_colors = np.zeros((num_verts, 4), dtype=np.uint8)
+                                vertex_colors[:, :3] = (gt_color * 255).astype(np.uint8)  # RGB
+                                vertex_colors[:, 3] = 255  # 完全不透明
+                                mesh.visual.vertex_colors = vertex_colors
+
+                                # 创建PyRender材质
+                                material = pyrender.MetallicRoughnessMaterial(
+                                    baseColorFactor=list(gt_color) + [0.5],
+                                    metallicFactor=0.3,
+                                    roughnessFactor=0.7
+                                )
+                                mesh_obj = pyrender.Mesh.from_trimesh(mesh, material=material)
+                                scene.add(mesh_obj)
+                                mesh_count += 1
+
+                if frame_idx == 0:
+                    print(f"   场景中添加了 {mesh_count} 个mesh")
+
+                # 设置相机
+                # Viser使用的是wxyz四元数，需要转换为PyRender的变换矩阵
+                from scipy.spatial.transform import Rotation as R
+
+                # wxyz -> xyzw for scipy
+                rot = R.from_quat([camera_wxyz[1], camera_wxyz[2], camera_wxyz[3], camera_wxyz[0]])
+                rot_matrix = rot.as_matrix()
+
+                # PyRender使用OpenGL坐标系
+                # 构建相机变换矩阵
+                camera_pose = np.eye(4)
+                camera_pose[:3, :3] = rot_matrix
+                camera_pose[:3, 3] = camera_pos
+
+                if frame_idx == 0:
+                    print(f"   相机位置: {camera_pos}")
+                    print(f"   相机旋转矩阵:\n{rot_matrix}")
+
+                # 创建透视相机
+                camera = pyrender.PerspectiveCamera(yfov=np.pi / 3.0, aspectRatio=1.0)
+                scene.add(camera, pose=camera_pose)
+
+                # 添加多个光源以确保场景被充分照亮
+                # 主光源跟随相机
+                light1 = pyrender.DirectionalLight(color=[1.0, 1.0, 1.0], intensity=2.0)
+                scene.add(light1, pose=camera_pose)
+
+                # 额外的环境光源
+                light2 = pyrender.DirectionalLight(color=[1.0, 1.0, 1.0], intensity=1.0)
+                light_pose = np.eye(4)
+                light_pose[:3, 3] = [10, 10, 10]
+                scene.add(light2, pose=light_pose)
+
+                # 渲染
+                renderer = pyrender.OffscreenRenderer(resolution, resolution)
+                color, depth = renderer.render(scene)
+                renderer.delete()
+
+                # 首次成功时打印使用的平台和渲染统计
+                if frame_idx == 0:
+                    print(f"   ✅ 使用 {platform.upper()} 进行离线渲染")
+                    print(f"   渲染输出范围: [{color.min()}, {color.max()}]")
+                    print(f"   深度范围: [{depth.min()}, {depth.max()}]")
+
+                return color
+
+            except Exception as e:
+                if platform == 'osmesa':
+                    # 两种方式都失败了
+                    if frame_idx == 0:
+                        print(f"❌ PyRender渲染失败 (EGL和OSMesa都不可用): {e}")
+                        print("   使用简化渲染模式...")
+                    return self._render_frame_simple(frame_idx, resolution)
+                # EGL失败，继续尝试OSMesa
+                continue
+
+        # 不应该到达这里，但以防万一
+        return self._render_frame_simple(frame_idx, resolution)
+
+    def _render_frame_simple(self, frame_idx: int, resolution: int) -> np.ndarray:
+        """简化渲染（纯色背景 + 文字提示）"""
+        # 创建空白图像
+        image = np.full((resolution, resolution, 3), [13, 13, 38], dtype=np.uint8)
+
+        # 添加文字
+        text = f"Frame {frame_idx + 1}/{self.original_frame_count}"
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        text_size = cv2.getTextSize(text, font, 1, 2)[0]
+        text_x = (resolution - text_size[0]) // 2
+        text_y = (resolution + text_size[1]) // 2
+
+        cv2.putText(image, text, (text_x, text_y), font, 1, (255, 255, 255), 2)
+
+        # 添加提示信息
+        hint = "Install pyrender for full rendering"
+        hint_size = cv2.getTextSize(hint, font, 0.5, 1)[0]
+        hint_x = (resolution - hint_size[0]) // 2
+        hint_y = text_y + 40
+
+        cv2.putText(image, hint, (hint_x, hint_y), font, 0.5, (150, 150, 150), 1)
+
+        return image
+
     def run(self, auto_open_browser: bool = True):
         """运行可视化器"""
         print("\n" + "="*60)