Revert to working minimal version

app.py

@@ -1,424 +1,16 @@
 """
-Dynamic Intelligence - Human Demo Visualizer
-Egocentric hand tracking dataset visualizer for robot training data
+Minimal test version
 """
-
 import gradio as gr
-import json
-import html
-import numpy as np
 from pathlib import Path
-import plotly.graph_objects as go
-import plotly.io as pio
-from typing import Dict, List
 
-# Load pipeline data
 DATA_DIR = Path(__file__).parent / "data"
-
-def load_json_safe(path):
-    try:
-        with open(path, 'r') as f:
-            return json.load(f)
-    except Exception as e:
-        print(f"Error loading {path}: {e}")
-        return {}
-
-# Load data at startup
-print("Loading data...")
-metadata = load_json_safe(DATA_DIR / "metadata.json")
-end_effector = load_json_safe(DATA_DIR / "end_effector.json")
-actions = load_json_safe(DATA_DIR / "actions.json")
-hands_2d = load_json_safe(DATA_DIR / "hands_2d.json")
-print(f"Loaded: metadata={len(metadata)}, ee={len(end_effector)}, actions={len(actions)}, hands={len(hands_2d)}")
-
-# Stats
-total_frames = max(1, len(metadata.get('poses', [])))
-fps = metadata.get('fps', 60)
-hand_detection_rate = len(hands_2d) / total_frames * 100
-
-# Count poses safely
-left_poses = 0
-right_poses = 0
-for frame_data in end_effector.values():
-    if frame_data and isinstance(frame_data, dict):
-        if frame_data.get('left_hand'):
-            left_poses += 1
-        if frame_data.get('right_hand'):
-            right_poses += 1
-
-print(f"Stats: frames={total_frames}, left={left_poses}, right={right_poses}")
-
-# Video path
 video_path = DATA_DIR / "video.mp4"
 
