added overlay video

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

CLAUDE.md

@@ -0,0 +1,120 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+The Laban Movement Analysis project is a Gradio 5 custom component that performs video movement analysis using Laban Movement Analysis (LMA) principles combined with modern pose estimation models. It provides both a web UI and MCP-compatible API for AI agents.
+
+### Core Architecture
+
+- **Backend**: Custom Gradio component in `backend/gradio_labanmovementanalysis/`
+- **Frontend**: Svelte components in `frontend/` for the Gradio UI
+- **Demo**: Standalone Gradio app in `demo/` for testing and deployment  
+- **Main Entry**: `app.py` serves as the primary entry point for Hugging Face Spaces
+
+### Key Components
+
+1. **LabanMovementAnalysis**: Main Gradio component (`labanmovementanalysis.py`)
+2. **Pose Estimation**: Multi-model support (MediaPipe, MoveNet, YOLO variants) 
+3. **Notation Engine**: LMA analysis logic (`notation_engine.py`)
+4. **Visualizer**: Video annotation and overlay generation (`visualizer.py`)
+5. **Agent API**: MCP-compatible interface for AI agents (`agent_api.py`)
+6. **Video Processing**: Smart input handling including YouTube/Vimeo downloads (`video_downloader.py`)
+
+## Development Commands
+
+### Running the Application
+```bash
+# Main application (Hugging Face Spaces compatible)
+python app.py
+
+# Demo version
+cd demo && python app.py
+
+# Alternative demo with space configuration
+python demo/space.py
+```
+
+### Package Management
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Install in development mode
+pip install -e .
+
+# Build package
+python -m build
+
+# Upload to PyPI  
+python -m twine upload dist/*
+```
+
+### Frontend Development
+```bash
+cd frontend
+npm install
+npm run build
+```
+
+## Pose Estimation Models
+
+The system supports 15+ pose estimation variants:
+
+- **MediaPipe**: `mediapipe-lite`, `mediapipe-full`, `mediapipe-heavy`
+- **MoveNet**: `movenet-lightning`, `movenet-thunder` 
+- **YOLO v8**: `yolo-v8-n`, `yolo-v8-s`, `yolo-v8-m`, `yolo-v8-l`, `yolo-v8-x`
+- **YOLO v11**: `yolo-v11-n`, `yolo-v11-s`, `yolo-v11-m`, `yolo-v11-l`, `yolo-v11-x`
+
+## API Usage Patterns
+
+### Standard Processing
+```python
+from gradio_labanmovementanalysis import LabanMovementAnalysis
+
+analyzer = LabanMovementAnalysis()
+result = analyzer.process(video_path, model="mediapipe-full")
+```
+
+### Agent API (MCP Compatible)
+```python
+from gradio_labanmovementanalysis.agent_api import LabanAgentAPI
+
+api = LabanAgentAPI()
+result = await api.analyze_video(video_path, model="mediapipe-full")
+```
+
+### Enhanced Processing with Visualization
+```python
+json_result, viz_video = analyzer.process_video(
+    video_path,
+    model="mediapipe-full", 
+    enable_visualization=True,
+    include_keypoints=True
+)
+```
+
+## File Organization
+
+- **Examples**: JSON output samples in `examples/` (mediapipe.json, yolo*.json, etc.)
+- **Version Info**: `version.py` contains package metadata
+- **Configuration**: `pyproject.toml` for package building and dependencies
+- **Deployment**: Both standalone (`app.py`) and demo (`demo/`) configurations
+
+## Important Implementation Notes
+
+- The component inherits from Gradio's base `Component` class
+- Video processing supports both file uploads and URL inputs (YouTube, Vimeo, direct URLs)
+- MCP server capability is enabled via `mcp_server=True` in launch configurations
+- Error handling includes graceful fallbacks when optional features (like Agent API) are unavailable
+- The system uses temporary files for video processing and cleanup
+- JSON output includes both LMA analysis and optional raw keypoint data
+
+## Development Considerations
+
+- The codebase maintains backward compatibility between demo and main app versions
+- Component registration follows Gradio 5 patterns with proper export definitions
+- Frontend uses modern Svelte with Gradio's component system
+- Dependencies are managed through both requirements.txt and pyproject.toml
+- The system is designed for both local development and cloud deployment (HF Spaces)

README.md

@@ -1,6 +1,6 @@
 ---
 title: Laban Movement Analysis
-emoji: 🏃
+emoji: 🩰
 colorFrom: purple
 colorTo: green
 app_file: app.py
@@ -59,15 +59,10 @@ try:
         MovementDirection,
         MovementIntensity
     )
-    HAS_AGENT_API = True
-    
-    try:
-        agent_api = LabanAgentAPI()
-    except Exception as e:
-        print(f"Warning: Agent API not available: {e}")
-        agent_api = None
-except ImportError:
-    HAS_AGENT_API = False
+    agent_api = LabanAgentAPI()
+except Exception as e:
+    print(f"Warning: Agent API not available: {e}")
+    agent_api = None
 # Initialize components
 try:
     analyzer = LabanMovementAnalysis(
@@ -99,21 +94,38 @@ def process_video_enhanced(video_input, model, enable_viz, include_keypoints):
         error_result = {"error": str(e)}
         return error_result, None
 
-def process_video_standard(video, model, enable_viz, include_keypoints):
-    """Standard video processing function."""
+def process_video_standard(video : str, model : str, include_keypoints : bool) -> dict:
+    """
+    Processes a video file using the specified pose estimation model and returns movement analysis results.
+
+    Args:
+        video (str): Path to the video file to be analyzed.
+        model (str): The name of the pose estimation model to use (e.g., "mediapipe-full", "movenet-thunder", etc.).
+        include_keypoints (bool): Whether to include raw keypoint data in the output.
+
+    Returns:
+        dict:
+            - A dictionary containing the movement analysis results in JSON format, or an error message if processing fails.
+
+
+    Notes:
+        - Visualization is disabled in this standard processing function.
+        - If the input video is None, both return values will be None.
+        - If an error occurs during processing, the first return value will be a dictionary with an "error" key.
+    """
     if video is None:
-        return None, None
-    
+        return None
     try:
-        json_output, video_output = analyzer.process_video(
+        json_output = analyzer.process(
             video,
             model=model,
-            enable_visualization=enable_viz,
             include_keypoints=include_keypoints
         )
-        return json_output, video_output
-    except Exception as e:
-        return {"error": str(e)}, None
+
+        
+        return json_output
+    except (RuntimeError, ValueError, OSError) as e:
+        return {"error": str(e)}
 
 # ── 4.  Build UI ─────────────────────────────────────────────────
 def create_demo() -> gr.Blocks:
@@ -122,7 +134,7 @@ def create_demo() -> gr.Blocks:
         theme='gstaff/sketch',
         fill_width=True,
     ) as demo:
-
+        # gr.api(process_video_standard, api_name="process_video")  # <-- Remove from here
         # ── Hero banner ──
         gr.Markdown(
             """
@@ -214,10 +226,15 @@ def create_demo() -> gr.Blocks:
                 """
             )
     return demo
-  
+
+# Register API endpoint OUTSIDE the UI
+
+gr.api(process_video_standard, api_name="process_video")
+
 if __name__ == "__main__":
     demo = create_demo()
     demo.launch(server_name="0.0.0.0",
+                share=True,
                 server_port=int(os.getenv("PORT", 7860)),
                 mcp_server=True) 
 

backend/gradio_labanmovementanalysis/labanmovementanalysis.py

@@ -283,7 +283,25 @@ class LabanMovementAnalysis(Component):
         """
         return self.process_video(video_path, **kwargs)
     
+    def process(self, video_input: Union[str, os.PathLike], model: str = DEFAULT_MODEL, include_keypoints: bool = False) -> Dict[str, Any]:
+        """
+        Processes a video and returns only the JSON analysis result.
+
+        Args:
+            video_input: Path to input video, video URL, or file object
+            model: Pose estimation model to use
+            include_keypoints: Whether to include keypoints in JSON
 
+        Returns:
+            dict: Movement analysis results in JSON format
+        """
+        json_output, _ = self.process_video(
+            video_input,
+            model=model,
+            enable_visualization=False,
+            include_keypoints=include_keypoints
+        )
+        return json_output
     
     # SkateFormer methods moved to Version 2 development
     # get_skateformer_compatibility() and get_skateformer_status_report() 

backend/gradio_labanmovementanalysis/labanmovementanalysis.pyi

@@ -0,0 +1,402 @@
+"""
+Custom Gradio v5 component for video-based pose analysis with LMA-inspired metrics.
+"""
+
+import gradio as gr
+from gradio.components.base import Component
+from typing import Dict, Any, Optional, Tuple, List, Union
+import tempfile
+import os
+import numpy as np
+
+from .video_utils import extract_frames, get_video_info
+from .pose_estimation import get_pose_estimator
+from .notation_engine import analyze_pose_sequence
+from .json_generator import generate_json, format_for_display
+from .visualizer import PoseVisualizer
+from .video_downloader import SmartVideoInput
+
+# Advanced features reserved for Version 2
+# SkateFormer AI integration will be available in future release
+
+
+
+# SkateFormerCompatibility class removed for Version 1 stability
+# Will be reimplemented in Version 2 with enhanced AI features
+
+from gradio.events import Dependency
+
+class LabanMovementAnalysis(Component):
+    """
+    Gradio component for video-based pose analysis with Laban Movement Analysis metrics.
+    """
+    
+    # Component metadata
+    COMPONENT_TYPE = "composite"
+    DEFAULT_MODEL = "mediapipe"
+    
+    def __init__(self,
+                 default_model: str = DEFAULT_MODEL,
+                 enable_visualization: bool = True,
+                 include_keypoints: bool = False,
+
+                 label: Optional[str] = None,
+                 every: Optional[float] = None,
+                 show_label: Optional[bool] = None,
+                 container: bool = True,
+                 scale: Optional[int] = None,
+                 min_width: int = 160,
+                 interactive: Optional[bool] = None,
+                 visible: bool = True,
+                 elem_id: Optional[str] = None,
+                 elem_classes: Optional[List[str]] = None,
+                 render: bool = True,
+                 **kwargs):
+        # print("[TRACE] LabanMovementAnalysis.__init__ called")
+        """
+        Initialize the Laban Movement Analysis component.
+        
+        Args:
+            default_model: Default pose estimation model ("mediapipe", "movenet", "yolo")
+            enable_visualization: Whether to generate visualization video by default
+            include_keypoints: Whether to include raw keypoints in JSON output
+
+            label: Component label
+            ... (other standard Gradio component args)
+        """
+        super().__init__(
+            label=label,
+            every=every,
+            show_label=show_label,
+            container=container,
+            scale=scale,
+            min_width=min_width,
+            interactive=interactive,
+            visible=visible,
+            elem_id=elem_id,
+            elem_classes=elem_classes,
+            render=render,
+            **kwargs
+        )
+        
+        self.default_model = default_model
+        self.enable_visualization = enable_visualization
+        self.include_keypoints = include_keypoints
+        # Cache for pose estimators
+        self._estimators = {}
+        
+        # Video input handler for URLs
+        self.video_input = SmartVideoInput()
+        
+        # SkateFormer features reserved for Version 2
+    
+    def preprocess(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        # print("[TRACE] LabanMovementAnalysis.preprocess called")
+        """
+        Preprocess input from the frontend.
+        
+        Args:
+            payload: Input data containing video file and options
+            
+        Returns:
+            Processed data for analysis
+        """
+        if not payload:
+            return None
+            
+        # Extract video file path
+        video_data = payload.get("video")
+        if not video_data:
+            return None
+            
+        # Handle different input formats
+        if isinstance(video_data, str):
+            video_path = video_data
+        elif isinstance(video_data, dict):
+            video_path = video_data.get("path") or video_data.get("name")
+        else:
+            # Assume it's a file object
+            video_path = video_data.name if hasattr(video_data, "name") else str(video_data)
+        
+        # Extract options
+        options = {
+            "video_path": video_path,
+            "model": payload.get("model", self.default_model),
+            "enable_visualization": payload.get("enable_visualization", self.enable_visualization),
+            "include_keypoints": payload.get("include_keypoints", self.include_keypoints)
+        }
+        
+        return options
+    
+    def postprocess(self, value: Any) -> Dict[str, Any]:
+        # print("[TRACE] LabanMovementAnalysis.postprocess called")
+        """
+        Postprocess analysis results for the frontend.
+        
+        Args:
+            value: Analysis results
+            
+        Returns:
+            Formatted output for display
+        """
+        if value is None:
+            return {"json_output": {}, "video_output": None}
+        
+        # Ensure we have the expected format
+        if isinstance(value, tuple) and len(value) == 2:
+            json_data, video_path = value
+        else:
+            json_data = value
+            video_path = None
+        
+        return {
+            "json_output": json_data,
+            "video_output": video_path
+        }
+    
+    def process_video(self, video_input: Union[str, os.PathLike], model: str = DEFAULT_MODEL,
+                     enable_visualization: bool = True,
+                     include_keypoints: bool = False) -> Tuple[Dict[str, Any], Optional[str]]:
+        # print(f"[TRACE] LabanMovementAnalysis.process_video called with model={model}, enable_visualization={enable_visualization}, include_keypoints={include_keypoints}")
+        """
+        Main processing function that performs pose analysis on a video.
+        
+        Args:
+            video_input: Path to input video, video URL (YouTube/Vimeo), or file object
+            model: Pose estimation model to use (supports enhanced syntax like "yolo-v11-s")
+            enable_visualization: Whether to generate visualization video
+            include_keypoints: Whether to include keypoints in JSON
+            
+        Returns:
+            Tuple of (analysis_json, visualization_video_path)
+        """
+        # Handle video input (local file, URL, etc.)
+        try:
+            video_path, video_metadata = self.video_input.process_input(str(video_input))
+            print(f"Processing video: {video_metadata.get('title', 'Unknown')}")
+            if video_metadata.get('platform') in ['youtube', 'vimeo']:
+                print(f"Downloaded from {video_metadata['platform']}")
+        except Exception as e:
+            raise ValueError(f"Failed to process video input: {str(e)}")
+        # Get video metadata
+        frame_count, fps, (width, height) = get_video_info(video_path)
+        
+        # Create or get pose estimator
+        if model not in self._estimators:
+            self._estimators[model] = get_pose_estimator(model)
+        estimator = self._estimators[model]
+        
+        # Process video frame by frame
+        print(f"Processing {frame_count} frames with {model} model...")
+        
+        all_frames = []
+        all_pose_results = []
+        
+        for i, frame in enumerate(extract_frames(video_path)):
+            # Store frame if visualization is needed
+            if enable_visualization:
+                all_frames.append(frame)
+            
+            # Detect poses
+            pose_results = estimator.detect(frame)
+            
+            # Update frame indices
+            for result in pose_results:
+                result.frame_index = i
+            
+            all_pose_results.append(pose_results)
+            
+            # Progress indicator
+            if i % 30 == 0:
+                print(f"Processed {i}/{frame_count} frames...")
+        
+        print("Analyzing movement patterns...")
+        
+        # Analyze movement
+        movement_metrics = analyze_pose_sequence(all_pose_results, fps=fps)
+        
+        # Enhanced AI analysis reserved for Version 2
+        print("LMA analysis complete - advanced AI features coming in Version 2!")
+        
+        # Generate JSON output
+        video_metadata = {
+            "fps": fps,
+            "width": width,
+            "height": height,
+            "frame_count": frame_count,
+            "model_info": {
+                "name": model,
+                "type": "pose_estimation"
+            },
+            "input_metadata": video_metadata  # Include video source metadata
+        }
+        
+        json_output = generate_json(
+            movement_metrics,
+            all_pose_results if include_keypoints else None,
+            video_metadata,
+            include_keypoints=include_keypoints
+        )
+        
+        # Enhanced AI analysis will be added in Version 2
+        
+        # Generate visualization if requested
+        visualization_path = None
+        if enable_visualization:
+            print("Generating visualization video...")
+            
+            # Create temporary output file
+            with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as tmp:
+                visualization_path = tmp.name
+            
+            # Create visualizer
+            visualizer = PoseVisualizer(
+                show_trails=True,
+                show_skeleton=True,
+                show_direction_arrows=True,
+                show_metrics=True
+            )
+            
+            # Generate overlay video
+            visualization_path = visualizer.generate_overlay_video(
+                all_frames,
+                all_pose_results,
+                movement_metrics,
+                visualization_path,
+                fps
+            )
+            
+            print(f"Visualization saved to: {visualization_path}")
+        
+        return json_output, visualization_path
+    
+    def __call__(self, video_path: str, **kwargs) -> Tuple[Dict[str, Any], Optional[str]]:
+        # print(f"[TRACE] LabanMovementAnalysis.__call__ called with video_path={video_path}")
+        """
+        Make the component callable for easy use.
+        
+        Args:
+            video_path: Path to video file
+            **kwargs: Additional options
+            
+        Returns:
+            Analysis results
+        """
+        return self.process_video(video_path, **kwargs)
+    
+    def process(self, video_input: Union[str, os.PathLike], model: str = DEFAULT_MODEL, include_keypoints: bool = False) -> Dict[str, Any]:
+        """
+        Processes a video and returns only the JSON analysis result.
+
+        Args:
+            video_input: Path to input video, video URL, or file object
+            model: Pose estimation model to use
+            include_keypoints: Whether to include keypoints in JSON
+
+        Returns:
+            dict: Movement analysis results in JSON format
+        """
+        json_output, _ = self.process_video(
+            video_input,
+            model=model,
+            enable_visualization=False,
+            include_keypoints=include_keypoints
+        )
+        return json_output
+    
+    # SkateFormer methods moved to Version 2 development
+    # get_skateformer_compatibility() and get_skateformer_status_report() 
+    # will be available in the next major release
+    
+    def cleanup(self):
+        # print("[TRACE] LabanMovementAnalysis.cleanup called")
+        """Clean up temporary files and resources."""
+        # Clean up video input handler
+        if hasattr(self, 'video_input'):
+            self.video_input.cleanup()
+    
+    def example_payload(self) -> Dict[str, Any]:
+        # print("[TRACE] LabanMovementAnalysis.example_payload called")
+        """Example input payload for documentation."""
+        return {
+            "video": {"path": "/path/to/video.mp4"},
+            "model": "mediapipe",
+            "enable_visualization": True,
+            "include_keypoints": False
+        }
+    
+    def example_value(self) -> Dict[str, Any]:
+        # print("[TRACE] LabanMovementAnalysis.example_value called")
+        """Example output value for documentation."""
+        return {
+            "json_output": {
+                "analysis_metadata": {
+                    "timestamp": "2024-01-01T00:00:00",
+                    "version": "1.0.0",
+                    "model_info": {"name": "mediapipe", "type": "pose_estimation"}
+                },
+                "video_info": {
+                    "fps": 30.0,
+                    "duration_seconds": 5.0,
+                    "width": 1920,
+                    "height": 1080,
+                    "frame_count": 150
+                },
+                "movement_analysis": {
+                    "frame_count": 150,
+                    "frames": [
+                        {
+                            "frame_index": 0,
+                            "timestamp": 0.0,
+                            "metrics": {
+                                "direction": "stationary",
+                                "intensity": "low",
+                                "speed": "slow",
+                                "velocity": 0.0,
+                                "acceleration": 0.0,
+                                "fluidity": 1.0,
+                                "expansion": 0.5
+                            }
+                        }
+                    ],
+                    "summary": {
+                        "direction": {
+                            "distribution": {"stationary": 50, "up": 30, "down": 20},
+                            "dominant": "stationary"
+                        },
+                        "intensity": {
+                            "distribution": {"low": 80, "medium": 15, "high": 5},
+                            "dominant": "low"
+                        }
+                    }
+                }
+            },
+            "video_output": "/tmp/visualization.mp4"
+        }
+    
+    def api_info(self) -> Dict[str, Any]:
+        # print("[TRACE] LabanMovementAnalysis.api_info called")
+        """API information for the component."""
+        return {
+            "type": "composite",
+            "description": "Video-based pose analysis with Laban Movement Analysis metrics",
+            "parameters": {
+                "video": {"type": "file", "description": "Input video file or URL (YouTube/Vimeo)"},
+                "model": {"type": "string", "description": "Pose model: mediapipe, movenet, or yolo variants"},
+                "enable_visualization": {"type": "integer", "description": "Generate visualization video (1=yes, 0=no)"},
+                "include_keypoints": {"type": "integer", "description": "Include keypoints in JSON (1=yes, 0=no)"}
+            },
+            "returns": {
+                "json_output": {"type": "object", "description": "LMA analysis results"},
+                "video_output": {"type": "file", "description": "Visualization video (optional)"}
+            },
+            "version_2_preview": {
+                "planned_features": ["SkateFormer AI integration", "Enhanced movement recognition", "Real-time analysis"],
+                "note": "Advanced AI features coming in Version 2!"
+            }
+        }
+    from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+    from gradio.blocks import Block
+    if TYPE_CHECKING:
+        from gradio.components import Timer
+        from gradio.components.base import Component

backend/gradio_labanmovementanalysis/notation_engine.py

@@ -17,8 +17,8 @@ class Direction(Enum):
     DOWN = "down"
     LEFT = "left"
     RIGHT = "right"
-    FORWARD = "forward"
-    BACKWARD = "backward"
+    FORWARD = "forward"  # Note: Not fully implemented with 2D keypoints
+    BACKWARD = "backward" # Note: Not fully implemented with 2D keypoints
     STATIONARY = "stationary"
 
 
@@ -64,20 +64,20 @@ class MovementAnalyzer:
     """Analyzes pose sequences to extract LMA-style movement metrics."""
     
     def __init__(self, fps: float = 30.0, 
-                 velocity_threshold_slow: float = 0.01,
-                 velocity_threshold_fast: float = 0.1,
-                 intensity_accel_threshold: float = 0.05):
+                 velocity_threshold_slow: float = 0.01, # Normalized units / frame; will be scaled by fps
+                 velocity_threshold_fast: float = 0.1,  # Normalized units / frame; will be scaled by fps
+                 intensity_accel_threshold: float = 0.05): # Normalized units / frame^2; will be scaled by fps^2 (approx)
         """
         Initialize movement analyzer.
         
         Args:
             fps: Frames per second of the video
-            velocity_threshold_slow: Threshold for slow movement (normalized)
-            velocity_threshold_fast: Threshold for fast movement (normalized)
-            intensity_accel_threshold: Acceleration threshold for intensity
+            velocity_threshold_slow: Threshold for slow movement (normalized units per second)
+            velocity_threshold_fast: Threshold for fast movement (normalized units per second)
+            intensity_accel_threshold: Acceleration threshold for intensity (normalized units per second^2)
         """
         self.fps = fps
-        self.frame_duration = 1.0 / fps
+        self.frame_duration = 1.0 / fps if fps > 0 else 0.0
         self.velocity_threshold_slow = velocity_threshold_slow
         self.velocity_threshold_fast = velocity_threshold_fast
         self.intensity_accel_threshold = intensity_accel_threshold
@@ -87,43 +87,56 @@ class MovementAnalyzer:
         Analyze a sequence of poses to compute movement metrics.
         
         Args:
-            pose_sequence: List of pose results per frame
+            pose_sequence: List of pose results per frame. Each inner list can contain
+                           multiple PoseResult if multiple people are detected.
             
         Returns:
-            List of movement metrics per frame
+            List of movement metrics per frame (currently for the first detected person).
         """
         if not pose_sequence:
             return []
         
         metrics = []
-        prev_centers = None
-        prev_velocity = None
+        # For multi-person, these would need to be dictionaries mapping person_id to values
+        prev_centers = None # Store as {person_id: center_coords} for multi-person
+        prev_velocity = None # Store as {person_id: velocity_value} for multi-person
         
         for frame_idx, frame_poses in enumerate(pose_sequence):
             if not frame_poses:
                 # No pose detected in this frame
                 metrics.append(MovementMetrics(
                     frame_index=frame_idx,
-                    timestamp=frame_idx * self.frame_duration
+                    timestamp=frame_idx * self.frame_duration if self.frame_duration else None
                 ))
                 continue
             
-            # For now, analyze first person only
-            # TODO: Extend to multi-person analysis
-            pose = frame_poses[0]
-            
-            # Compute body center and limb positions
+            # --- CURRENT: Analyze first person only ---
+            # TODO: Extend to multi-person analysis. This would involve iterating
+            # through frame_poses and tracking metrics for each person_id.
+            pose = frame_poses[0] 
+            # --- END CURRENT ---
+
+            if not pose.keypoints: # Ensure pose object has keypoints
+                 metrics.append(MovementMetrics(
+                    frame_index=frame_idx,
+                    timestamp=frame_idx * self.frame_duration if self.frame_duration else None
+                ))
+                 # Reset for next frame if this person was being tracked
+                 prev_centers = None # Or prev_centers.pop(person_id, None)
+                 prev_velocity = None # Or prev_velocity.pop(person_id, None)
+                 continue
+
+            # Compute body center
             center = self._compute_body_center(pose.keypoints)
-            limb_positions = self._get_limb_positions(pose.keypoints)
             
             # Initialize metrics for this frame
             frame_metrics = MovementMetrics(
                 frame_index=frame_idx,
-                timestamp=frame_idx * self.frame_duration
+                timestamp=frame_idx * self.frame_duration if self.frame_duration else None
             )
             
-            if prev_centers is not None and frame_idx > 0:
-                # Compute displacement and velocity
+            # Displacement, velocity, etc. can only be computed if there's a previous frame's center
+            if prev_centers is not None and frame_idx > 0 and self.fps > 0:
                 displacement = (
                     center[0] - prev_centers[0],
                     center[1] - prev_centers[1]
@@ -133,102 +146,86 @@ class MovementAnalyzer:
                     displacement[0]**2 + displacement[1]**2
                 )
                 
-                # Velocity (normalized units per second)
                 frame_metrics.velocity = frame_metrics.total_displacement * self.fps
-                
-                # Direction
                 frame_metrics.direction = self._compute_direction(displacement)
-                
-                # Speed category
                 frame_metrics.speed = self._categorize_speed(frame_metrics.velocity)
                 
-                # Acceleration and intensity
                 if prev_velocity is not None:
-                    frame_metrics.acceleration = abs(
-                        frame_metrics.velocity - prev_velocity
-                    ) * self.fps
+                    # Acceleration (change in velocity per second)
+                    delta_velocity = frame_metrics.velocity - prev_velocity
+                    frame_metrics.acceleration = delta_velocity * self.fps # (units/s)/s = units/s^2
+                    
                     frame_metrics.intensity = self._compute_intensity(
                         frame_metrics.acceleration,
                         frame_metrics.velocity
                     )
-                
-                # Fluidity (based on acceleration smoothness)
-                frame_metrics.fluidity = self._compute_fluidity(
-                    frame_metrics.acceleration
-                )
+                    frame_metrics.fluidity = self._compute_fluidity(
+                        frame_metrics.acceleration
+                    )
             
-            # Expansion (how spread out the pose is)
             frame_metrics.expansion = self._compute_expansion(pose.keypoints)
-            
             metrics.append(frame_metrics)
             
-            # Update previous values
+            # Update for next iteration (for the currently tracked person)
             prev_centers = center
             prev_velocity = frame_metrics.velocity
         
-        # Post-process to smooth metrics if needed
         metrics = self._smooth_metrics(metrics)
-        
         return metrics
     
     def _compute_body_center(self, keypoints: List[Keypoint]) -> Tuple[float, float]:
         """Compute the center of mass of the body."""
-        # Use major body joints for center calculation
         major_joints = ["left_hip", "right_hip", "left_shoulder", "right_shoulder"]
         
         x_coords = []
         y_coords = []
         
         for kp in keypoints:
-            if kp.name in major_joints and kp.confidence > 0.5:
+            if kp.confidence > 0.5 and kp.name in major_joints: # Ensure kp.name is not None
                 x_coords.append(kp.x)
                 y_coords.append(kp.y)
         
-        if not x_coords:
-            # Fallback to all keypoints
+        if not x_coords or not y_coords: # If no major joints, try all keypoints
             x_coords = [kp.x for kp in keypoints if kp.confidence > 0.3]
             y_coords = [kp.y for kp in keypoints if kp.confidence > 0.3]
         
-        if x_coords:
+        if x_coords and y_coords: # Check if lists are non-empty
             return (np.mean(x_coords), np.mean(y_coords))
-        return (0.5, 0.5)  # Default center
+        return (0.5, 0.5)  # Default center if no reliable keypoints
     
     def _get_limb_positions(self, keypoints: List[Keypoint]) -> Dict[str, Tuple[float, float]]:
-        """Get positions of major limbs."""
+        """Get positions of major limbs. (Currently not heavily used beyond potential debugging)"""
         positions = {}
         for kp in keypoints:
-            if kp.confidence > 0.3:
+            if kp.confidence > 0.3 and kp.name:
                 positions[kp.name] = (kp.x, kp.y)
         return positions
     
     def _compute_direction(self, displacement: Tuple[float, float]) -> Direction:
         """Compute movement direction from displacement vector."""
         dx, dy = displacement
-        
-        # Threshold for considering movement
-        threshold = 0.005
+        threshold = 0.005 # Normalized units per frame
         
         if abs(dx) < threshold and abs(dy) < threshold:
             return Direction.STATIONARY
         
-        # Determine primary direction
         if abs(dx) > abs(dy):
             return Direction.RIGHT if dx > 0 else Direction.LEFT
         else:
-            return Direction.DOWN if dy > 0 else Direction.UP
+            return Direction.DOWN if dy > 0 else Direction.UP # dy positive is typically down in image coords
     
     def _categorize_speed(self, velocity: float) -> Speed:
-        """Categorize velocity into speed levels."""
+        """Categorize velocity into speed levels (velocity is in normalized units/sec)."""
         if velocity < self.velocity_threshold_slow:
             return Speed.SLOW
         elif velocity < self.velocity_threshold_fast:
-            return Speed.FAST
+            return Speed.MODERATE # Corrected from Speed.FAST
         else:
             return Speed.FAST
     
     def _compute_intensity(self, acceleration: float, velocity: float) -> Intensity:
-        """Compute movement intensity based on acceleration and velocity."""
-        # High acceleration or high velocity indicates high intensity
+        """Compute movement intensity (accel in norm_units/sec^2, vel in norm_units/sec)."""
+        # Thresholds are relative to normalized space and per-second metrics
         if acceleration > self.intensity_accel_threshold * 2 or velocity > self.velocity_threshold_fast:
             return Intensity.HIGH
         elif acceleration > self.intensity_accel_threshold or velocity > self.velocity_threshold_slow:
@@ -238,14 +235,12 @@ class MovementAnalyzer:
     
     def _compute_fluidity(self, acceleration: float) -> float:
         """
-        Compute fluidity score (0-1) based on acceleration.
-        Lower acceleration = higher fluidity (smoother movement).
+        Compute fluidity score (0-1) based on acceleration (norm_units/sec^2).
+        Lower acceleration = higher fluidity.
         """
-        # Normalize acceleration to 0-1 range
-        max_accel = 0.2  # Expected maximum acceleration
-        norm_accel = min(acceleration / max_accel, 1.0)
-        
-        # Invert so low acceleration = high fluidity
+        max_expected_accel = 0.2 # This is an assumption for normalization, might need tuning.
+                                 # Represents a fairly high acceleration in normalized units/sec^2.
+        norm_accel = min(abs(acceleration) / max_expected_accel, 1.0) if max_expected_accel > 0 else 0.0
         return 1.0 - norm_accel
     
     def _compute_expansion(self, keypoints: List[Keypoint]) -> float:
@@ -253,52 +248,62 @@ class MovementAnalyzer:
         Compute how expanded/contracted the pose is.
         Returns 0-1 where 1 is fully expanded.
         """
-        # Calculate distances between opposite limbs
         limb_pairs = [
             ("left_wrist", "right_wrist"),
             ("left_ankle", "right_ankle"),
-            ("left_wrist", "left_ankle"),
-            ("right_wrist", "right_ankle")
+            ("left_wrist", "left_ankle"), 
+            ("right_wrist", "right_ankle"),
+            # Could add torso diagonals like ("left_shoulder", "right_hip")
         ]
         
-        kp_dict = {kp.name: kp for kp in keypoints if kp.confidence > 0.3}
-        
+        kp_dict = {kp.name: kp for kp in keypoints if kp.confidence > 0.3 and kp.name}
+        if not kp_dict: return 0.5 # No reliable keypoints
+
         distances = []
-        for limb1, limb2 in limb_pairs:
-            if limb1 in kp_dict and limb2 in kp_dict:
-                kp1 = kp_dict[limb1]
-                kp2 = kp_dict[limb2]
-                dist = np.sqrt((kp1.x - kp2.x)**2 + (kp1.y - kp2.y)**2)
-                distances.append(dist)
+        for name1, name2 in limb_pairs:
+            if name1 in kp_dict and name2 in kp_dict:
+                kp1 = kp_dict[name1]
+                kp2 = kp_dict[name2]
+                # Ensure coordinates are not NaN before calculation
+                if not (np.isnan(kp1.x) or np.isnan(kp1.y) or np.isnan(kp2.x) or np.isnan(kp2.y)):
+                    dist = np.sqrt((kp1.x - kp2.x)**2 + (kp1.y - kp2.y)**2)
+                    distances.append(dist)
         
         if distances:
-            # Normalize by expected maximum distance
             avg_dist = np.mean(distances)
-            max_expected = 1.4  # Diagonal of normalized space
-            return min(avg_dist / max_expected, 1.0)
+            # Max expected distance (e.g., diagonal of normalized 1x1 space is sqrt(2) approx 1.414)
+            # This assumes keypoints are normalized.
+            max_possible_dist_heuristic = 1.0 # A more conservative heuristic than 1.4, as limbs rarely span the full diagonal.
+            return min(avg_dist / max_possible_dist_heuristic, 1.0) if max_possible_dist_heuristic > 0 else 0.0
         
-        return 0.5  # Default neutral expansion
+        return 0.5  # Default neutral expansion if no valid pairs
     
-    def _smooth_metrics(self, metrics: List[MovementMetrics]) -> List[MovementMetrics]:
-        """Apply smoothing to reduce noise in metrics."""
-        # Simple moving average for numeric values
+    def _smooth_metrics(self, metrics_list: List[MovementMetrics]) -> List[MovementMetrics]:
+        """Apply smoothing to reduce noise in metrics using a simple moving average."""
         window_size = 3
+        num_metrics = len(metrics_list)
+
+        if num_metrics <= window_size:
+            return metrics_list
+
+        smoothed_metrics_list = metrics_list[:] # Work on a copy
+
+        # Fields to smooth
+        fields_to_smooth = ["velocity", "acceleration", "fluidity", "expansion"]
+
+        for i in range(num_metrics):
+            start_idx = max(0, i - window_size // 2)
+            end_idx = min(num_metrics, i + window_size // 2 + 1)
+            window = metrics_list[start_idx:end_idx]
+
+            if not window: continue
+
+            for field in fields_to_smooth:
+                values = [getattr(m, field) for m in window if hasattr(m, field)]
+                if values:
+                    setattr(smoothed_metrics_list[i], field, np.mean(values))
         
-        if len(metrics) <= window_size:
-            return metrics
-        
-        # Smooth velocity and acceleration
-        for i in range(window_size, len(metrics)):
-            velocities = [m.velocity for m in metrics[i-window_size:i+1]]
-            metrics[i].velocity = np.mean(velocities)
-            
-            accels = [m.acceleration for m in metrics[i-window_size:i+1]]
-            metrics[i].acceleration = np.mean(accels)
-            
-            fluidities = [m.fluidity for m in metrics[i-window_size:i+1]]
-            metrics[i].fluidity = np.mean(fluidities)
-        
-        return metrics
+        return smoothed_metrics_list
 
 
 def analyze_pose_sequence(pose_sequence: List[List[PoseResult]], 
@@ -314,4 +319,4 @@ def analyze_pose_sequence(pose_sequence: List[List[PoseResult]],
         List of movement metrics
     """
     analyzer = MovementAnalyzer(fps=fps)
-    return analyzer.analyze_movement(pose_sequence) 
+    return analyzer.analyze_movement(pose_sequence)

cookies.txt

@@ -0,0 +1,12 @@
+# Netscape HTTP Cookie File
+# This file is generated by yt-dlp.  Do not edit.
+
+.youtube.com	TRUE	/	FALSE	0	PREF	hl=en&tz=UTC
+.youtube.com	TRUE	/	TRUE	0	SOCS	CAI
+.youtube.com	TRUE	/	TRUE	1749571718	GPS	1
+.youtube.com	TRUE	/	TRUE	0	YSC	Lynn9Gphl18
+.youtube.com	TRUE	/	TRUE	1765122596	VISITOR_INFO1_LIVE	pOBV-yb5TwA
+.youtube.com	TRUE	/	TRUE	1765122596	VISITOR_PRIVACY_METADATA	CgJTSxIhEh0SGwsMDg8QERITFBUWFxgZGhscHR4fICEiIyQlJiA5
+.youtube.com	TRUE	/	TRUE	1765121919	__Secure-ROLLOUT_TOKEN	CIvW7bfurM-MgAEQm8aF7JfnjQMYuv2n7JfnjQM%3D
+.youtube.com	TRUE	/	TRUE	1812642596	__Secure-YT_TVFAS	t=485991&s=2
+.youtube.com	TRUE	/	TRUE	1765122596	DEVICE_INFO	ChxOelV4TkRNME5UVTROVGsyTWpnME1UazBNZz09EKSoocIGGP+iocIG

demo/app.py

@@ -3,11 +3,11 @@
 Laban Movement Analysis – modernised Gradio Space
 Author: Csaba (BladeSzaSza)
 """
-
 import gradio as gr
 import os
-from backend.gradio_labanmovementanalysis import LabanMovementAnalysis
-# from gradio_labanmovementanalysis import LabanMovementAnalysis
+# from backend.gradio_labanmovementanalysis import LabanMovementAnalysis
+from gradio_labanmovementanalysis import LabanMovementAnalysis
+from gradio_overlay_video import OverlayVideo
 
 # Import agent API if available
 # Initialize agent API if available
@@ -19,15 +19,10 @@ try:
         MovementDirection,
         MovementIntensity
     )
-    HAS_AGENT_API = True
-    
-    try:
-        agent_api = LabanAgentAPI()
-    except Exception as e:
-        print(f"Warning: Agent API not available: {e}")
-        agent_api = None
-except ImportError:
-    HAS_AGENT_API = False
+    agent_api = LabanAgentAPI()
+except Exception as e:
+    print(f"Warning: Agent API not available: {e}")
+    agent_api = None
 # Initialize components
 try:
     analyzer = LabanMovementAnalysis(
@@ -59,21 +54,37 @@ def process_video_enhanced(video_input, model, enable_viz, include_keypoints):
         error_result = {"error": str(e)}
         return error_result, None
 
-def process_video_standard(video, model, enable_viz, include_keypoints):
-    """Standard video processing function."""
+def process_video_standard(video : str, model : str, include_keypoints : bool) -> dict:
+    """
+    Processes a video file using the specified pose estimation model and returns movement analysis results.
+
+    Args:
+        video (str): Path to the video file to be analyzed.
+        model (str): The name of the pose estimation model to use (e.g., "mediapipe-full", "movenet-thunder", etc.).
+        include_keypoints (bool): Whether to include raw keypoint data in the output.
+
+    Returns:
+        dict:
+            - A dictionary containing the movement analysis results in JSON format, or an error message if processing fails.
+
+
+    Notes:
+        - Visualization is disabled in this standard processing function.
+        - If the input video is None, both return values will be None.
+        - If an error occurs during processing, the first return value will be a dictionary with an "error" key.
+    """
     if video is None:
-        return None, None
-    
+        return None
     try:
-        json_output, video_output = analyzer.process_video(
+        json_output, _ = analyzer.process_video(
             video,
             model=model,
-            enable_visualization=enable_viz,
+            enable_visualization=False,
             include_keypoints=include_keypoints
         )
-        return json_output, video_output
-    except Exception as e:
-        return {"error": str(e)}, None
+        return json_output
+    except (RuntimeError, ValueError, OSError) as e:
+        return {"error": str(e)}
 
 # ── 4.  Build UI ─────────────────────────────────────────────────
 def create_demo() -> gr.Blocks:
@@ -82,7 +93,7 @@ def create_demo() -> gr.Blocks:
         theme='gstaff/sketch',
         fill_width=True,
     ) as demo:
-
+        # gr.api(process_video_standard, api_name="process_video") 
         # ── Hero banner ──
         gr.Markdown(
             """
@@ -130,8 +141,8 @@ def create_demo() -> gr.Blocks:
                         )
                         
                         with gr.Accordion("Analysis Options", open=False):
-                            enable_viz = gr.Radio([("Yes", 1), ("No", 0)], value=1, label="Visualization")
-                            include_kp = gr.Radio([("Yes", 1), ("No", 0)], value=0, label="Raw Keypoints")
+                            enable_viz = gr.Radio([("Create", 1), ("Dismiss", 0)], value=1, label="Visualization")
+                            include_kp = gr.Radio([("Include", 1), ("Exclude", 0)], value=1, label="Raw Keypoints")
 
                         gr.Examples(
                             examples=[
@@ -156,7 +167,9 @@ def create_demo() -> gr.Blocks:
                 def process_enhanced_input(file_input, url_input, model, enable_viz, include_keypoints):
                     """Process either file upload or URL input."""
                     video_source = file_input if file_input else url_input
-                    return process_video_enhanced(video_source, model, enable_viz, include_keypoints)
+                    [json_out, viz_out] = process_video_enhanced(video_source, model, enable_viz, include_keypoints)
+                    overlay_video.value = (None, json_out)
+                    return [json_out, viz_out]
                 
                 analyze_btn_enh.click(
                     fn=process_enhanced_input,
@@ -165,18 +178,48 @@ def create_demo() -> gr.Blocks:
                     api_name="analyze_enhanced"
                 )
 
+            with gr.Tab("🎬 Overlayed Visualisation"):
+                gr.Markdown(
+                    "# 🩰 Interactive Pose Visualization\n"
+                    "## See the movement analysis in action with an interactive overlay. "
+                    "Analyze video @ 🎬 Standard Analysis tab"
+                )
+                with gr.Row(equal_height=True, min_height=400):
+                    overlay_video = OverlayVideo(
+                            value=(None, json_out),
+                            autoplay=True,
+                            interactive=False
+                        )
+                
+                       
+                # Update overlay when JSON changes
+                def update_overlay(json_source):
+                    """Update overlay video with JSON data from analysis or upload."""
+                    if json_source:
+                        return OverlayVideo(value=("", json_source), autoplay=True, interactive=False)
+                    return OverlayVideo(value=("", None), autoplay=True, interactive=False)
+                
+                # Connect JSON output from analysis to overlay
+                json_out.change(
+                    fn=update_overlay,
+                    inputs=[json_out],
+                    outputs=[overlay_video]
+                )
+         
         # Footer
         with gr.Row():
             gr.Markdown(
                 """
                 **Built by Csaba Bolyós**  
-                [GitHub](https://github.com/bladeszasza) • [HF](https://huggingface.co/BladeSzaSza)
+                [GitHub](https://github.com/bladeszasza) • [HF](https://huggingface.co/BladeSzaSza) • [LinkedIn](https://www.linkedin.com/in/csaba-bolyós-00a11767/)
                 """
             )
     return demo
-  
+
+
 if __name__ == "__main__":
     demo = create_demo()
     demo.launch(server_name="0.0.0.0",
+                share=True,
                 server_port=int(os.getenv("PORT", 7860)),
                 mcp_server=True) 

demo/space.py

@@ -59,15 +59,10 @@ try:
         MovementDirection,
         MovementIntensity
     )
-    HAS_AGENT_API = True
-    
-    try:
-        agent_api = LabanAgentAPI()
-    except Exception as e:
-        print(f"Warning: Agent API not available: {e}")
-        agent_api = None
-except ImportError:
-    HAS_AGENT_API = False
+    agent_api = LabanAgentAPI()
+except Exception as e:
+    print(f"Warning: Agent API not available: {e}")
+    agent_api = None
 # Initialize components
 try:
     analyzer = LabanMovementAnalysis(
@@ -99,21 +94,37 @@ def process_video_enhanced(video_input, model, enable_viz, include_keypoints):
         error_result = {"error": str(e)}
         return error_result, None
 
-def process_video_standard(video, model, enable_viz, include_keypoints):
-    \"\"\"Standard video processing function.\"\"\"
+def process_video_standard(video : str, model : str, include_keypoints : bool) -> dict:
+    \"\"\"
+    Processes a video file using the specified pose estimation model and returns movement analysis results.
+
+    Args:
+        video (str): Path to the video file to be analyzed.
+        model (str): The name of the pose estimation model to use (e.g., "mediapipe-full", "movenet-thunder", etc.).
+        include_keypoints (bool): Whether to include raw keypoint data in the output.
+
+    Returns:
+        dict:
+            - A dictionary containing the movement analysis results in JSON format, or an error message if processing fails.
+
+
+    Notes:
+        - Visualization is disabled in this standard processing function.
+        - If the input video is None, both return values will be None.
+        - If an error occurs during processing, the first return value will be a dictionary with an "error" key.
+    \"\"\"
     if video is None:
-        return None, None
-    
+        return None
     try:
-        json_output, video_output = analyzer.process_video(
+        json_output, _ = analyzer.process_video(
             video,
             model=model,
-            enable_visualization=enable_viz,
+            enable_visualization=False,
             include_keypoints=include_keypoints
         )
-        return json_output, video_output
-    except Exception as e:
-        return {"error": str(e)}, None
+        return json_output
+    except (RuntimeError, ValueError, OSError) as e:
+        return {"error": str(e)}
 
 # ── 4.  Build UI ─────────────────────────────────────────────────
 def create_demo() -> gr.Blocks:
@@ -122,7 +133,7 @@ def create_demo() -> gr.Blocks:
         theme='gstaff/sketch',
         fill_width=True,
     ) as demo:
-
+        gr.api(process_video_standard, api_name="process_video") 
         # ── Hero banner ──
         gr.Markdown(
             \"\"\"
@@ -214,10 +225,12 @@ def create_demo() -> gr.Blocks:
                 \"\"\"
             )
     return demo
-  
+
+
 if __name__ == "__main__":
     demo = create_demo()
     demo.launch(server_name="0.0.0.0",
+                share=True,
                 server_port=int(os.getenv("PORT", 7860)),
                 mcp_server=True) 
 

pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gradio_labanmovementanalysis"
-version = "0.0.4"
+version = "0.0.5"
 description = "A Gradio 5 component for video movement analysis using Laban Movement Analysis (LMA) with MCP support for AI agents"
 readme = "README.md"
 license = "apache-2.0"
@@ -24,7 +24,8 @@ dependencies = [
     "ultralytics>=8.0.0",
     "tensorflow>=2.8.0",
     "tensorflow-hub>=0.12.0",
-    "yt-dlp>=2025.05.22"
+    "yt-dlp>=2025.05.22",
+    "gradio_overlay_video>=0.0.9"
 ]
 
 [project.optional-dependencies]