Revert to minimal working version

app.py

@@ -1,177 +1,16 @@
-import json
-import html
-from pathlib import Path
-from typing import Dict, List
-
+"""
+Minimal test version
+"""
 import gradio as gr
-import plotly.graph_objects as go
-import plotly.io as pio
-
-METRIC_LABELS = {
-    "x_cm": "X (cm)",
-    "y_cm": "Y (cm)",
-    "z_cm": "Z (cm)",
-    "yaw_deg": "Yaw (°)",
-    "pitch_deg": "Pitch (°)",
-    "roll_deg": "Roll (°)",
-}
-
-PLOT_GRID = [
-    ["x_cm", "y_cm", "z_cm"],
-    ["yaw_deg", "pitch_deg", "roll_deg"],
-]
-
-def get_data_dir():
-    try:
-        return Path(__file__).parent / "data"
-    except:
-        return Path("data")
-
-def load_data():
-    data_dir = get_data_dir()
-    metadata = {}
-    end_effector = {}
-    hands_2d = {}
-    
-    try:
-        metadata_path = data_dir / "metadata.json"
-        if metadata_path.exists():
-            with open(metadata_path, 'r') as f:
-                metadata = json.load(f)
-    except:
-        pass
-    
-    try:
-        end_effector_path = data_dir / "end_effector.json"
-        if end_effector_path.exists():
-            with open(end_effector_path, 'r') as f:
-                end_effector = json.load(f)
-    except:
-        pass
-    
-    try:
-        hands_2d_path = data_dir / "hands_2d.json"
-        if hands_2d_path.exists():
-            with open(hands_2d_path, 'r') as f:
-                hands_2d = json.load(f)
-    except:
-        pass
-    
-    return metadata, end_effector, hands_2d
+from pathlib import Path
 
-def build_state_dataframe(metadata: dict, end_effector: dict, hand: str = "left"):
-    fps = metadata.get('fps', 60)
-    frame_keys = sorted([int(k) for k in end_effector.keys() if str(k).isdigit()])
-    
-    timestamps = []
-    state_data = {
-        'wrist_x_cm': [],
-        'wrist_y_cm': [],
-        'wrist_z_cm': [],
-        'wrist_yaw_deg': [],
-        'wrist_pitch_deg': [],
-        'wrist_roll_deg': [],
-    }
-    
-    for frame_idx in frame_keys:
-        frame_key = str(frame_idx)
-        t = frame_idx / fps
-        timestamps.append(t)
-        
-        ee_data = end_effector.get(frame_key, {}) or {}
-        hand_data = ee_data.get(hand + "_hand")
-        
-        if hand_data and isinstance(hand_data, dict):
-            pose = hand_data.get('pose_6dof')
-            if pose and len(pose) >= 6:
-                state_data['wrist_x_cm'].append(pose[0] * 100)
-                state_data['wrist_y_cm'].append(pose[1] * 100)
-                state_data['wrist_z_cm'].append(pose[2] * 100)
-                state_data['wrist_roll_deg'].append(pose[3] * 57.3)
-                state_data['wrist_pitch_deg'].append(pose[4] * 57.3)
-                state_data['wrist_yaw_deg'].append(pose[5] * 57.3)
-            else:
-                for k in state_data:
-                    state_data[k].append(None)
-        else:
-            for k in state_data:
-                state_data[k].append(None)
-    
-    return timestamps, state_data
+DATA_DIR = Path(__file__).parent / "data"
+video_path = DATA_DIR / "video.mp4"
 
-def build_plot_html(timestamps: List[float], state_data: Dict, metric: str) -> str:
-    col_name = f"wrist_{metric}"
-    if col_name not in state_data or not timestamps:
-        return "<p>No data</p>"
-    
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(x=timestamps, y=state_data[col_name], mode="lines", name="Wrist"))
-    fig.update_layout(
-        margin=dict(l=20, r=20, t=30, b=20),
-        height=250,
-        template="plotly_dark",
-        xaxis_title="Time (s)",
-        yaxis_title=METRIC_LABELS[metric],
-    )
-    return pio.to_html(fig, include_plotlyjs="cdn", full_html=False)
+with gr.Blocks() as demo:
+    gr.Markdown("# Test")
+    gr.Video(value=str(video_path) if video_path.exists() else None)
 
-def build_interface():
-    metadata, end_effector, hands_2d = load_data()
-    
-    total_frames = len(metadata.get('poses', []))
-    fps = metadata.get('fps', 60)
-    hand_detection_rate = len(hands_2d) / max(1, total_frames) * 100 if total_frames > 0 else 0
-    left_poses = sum(1 for f in end_effector.values() if f and isinstance(f, dict) and f.get('left_hand'))
-    right_poses = sum(1 for f in end_effector.values() if f and isinstance(f, dict) and f.get('right_hand'))
-    
-    video_path = get_data_dir() / "video.mp4"
-    
-    left_timestamps, left_state = build_state_dataframe(metadata, end_effector, "left")
-    right_timestamps, right_state = build_state_dataframe(metadata, end_effector, "right")
-    
-    left_figs = {metric: build_plot_html(left_timestamps, left_state, metric) for metric in METRIC_LABELS.keys()}
-    right_figs = {metric: build_plot_html(right_timestamps, right_state, metric) for metric in METRIC_LABELS.keys()}
-    
-    stats_html = f"""
-<div style="background: #0f172a; padding: 20px; border-radius: 18px;">
-  <ul style="list-style: none; padding: 0;">
-    <li><span style="color: #7dd3fc;">Frames:</span> {total_frames:,}</li>
-    <li><span style="color: #7dd3fc;">Detection rate:</span> {hand_detection_rate:.1f}%</li>
-    <li><span style="color: #7dd3fc;">Left poses:</span> {left_poses}</li>
-    <li><span style="color: #7dd3fc;">Right poses:</span> {right_poses}</li>
-    <li><span style="color: #7dd3fc;">FPS:</span> {fps:.1f}</li>
-  </ul>
-</div>
-"""
-    
-    theme = gr.themes.Soft(primary_hue="cyan", secondary_hue="blue", neutral_hue="slate")
-    
-    with gr.Blocks(theme=theme) as demo:
-        gr.Markdown("# 🤖 Dynamic Intelligence - Human Demo Visualizer")
-        gr.Markdown("Egocentric hand tracking dataset for humanoid robot training.")
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.HTML(stats_html)
-            with gr.Column(scale=2):
-                video = gr.Video(value=str(video_path) if video_path.exists() else None, height=360)
-        
-        gr.Markdown("### Left Hand Trajectories")
-        with gr.Row():
-            for metric in ["x_cm", "y_cm", "z_cm"]:
-                gr.HTML(value=left_figs[metric])
-        with gr.Row():
-            for metric in ["yaw_deg", "pitch_deg", "roll_deg"]:
-                gr.HTML(value=left_figs[metric])
-        
-        gr.Markdown("### Right Hand Trajectories")
-        with gr.Row():
-            for metric in ["x_cm", "y_cm", "z_cm"]:
-                gr.HTML(value=right_figs[metric])
-        with gr.Row():
-            for metric in ["yaw_deg", "pitch_deg", "roll_deg"]:
-                gr.HTML(value=right_figs[metric])
-    
-    return demo
+if __name__ == "__main__":
+    demo.launch()
 
-demo = build_interface()