-# Prepare time-series data
-def prepare_data():
-    """Prepare time-series data for plots."""
-    times = []
-    left_pos = {'x': [], 'y': [], 'z': []}
-    left_rot = {'yaw': [], 'pitch': [], 'roll': []}
-    right_pos = {'x': [], 'y': [], 'z': []}
-    right_rot = {'yaw': [], 'pitch': [], 'roll': []}
-    
-    if not end_effector:
-        return {
-            'times': times,
-            'left_pos': left_pos,
-            'left_rot': left_rot,
-            'right_pos': right_pos,
-            'right_rot': right_rot
-        }
-    
-    try:
-        frame_keys = sorted([int(k) for k in end_effector.keys() if str(k).isdigit()])
-    except:
-        frame_keys = []
-    
-    for frame_idx in frame_keys:
-        frame_key = str(frame_idx)
-        t = frame_idx / fps
-        times.append(t)
-        
-        ee_data = end_effector.get(frame_key, {}) or {}
-        
-        # Left hand
-        left_hand_data = ee_data.get('left_hand')
-        if left_hand_data and isinstance(left_hand_data, dict):
-            pose = left_hand_data.get('pose_6dof')
-            if pose and len(pose) >= 6:
-                left_pos['x'].append(pose[0] * 100)  # m to cm
-                left_pos['y'].append(pose[1] * 100)
-                left_pos['z'].append(pose[2] * 100)
-                left_rot['roll'].append(pose[3] * 57.3)  # rad to deg
-                left_rot['pitch'].append(pose[4] * 57.3)
-                left_rot['yaw'].append(pose[5] * 57.3)
-            else:
-                for k in left_pos: left_pos[k].append(None)
-                for k in left_rot: left_rot[k].append(None)
-        else:
-            for k in left_pos: left_pos[k].append(None)
-            for k in left_rot: left_rot[k].append(None)
-        
-        # Right hand
-        right_hand_data = ee_data.get('right_hand')
-        if right_hand_data and isinstance(right_hand_data, dict):
-            pose = right_hand_data.get('pose_6dof')
-            if pose and len(pose) >= 6:
-                right_pos['x'].append(pose[0] * 100)
-                right_pos['y'].append(pose[1] * 100)
-                right_pos['z'].append(pose[2] * 100)
-                right_rot['roll'].append(pose[3] * 57.3)
-                right_rot['pitch'].append(pose[4] * 57.3)
-                right_rot['yaw'].append(pose[5] * 57.3)
-            else:
-                for k in right_pos: right_pos[k].append(None)
-                for k in right_rot: right_rot[k].append(None)
-        else:
-            for k in right_pos: right_pos[k].append(None)
-            for k in right_rot: right_rot[k].append(None)
-    
-    return {
-        'times': times,
-        'left_pos': left_pos,
-        'left_rot': left_rot,
-        'right_pos': right_pos,
-        'right_rot': right_rot
-    }
-
-# Lazy load plot data
-plot_data = None
-
-def get_plot_data():
-    """Lazy load plot data."""
-    global plot_data
-    if plot_data is None:
-        try:
-            plot_data = prepare_data()
-        except Exception as e:
-            print(f"Error preparing plot data: {e}")
-            plot_data = {
-                'times': [],
-                'left_pos': {'x': [], 'y': [], 'z': []},
-                'left_rot': {'yaw': [], 'pitch': [], 'roll': []},
-                'right_pos': {'x': [], 'y': [], 'z': []},
-                'right_rot': {'yaw': [], 'pitch': [], 'roll': []}
-            }
-    return plot_data
-
-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"],
-]
-
-PLOT_ORDER = [metric for row in PLOT_GRID for metric in row]
-
-CUSTOM_CSS = """
-:root, .gradio-container, body {
-    background-color: #050a18 !important;
-    color: #f8fafc !important;
-    font-family: 'Inter', 'Segoe UI', system-ui, sans-serif;
-}
-.side-panel {
-    background: #0f172a;
-    padding: 20px;
-    border-radius: 18px;
-    border: 1px solid #1f2b47;
-    min-height: 100%;
-}
-.stats-card ul {
-    list-style: none;
-    padding: 0;
-    margin: 0;
-    font-size: 0.92rem;
-}
-.stats-card li {
-    margin-bottom: 10px;
-    color: #e2e8f0;
-}
-.stats-card span {
-    display: inline-block;
-    margin-right: 6px;
-    color: #7dd3fc;
-}
-.main-panel {
-    padding-top: 8px;
-}
-.instruction-card {
-    background: #0f172a;
-    padding: 18px 20px;
-    border-radius: 18px;
-    border: 1px solid #1f2b47;
-}
-.instruction-label {
-    font-size: 0.75rem;
-    letter-spacing: 0.12em;
-    text-transform: uppercase;
-    color: #94a3b8;
-    margin-bottom: 10px;
-}
-.instruction-text {
-    font-size: 1.1rem;
-    line-height: 1.5;
-}
-.video-card {
-    background: #0f172a;
-    border: 1px solid #1f2b47;
-    border-radius: 18px;
-    padding: 18px 20px;
-    margin-top: 18px;
-}
-.video-title {
-    font-size: 0.78rem;
-    text-transform: uppercase;
-    letter-spacing: 0.18em;
-    color: #94a3b8;
-    margin-bottom: 8px;
-}
-.video-panel video {
-    border-radius: 12px;
-    border: 1px solid #1f2b47;
-    background: #030712;
-}
-.download-button button {
-    border-radius: 999px;
-    border: 1px solid #334155;
-    background: #1e293b;
-    color: #f8fafc;
-    font-size: 0.85rem;
-    padding: 8px 24px;
-}
-.download-button button:hover {
-    border-color: #67e8f9;
-    color: #67e8f9;
-}
-.plots-wrap {
-    margin-top: 18px;
-}
-.plots-wrap .gr-row {
-    gap: 16px;
-}
-.plot-html {
-    background: #111a2c;
-    border-radius: 12px;
-    padding: 10px;
-    border: 1px solid #1f2b47;
-    min-height: 320px;
-}
-.plot-html iframe {
-    width: 100%;
-    height: 300px;
-    border: none;
-}
-"""
-
-def build_plot_fig(metric: str, hand: str = "left") -> go.Figure:
-    """Build Plotly figure for a metric."""
-    try:
-        data = get_plot_data()
-        times = data.get('times', [])
-        
-        if hand == "left":
-            if "cm" in metric:
-                key = metric.replace('_cm', '')
-                plot_values = data.get('left_pos', {}).get(key, [])
-            else:
-                key = metric.replace('_deg', '')
-                plot_values = data.get('left_rot', {}).get(key, [])
-            name = "Left Hand"
-        else:
-            if "cm" in metric:
-                key = metric.replace('_cm', '')
-                plot_values = data.get('right_pos', {}).get(key, [])
-            else:
-                key = metric.replace('_deg', '')
-                plot_values = data.get('right_rot', {}).get(key, [])
-            name = "Right Hand"
-        
-        if not times or not plot_values:
-            # Return empty plot
-            times = [0]
-            plot_values = [0]
-    except Exception as e:
-        print(f"Error in build_plot_fig: {e}")
-        times = [0]
-        plot_values = [0]
-        name = "Error"
-    
-    fig = go.Figure()
-    fig.add_trace(
-        go.Scatter(
-            x=times,
-            y=plot_values,
-            mode="lines",
-            name=name,
-            line=dict(color="#67e8f9", width=2)
-        )
-    )
-    fig.update_layout(
-        margin=dict(l=20, r=20, t=30, b=20),
-        height=250,
-        template="plotly_dark",
-        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
-        xaxis_title="Time (s)",
-        yaxis_title=METRIC_LABELS[metric],
-    )
-    fig.update_xaxes(showgrid=True, gridwidth=0.5, gridcolor="rgba(255,255,255,0.1)")
-    fig.update_yaxes(showgrid=True, gridwidth=0.5, gridcolor="rgba(255,255,255,0.1)")
-    return fig
-
-def build_plot_html(metric: str, hand: str = "left") -> str:
-    """Build Plotly HTML for a metric."""
-    fig = build_plot_fig(metric, hand)
-    return pio.to_html(fig, include_plotlyjs="cdn", full_html=False)
-
-# Build interface
-stats_html = f"""
-<div class="stats-card">
-  <ul>
-    <li><span>Number of samples/frames:</span> {total_frames:,}</li>
-    <li><span>Hand detection rate:</span> {hand_detection_rate:.1f}%</li>
-    <li><span>Left hand poses:</span> {left_poses}</li>
-    <li><span>Right hand poses:</span> {right_poses}</li>
-    <li><span>Frames per second:</span> {fps:.1f}</li>
-  </ul>
-</div>
-"""
-
-instruction_text = "LiDAR-based egocentric hand tracking for robot training data"
-
-theme = gr.themes.Soft(
-    primary_hue="cyan", secondary_hue="blue", neutral_hue="slate"
-).set(
-    body_background_fill="#0c1424",
-    body_text_color="#f8fafc",
-    block_background_fill="#111a2c",
-    block_title_text_color="#f8fafc",
-    input_background_fill="#151f33",
-    border_color_primary="#1f2b47",
-    shadow_drop="none",
-)
-
-def format_instruction_html(text: str) -> str:
-    safe_text = html.escape(text)
-    return (
-        '<div class="instruction-card">'
-        '<p class="instruction-label">Language Instruction</p>'
-        f'<p class="instruction-text">{safe_text}</p>'
-        "</div>"
-    )
-
-with gr.Blocks(theme=theme, css=CUSTOM_CSS) as demo:
-    gr.Markdown("# 🤖 Dynamic Intelligence - Human Demo Visualizer")
-    gr.Markdown(
-        "Egocentric hand tracking dataset for humanoid robot training. "
-        "Pipeline: iPhone LiDAR → MediaPipe → 6DoF End-Effector → Robot Training Data"
-    )
-
-    with gr.Row(equal_height=True):
-        with gr.Column(scale=1, min_width=260, elem_classes=["side-panel"]):
-            gr.HTML(stats_html)
-        with gr.Column(scale=2, min_width=640, elem_classes=["main-panel"]):
-            instruction_box = gr.HTML(
-                format_instruction_html(instruction_text),
-                label="Language Instruction",
-            )
-            with gr.Column(elem_classes=["video-card"]):
-                gr.HTML('<div class="video-title">RGB Video</div>')
-                video = gr.Video(
-                    height=360,
-                    value=str(video_path) if video_path.exists() else None,
-                    elem_classes=["video-panel"],
-                    show_label=False,
-                    show_download_button=False,
-                )
-                download_button = gr.DownloadButton(
-                    label="Download",
-                    value=str(video_path) if video_path.exists() else None,
-                    elem_classes=["download-button"],
-                )
-
-    try:
-        gr.Markdown("### Left Hand Trajectories", elem_classes=["plots-title"])
-        plot_outputs_left = []
-        with gr.Column(elem_classes=["plots-wrap"]):
-            for row in PLOT_GRID:
-                with gr.Row():
-                    for metric in row:
-                        try:
-                            plot_html = build_plot_html(metric, "left")
-                            plot = gr.HTML(value=plot_html, elem_classes=["plot-html"])
-                            plot_outputs_left.append(plot)
-                        except Exception as e:
-                            print(f"Error creating plot {metric} for left hand: {e}")
-                            plot = gr.HTML(value="<p>Plot unavailable</p>", elem_classes=["plot-html"])
-                            plot_outputs_left.append(plot)
-        
-        gr.Markdown("### Right Hand Trajectories", elem_classes=["plots-title"])
-        plot_outputs_right = []
-        with gr.Column(elem_classes=["plots-wrap"]):
-            for row in PLOT_GRID:
-                with gr.Row():
-                    for metric in row:
-                        try:
-                            plot_html = build_plot_html(metric, "right")
-                            plot = gr.HTML(value=plot_html, elem_classes=["plot-html"])
-                            plot_outputs_right.append(plot)
-                        except Exception as e:
-                            print(f"Error creating plot {metric} for right hand: {e}")
-                            plot = gr.HTML(value="<p>Plot unavailable</p>", elem_classes=["plot-html"])
-                            plot_outputs_right.append(plot)
-    except Exception as e:
-        print(f"Error creating plots section: {e}")
-        gr.Markdown("### Plots unavailable")
+with gr.Blocks() as demo:
+    gr.Markdown("# Test")
+    gr.Video(value=str(video_path) if video_path.exists() else None)
 
 if __name__ == "__main__":
-    demo.queue().launch(show_api=False)
+    demo.launch()
+