Update app.py

app.py

@@ -14,7 +14,12 @@ import os
 from pathlib import Path
 from typing import Tuple, Optional
 from urllib.parse import urljoin
+import subprocess
+import shutil
+
+
 # ------------------ 下载数据 ------------------
+DOWNLOAD_DIR = tempfile.mkdtemp()
 
 class RemoteDatasetLoader:
     """从 Hugging Face Hub 远程加载数据集的类"""
@@ -96,21 +101,130 @@ class RemoteDatasetLoader:
         return video_paths, df
 
 
+# ------------------ 视频重编码函数 ------------------
+def check_ffmpeg_available():
+    """检查ffmpeg是否可用"""
+    try:
+        result = subprocess.run(['ffmpeg', '-version'], 
+                              capture_output=True, text=True, timeout=5)
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return False
+
+def get_video_codec_info(video_path):
+    """获取视频编码信息"""
+    try:
+        result = subprocess.run([
+            'ffprobe', '-v', 'quiet', '-print_format', 'json', 
+            '-show_streams', video_path
+        ], capture_output=True, text=True, timeout=10)
+        
+        if result.returncode == 0:
+            info = json.loads(result.stdout)
+            for stream in info.get('streams', []):
+                if stream.get('codec_type') == 'video':
+                    return stream.get('codec_name', 'unknown')
+    except Exception as e:
+        print(f"获取视频编码信息失败: {e}")
+    
+    return 'unknown'
+
+def reencode_video_to_h264(input_path, output_path=None, quality='medium'):
+    """将视频重编码为H.264格式"""
+    if output_path is None:
+        base_name = os.path.splitext(input_path)[0]
+        output_path = f"{base_name}_h264.mp4"
+    
+    # 根据质量选择参数
+    quality_params = {
+        'fast': ['-preset', 'ultrafast', '-crf', '28'],
+        'medium': ['-preset', 'medium', '-crf', '23'],
+        'high': ['-preset', 'slow', '-crf', '18']
+    }
+    
+    params = quality_params.get(quality, quality_params['medium'])
+    
+    try:
+        cmd = [
+            'ffmpeg', '-i', input_path,
+            '-c:v', 'libx264',  # 使用H.264编码器
+            '-c:a', 'aac',      # 音频编码器
+            '-movflags', '+faststart',  # 优化网络播放
+            '-y',  # 覆盖输出文件
+        ] + params + [output_path]
+        
+        print(f"重编码视频: {input_path} -> {output_path}")
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
+        
+        if result.returncode == 0:
+            print(f"重编码成功: {output_path}")
+            return output_path
+        else:
+            print(f"重编码失败: {result.stderr}")
+            return input_path
+            
+    except subprocess.TimeoutExpired:
+        print("重编码超时")
+        return input_path
+    except Exception as e:
+        print(f"重编码异常: {e}")
+        return input_path
+
+def process_video_for_compatibility(video_path):
+    """处理视频以确保兼容性"""
+    if not os.path.exists(video_path):
+        print(f"视频文件不存在: {video_path}")
+        return video_path
+    
+    # 检查ffmpeg是否可用
+    if not check_ffmpeg_available():
+        print("ffmpeg不可用，跳过重编码")
+        return video_path
+    
+    # 获取视频编码信息
+    codec = get_video_codec_info(video_path)
+    print(f"视频编码格式: {codec}")
+    
+    # 如果是AV1或其他不兼容的编码，重编码为H.264
+    if codec in ['av01', 'av1', 'vp9', 'vp8'] or codec == 'unknown':
+        print(f"检测到不兼容的编码格式 ({codec})，开始重编码...")
+        reencoded_path = reencode_video_to_h264(video_path, quality='fast')
+        
+        # 检查重编码后的文件是否存在且大小合理
+        if os.path.exists(reencoded_path) and os.path.getsize(reencoded_path) > 1024:
+            return reencoded_path
+        else:
+            print("重编码失败，使用原始文件")
+            return video_path
+    else:
+        print(f"视频编码 ({codec}) 兼容，无需重编码")
+        return video_path
+
+
 def load_remote_dataset(repo_id: str,
                         episode_id: int = 0,
                         video_keys: Optional[list] = None,
                         download_dir: Optional[str] = None) -> Tuple[list, pd.DataFrame]:
     loader = RemoteDatasetLoader(repo_id)
-    return loader.load_episode_data(episode_id, video_keys, download_dir)
+    video_paths, df = loader.load_episode_data(episode_id, video_keys, download_dir)
+    
+    # 处理视频兼容性
+    processed_video_paths = []
+    for video_path in video_paths:
+        processed_path = process_video_for_compatibility(video_path)
+        processed_video_paths.append(processed_path)
+    
+    return processed_video_paths, df
 
 
-video_paths, data_df = load_remote_dataset(
-            repo_id="zijian2022/sortingtest",
-            episode_id=0,
-            download_dir="./downloaded_videos"
-        )
 # ------------------ 加载数据 ------------------
-#df = pd.read_parquet("./data/clean_data/uni_boxing_object_vfm/data/chunk-000/episode_000000.parquet")
+print("正在加载数据集...")
+video_paths, data_df = load_remote_dataset(
+    repo_id="zijian2022/sortingtest",
+    episode_id=0,
+    download_dir="./downloaded_videos"
+)
+
 df = data_df
 columns = ["shoulder_pan", "shoulder_pitch", "elbow", "wrist_pitch", "wrist_roll", "gripper"]
 timestamps = df["timestamp"].values
@@ -119,10 +233,12 @@ time_for_plot = timestamps[1:]
 action_df = pd.DataFrame(df["action"].tolist(), columns=columns)
 
 # ------------------ 视频路径 ------------------
-#video_path_1 = "./data/clean_data/uni_boxing_object_vfm/videos/chunk-000/observation.images.laptop/episode_000000.mp4"
-#video_path_2 = "./data/clean_data/uni_boxing_object_vfm/videos/chunk-000/observation.images.phone/episode_000000.mp4"
 video_path_1 = video_paths[0]
 video_path_2 = video_paths[1] 
+
+print(f"视频路径1: {video_path_1}")
+print(f"视频路径2: {video_path_2}")
+
 # ------------------ Dash 初始化 ------------------
 app = dash.Dash(__name__)
 server = app.server
@@ -132,20 +248,43 @@ all_shadows = {}  # 存储所有关节的阴影信息
 
 # ------------------ 视频帧提取函数 ------------------
 def get_video_frame(video_path, time_in_seconds):
-    cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened():
-        print(f"❌ 无法打开视频: {video_path}")
-        return None
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    frame_num = int(time_in_seconds * fps)
-    cap.set(cv2.CAP_PROP_POS_FRAMES, frame_num)
-    success, frame = cap.read()
-    cap.release()
-    if success:
-        _, buffer = cv2.imencode('.jpg', frame)
-        encoded = base64.b64encode(buffer).decode('utf-8')
-        return f"data:image/jpeg;base64,{encoded}"
-    else:
+    """从视频中提取指定时间的帧"""
+    try:
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            print(f"❌ 无法打开视频: {video_path}")
+            return None
+        
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        if fps <= 0:
+            print(f"❌ 无法获取视频帧率: {video_path}")
+            cap.release()
+            return None
+        
+        frame_num = int(time_in_seconds * fps)
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_num)
+        success, frame = cap.read()
+        cap.release()
+        
+        if success and frame is not None:
+            # 调整图像大小以减少数据传输
+            height, width = frame.shape[:2]
+            if width > 640:  # 如果宽度大于640，则缩放
+                new_width = 640
+                new_height = int(height * (new_width / width))
+                frame = cv2.resize(frame, (new_width, new_height))
+            
+            # 编码为JPEG
+            encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 85]  # 85%质量
+            _, buffer = cv2.imencode('.jpg', frame, encode_param)
+            encoded = base64.b64encode(buffer).decode('utf-8')
+            return f"data:image/jpeg;base64,{encoded}"
+        else:
+            print(f"❌ 无法读取帧: {video_path}, 时间: {time_in_seconds}s")
+            return None
+            
+    except Exception as e:
+        print(f"❌ 提取视频帧异常: {e}")
         return None
 
 def find_intervals(mask):
@@ -233,6 +372,7 @@ def find_shadows_in_range(shadows, start_time, end_time):
     return shadows_in_range
 
 # 预计算所有关节的阴影信息
+print("正在预计算阴影信息...")
 for joint in columns:
     all_shadows[joint] = get_shadow_info(joint)
 
@@ -326,12 +466,11 @@ for i, joint in enumerate(columns):
         ], style={"width": "38%", "display": "inline-block", "paddingLeft": "2%"})
     ], style={"marginBottom": "15px"}))
 
-# 添加定时器和存储组件
-rows.append(dcc.Interval(id="video-playback-interval", interval=300, n_intervals=0))
-rows.append(dcc.Store(id="hover-state-store", data={"active": False, "last_update": 0}))
-
 # 设置 layout
-app.layout = html.Div(rows)
+app.layout = html.Div([
+    html.H1("机器人数据可视化 - 视频兼容性优化", style={"textAlign": "center", "marginBottom": "20px"}),
+    html.Div(rows)
+])
 
 # ------------------ 回调：监听 hoverData 并更新阴影高亮 ------------------
 @app.callback(
@@ -404,20 +543,13 @@ def update_shadow_highlighting(*args):
         return [no_update] * 6
 
 # ------------------ 回调：监听 hoverData 更新视频帧 ------------------
-video_duration = timestamps[-1] - timestamps[0]
-
 @app.callback(
     [Output(f"video1-{i}", "src") for i in range(6)] + 
-    [Output(f"video2-{i}", "src") for i in range(6)] + 
-    [Output("hover-state-store", "data")],
-    [Input(f"graph-{i}", "hoverData") for i in range(6)] + 
-    [Input("video-playback-interval", "n_intervals")],
-    [State("hover-state-store", "data")]
+    [Output(f"video2-{i}", "src") for i in range(6)],
+    [Input(f"graph-{i}", "hoverData") for i in range(6)]
 )
 def update_video_frames(*args):
-    hover_datas = args[:-2]
-    interval_count = args[-2]
-    hover_state = args[-1]
+    hover_datas = args
     
     # 获取触发回调的上下文
     ctx = dash.callback_context
@@ -439,43 +571,19 @@ def update_video_frames(*args):
                         frame1 = get_video_frame(video_path_1, hover_time)
                         frame2 = get_video_frame(video_path_2, hover_time)
                         
-                        # 更新hover状态为活跃
-                        new_hover_state = {"active": True, "last_update": interval_count}
-                        
                         # 如果成功获取帧，返回所有视频的帧
                         if frame1 and frame2:
-                            return [frame1]*6 + [frame2]*6 + [new_hover_state]
+                            return [frame1]*6 + [frame2]*6
                     except Exception as e:
                         print(f"处理hover数据异常: {e}")
-            
-            # 如果是interval触发的
-            if 'video-playback-interval' in trigger_id:
-                # 检查hover状态是否过期（超过3个interval周期没有更新）
-                hover_expired = (interval_count - hover_state.get("last_update", 0)) > 3
-                
-                if not hover_state.get("active", False) or hover_expired:
-                    # 没有hover或hover已过期时才自动播放
-                    t = timestamps[0] + (interval_count * 0.3) % video_duration
-                    frame1 = get_video_frame(video_path_1, t)
-                    frame2 = get_video_frame(video_path_2, t)
-                    
-                    # 更新hover状态为非活跃
-                    new_hover_state = {"active": False, "last_update": interval_count}
-                    
-                    if frame1 and frame2:
-                        return [frame1]*6 + [frame2]*6 + [new_hover_state]
-                    else:
-                        return [no_update]*12 + [new_hover_state]
-                else:
-                    # hover仍然活跃时，暂停自动播放
-                    return [no_update]*12 + [hover_state]
-
-        return [no_update]*12 + [hover_state]
+
+        return [no_update]*12
 
     except Exception as e:
         print(f"update_video_frames回调函数异常: {e}")
-        return [no_update]*12 + [hover_state]
+        return [no_update]*12
 
 # ------------------ 启动应用 ------------------
 if __name__ == "__main__":
-    app.run(debug=True)
+    print("应用启动中...")
+    app.run(debug=True, host='0.0.0.0', port=8050)