Upload folder using huggingface_hub

.gitignore

@@ -327,4 +327,7 @@ tb_logs/
 outputs/
 .hydra/ 
 
-.working/
+.working/
+
+# Claude Code project instructions
+CLAUDE.md

README.md

@@ -1,6 +1,6 @@
 ---
 title: Laban Movement Analysis
-emoji: 🏃
+emoji: 🩰
 colorFrom: purple
 colorTo: green
 app_file: app.py
@@ -20,14 +20,43 @@ tags:
 - mediapipe
 - yolo
 - gradio
-short_description: Professional movement analysis with pose estimation and AI
+- agentic-analysis
+- overlay-video
+- temporal-patterns
+short_description: Laban Movement Analysis (LMA) from pose estimation
 license: apache-2.0
 ---
 
-# `gradio_labanmovementanalysis`
+# 🩰 Laban Movement Analysis
 <a href="https://pypi.org/project/gradio_labanmovementanalysis/" target="_blank"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/gradio_labanmovementanalysis"></a>  
 
-A Gradio 5 component for video movement analysis using Laban Movement Analysis (LMA) with MCP support for AI agents
+**Advanced video movement analysis platform** combining Laban Movement Analysis (LMA) principles with modern AI pose estimation, intelligent analysis, and interactive visualization.
+
+## 🌟 Key Features
+
+### 📊 **Multi-Model Pose Estimation** 
+- **15 different pose estimation models** from multiple sources:
+  - **MediaPipe**: `mediapipe-lite`, `mediapipe-full`, `mediapipe-heavy`
+  - **MoveNet**: `movenet-lightning`, `movenet-thunder`  
+  - **YOLO v8**: `yolo-v8-n/s/m/l/x` (5 variants)
+  - **YOLO v11**: `yolo-v11-n/s/m/l/x` (5 variants)
+
+### 🎥 **Comprehensive Video Processing**
+- **JSON Analysis Output**: Detailed movement metrics with temporal data
+- **Annotated Video Generation**: Pose overlay with Laban movement data
+- **URL Support**: Direct processing from YouTube, Vimeo, and video URLs
+- **Custom Overlay Component**: `gradio_overlay_video` for controlled layered visualization
+
+### 🤖 **Agentic Intelligence** 
+- **SUMMARY Analysis**: Narrative movement interpretation with temporal patterns
+- **STRUCTURED Analysis**: Quantitative breakdowns and statistical insights  
+- **MOVEMENT FILTERS**: Pattern detection with intelligent filtering
+- **Laban Interpretation**: Professional movement quality assessment
+
+### 🎨 **Interactive Visualization**
+- **Standard Analysis Tab**: Core pose estimation and LMA processing
+- **Overlay Visualization Tab**: Interactive layered video display
+- **Agentic Analysis Tab**: AI-powered movement insights and filtering
 
 ## Installation
 
@@ -46,8 +75,8 @@ 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
 
 # Import agent API if available
 # Initialize agent API if available
@@ -59,15 +88,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 +123,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 +163,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 +255,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) 
 

app.py

@@ -3,12 +3,12 @@
 Laban Movement Analysis – modernised Gradio Space
 Author: Csaba (BladeSzaSza)
 """
-
 import gradio as gr
 import os
-from spaces import GPU
-from src.backend.gradio_labanmovementanalysis import LabanMovementAnalysis
-# from gradio_labanmovementanalysis import LabanMovementAnalysis
+from pathlib import Path
+# from backend.gradio_labanmovementanalysis import LabanMovementAnalysis
+from backend.gradio_labanmovementanalysis import LabanMovementAnalysis
+from gradio_overlay_video import OverlayVideo
 
 # Import agent API if available
 # Initialize agent API if available
@@ -20,14 +20,11 @@ try:
         MovementDirection,
         MovementIntensity
     )
+    agent_api = LabanAgentAPI()
     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:
+except Exception as e:
+    print(f"Warning: Agent API not available: {e}")
+    agent_api = None
     HAS_AGENT_API = False
 # Initialize components
 try:
@@ -39,7 +36,7 @@ except Exception as e:
     print(f"Warning: Some features may not be available: {e}")
     analyzer = LabanMovementAnalysis()
 
-@GPU
+
 def process_video_enhanced(video_input, model, enable_viz, include_keypoints):
     """Enhanced video processing with all new features."""
     if not video_input:
@@ -60,21 +57,86 @@ 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
+        return json_output
+    except (RuntimeError, ValueError, OSError) as e:
+        return {"error": str(e)}
+
+def process_video_for_agent(video, model, output_format="summary"):
+    """Process video with agent-friendly output format."""
+    if not HAS_AGENT_API or agent_api is None:
+        return {"error": "Agent API not available"}
+    
+    if not video:
+        return {"error": "No video provided"}
+    
+    try:
+        model_enum = PoseModel(model)
+        result = agent_api.analyze(video, model=model_enum, generate_visualization=False)
+        
+        if output_format == "summary":
+            return {"summary": agent_api.get_movement_summary(result)}
+        elif output_format == "structured":
+            return {
+                "success": result.success,
+                "direction": result.dominant_direction.value,
+                "intensity": result.dominant_intensity.value,
+                "speed": result.dominant_speed,
+                "fluidity": result.fluidity_score,
+                "expansion": result.expansion_score,
+                "segments": len(result.movement_segments)
+            }
+        else:  # json
+            return result.raw_data
     except Exception as e:
-        return {"error": str(e)}, None
+        return {"error": str(e)}
+
+# Batch processing removed due to MediaPipe compatibility issues
+
+# process_standard_for_agent is now imported from backend
+
+# Movement filtering removed due to MediaPipe compatibility issues
+
+# Import agentic analysis functions from backend
+try:
+    from gradio_labanmovementanalysis.agentic_analysis import (
+        generate_agentic_analysis,
+        process_standard_for_agent
+    )
+except ImportError:
+    # Fallback if backend module is not available
+    def generate_agentic_analysis(json_data, analysis_type, filter_direction="any", filter_intensity="any", filter_min_fluidity=0.0, filter_min_expansion=0.0):
+        return {"error": "Agentic analysis backend not available"}
+    
+    def process_standard_for_agent(json_data, output_format="summary"):
+        return {"error": "Agent conversion backend not available"}
 
 # ── 4.  Build UI ─────────────────────────────────────────────────
 def create_demo() -> gr.Blocks:
@@ -83,18 +145,18 @@ 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(
             """
-            # 🎭 Laban Movement Analysis 
+            # 🩰 Laban Movement Analysis 
             
             Pose estimation • AI action recognition • Movement Analysis 
             """
         )
         with gr.Tabs():
             # Tab 1: Standard Analysis
-            with gr.Tab("🎬 Standard Analysis"):
+            with gr.Tab("🎭 Standard Analysis"):
                 gr.Markdown("""
                 ### Upload a video file to analyze movement using traditional LMA metrics with pose estimation.
                 """)
@@ -131,12 +193,12 @@ 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=[
-                                ["src/examples/balette.mp4"],
+                                ["examples/balette.mp4"],
                                 ["https://www.youtube.com/shorts/RX9kH2l3L8U"],
                                 ["https://vimeo.com/815392738"],
                                 ["https://vimeo.com/548964931"],
@@ -157,7 +219,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,
@@ -166,18 +230,295 @@ 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=240):
+                    with gr.Column(scale=1):
+                        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]
+                )
+
+            # Tab 3: Agentic Analysis
+            with gr.Tab("🤖 Agentic Analysis"):
+                gr.Markdown("""
+                ### Intelligent Movement Interpretation
+                AI-powered analysis using the processed data from the Standard Analysis tab.
+                """)
+                
+                with gr.Row(equal_height=True):
+                    # Left column - Video display (sourced from first tab)
+                    with gr.Column(scale=1, min_width=400):
+                        gr.Markdown("**Source Video** *(from Standard Analysis)*")
+                        agentic_video_display = gr.Video(
+                            label="Analyzed Video", 
+                            interactive=False,
+                            height=350
+                        )
+                        
+                        # Model info display (sourced from first tab)
+                        gr.Markdown("**Model Used** *(from Standard Analysis)*")
+                        agentic_model_display = gr.Textbox(
+                            label="Pose Model",
+                            interactive=False,
+                            value="No analysis completed yet"
+                        )
+                    
+                    # Right column - Analysis options and output
+                    with gr.Column(scale=1, min_width=400):
+                        gr.Markdown("**Analysis Type**")
+                        agentic_analysis_type = gr.Radio(
+                            choices=[
+                                ("🎯 SUMMARY", "summary"),
+                                ("📊 STRUCTURED", "structured"), 
+                                ("🔍 MOVEMENT FILTERS", "movement_filters")
+                            ],
+                            value="summary",
+                            label="Choose Analysis",
+                            info="Select the type of intelligent analysis"
+                        )
+                        
+                        # Movement filters options (shown when movement_filters is selected)
+                        with gr.Group(visible=False) as movement_filter_options:
+                            gr.Markdown("**Filter Criteria**")
+                            filter_direction = gr.Dropdown(
+                                choices=["any", "up", "down", "left", "right", "forward", "backward", "stationary"],
+                                value="any",
+                                label="Dominant Direction"
+                            )
+                            filter_intensity = gr.Dropdown(
+                                choices=["any", "low", "medium", "high"],
+                                value="any", 
+                                label="Movement Intensity"
+                            )
+                            filter_min_fluidity = gr.Slider(0.0, 1.0, 0.0, label="Minimum Fluidity Score")
+                            filter_min_expansion = gr.Slider(0.0, 1.0, 0.0, label="Minimum Expansion Score")
+                        
+                        analyze_agentic_btn = gr.Button("🚀 Generate Analysis", variant="primary", size="lg")
+                        
+                        # Output display
+                        with gr.Accordion("Analysis Results", open=True):
+                            agentic_output = gr.JSON(label="Intelligent Analysis Results")
+
+                # Show/hide movement filter options based on selection
+                def toggle_filter_options(analysis_type):
+                    return gr.Group(visible=(analysis_type == "movement_filters"))
+                
+                agentic_analysis_type.change(
+                    fn=toggle_filter_options,
+                    inputs=[agentic_analysis_type],
+                    outputs=[movement_filter_options]
+                )
+                
+                # Update video display when standard analysis completes
+                def update_agentic_video_display(video_input, url_input, model):
+                    """Update agentic tab with video and model from standard analysis."""
+                    video_source = video_input if video_input else url_input
+                    return video_source, f"Model: {model}"
+                
+                # Link to standard analysis inputs
+                video_in.change(
+                    fn=update_agentic_video_display,
+                    inputs=[video_in, url_input_enh, model_sel],
+                    outputs=[agentic_video_display, agentic_model_display]
+                )
+                
+                url_input_enh.change(
+                    fn=update_agentic_video_display,
+                    inputs=[video_in, url_input_enh, model_sel],
+                    outputs=[agentic_video_display, agentic_model_display]
+                )
+                
+                model_sel.change(
+                    fn=update_agentic_video_display,
+                    inputs=[video_in, url_input_enh, model_sel],
+                    outputs=[agentic_video_display, agentic_model_display]
+                )
+                
+                # Hook up the Generate Analysis button
+                def process_agentic_analysis(json_data, analysis_type, filter_direction, filter_intensity, filter_min_fluidity, filter_min_expansion):
+                    """Process agentic analysis based on user selection."""
+                    return generate_agentic_analysis(
+                        json_data, 
+                        analysis_type, 
+                        filter_direction, 
+                        filter_intensity, 
+                        filter_min_fluidity, 
+                        filter_min_expansion
+                    )
+                
+                analyze_agentic_btn.click(
+                    fn=process_agentic_analysis,
+                    inputs=[
+                        json_out,  # JSON data from standard analysis
+                        agentic_analysis_type,
+                        filter_direction,
+                        filter_intensity, 
+                        filter_min_fluidity,
+                        filter_min_expansion
+                    ],
+                    outputs=[agentic_output],
+                    api_name="analyze_agentic"
+                )
+                
+                # Auto-update agentic analysis when JSON changes and analysis type is summary
+                def auto_update_summary(json_data, analysis_type):
+                    """Auto-update with summary when new analysis is available."""
+                    if json_data and analysis_type == "summary":
+                        return generate_agentic_analysis(json_data, "summary")
+                    return None
+                
+                json_out.change(
+                    fn=auto_update_summary,
+                    inputs=[json_out, agentic_analysis_type],
+                    outputs=[agentic_output]
+                )
+
+            # Tab 4: About
+            with gr.Tab("ℹ️ About"):
+                gr.Markdown("""
+                # 🩰 Developer Journey: Laban Movement Analysis
+                
+                ## 🎯 Project Vision
+                
+                Created to bridge the gap between traditional **Laban Movement Analysis (LMA)** principles and modern **AI-powered pose estimation**, this platform represents a comprehensive approach to understanding human movement through technology.
+                
+                ## 🛠️ Technical Architecture
+                
+                ### **Core Foundation**
+                - **15 Pose Estimation Models** from diverse sources and frameworks
+                - **Multi-format Video Processing** with URL support (YouTube, Vimeo, direct links)
+                - **Real-time Analysis Pipeline** with configurable model selection
+                - **MCP-Compatible API** for AI agent integration
+                
+                ### **Pose Model Ecosystem**
+                ```
+                📊 MediaPipe Family (Google)     → 3 variants (lite/full/heavy)
+                ⚡ MoveNet Family (TensorFlow)   → 2 variants (lightning/thunder)  
+                🎯 YOLO v8 Family (Ultralytics) → 5 variants (n/s/m/l/x)
+                🔥 YOLO v11 Family (Ultralytics)→ 5 variants (n/s/m/l/x)
+                ```
+                
+                ## 🎨 Innovation Highlights
+                
+                ### **1. Custom Gradio Component: `gradio_overlay_video`**
+                - **Layered Visualization**: Controlled overlay of pose data on original video
+                - **Interactive Controls**: Frame-by-frame analysis with movement metrics
+                - **Synchronized Playback**: Real-time correlation between video and data
+                
+                ### **2. Agentic Analysis Engine**
+                Beyond raw pose detection, we've developed intelligent interpretation layers:
+                
+                - **🎯 SUMMARY**: Narrative movement interpretation with temporal pattern analysis
+                - **📊 STRUCTURED**: Comprehensive quantitative breakdowns with statistical insights
+                - **🔍 MOVEMENT FILTERS**: Advanced pattern detection with customizable criteria
+                
+                ### **3. Temporal Pattern Recognition**
+                - **Movement Consistency Tracking**: Direction and intensity variation analysis
+                - **Complexity Scoring**: Multi-dimensional movement sophistication metrics
+                - **Sequence Detection**: Continuous movement pattern identification
+                - **Laban Integration**: Professional movement quality assessment using LMA principles
+                
+                ## 📈 Processing Pipeline
+                
+                ```mermaid
+                Video Input → Pose Detection → LMA Analysis → JSON Output
+                     ↓              ↓              ↓           ↓
+                URL/Upload → 15 Models → Temporal → Visualization
+                     ↓              ↓        Patterns    ↓
+                Preprocessing → Keypoints → Metrics → Agentic Analysis
+                ```
+                
+                ## 🎭 Laban Movement Analysis Integration
+                
+                Our implementation translates raw pose coordinates into meaningful movement qualities:
+                
+                - **Effort Qualities**: Intensity, speed, and flow characteristics
+                - **Space Usage**: Expansion patterns and directional preferences  
+                - **Temporal Dynamics**: Rhythm, acceleration, and movement consistency
+                - **Quality Assessment**: Fluidity scores and movement sophistication
+                
+                ## 🔬 Technical Achievements
+                
+                ### **Multi-Source Model Integration**
+                Successfully unified models from different frameworks:
+                - Google's MediaPipe (BlazePose architecture)
+                - TensorFlow's MoveNet (lightweight and accurate variants)
+                - Ultralytics' YOLO ecosystem (object detection adapted for pose)
+                
+                ### **Real-Time Processing Capabilities**
+                - **Streaming Support**: Frame-by-frame processing with temporal continuity
+                - **Memory Optimization**: Efficient handling of large video files
+                - **Error Recovery**: Graceful handling of pose detection failures
+                
+                ### **Agent-Ready Architecture**
+                - **MCP Server Integration**: Compatible with AI agent workflows
+                - **Structured API**: RESTful endpoints for programmatic access
+                - **Flexible Output Formats**: JSON, visualization videos, and metadata
+                
+                ## 🌟 Future Roadmap
+                
+                - **3D Pose Integration**: Depth-aware movement analysis
+                - **Multi-Person Tracking**: Ensemble and group movement dynamics
+                - **Real-Time Streaming**: Live movement analysis capabilities
+                - **Machine Learning Enhancement**: Custom models trained on movement data
+                
+                ## 🔧 Built With
+                
+                - **Frontend**: Gradio 5.33+ with custom Svelte components
+                - **Backend**: Python with FastAPI and async processing
+                - **Computer Vision**: MediaPipe, TensorFlow, PyTorch, Ultralytics
+                - **Analysis**: NumPy, OpenCV, custom Laban algorithms
+                - **Deployment**: Hugging Face Spaces with Docker support
+                
+                ---
+                
+                ### 👨‍💻 Created by **Csaba Bolyós**
+                
+                *Combining classical movement analysis with cutting-edge AI to unlock new possibilities in human movement understanding.*
+                
+                **Connect:**  
+                [GitHub](https://github.com/bladeszasza) • [Hugging Face](https://huggingface.co/BladeSzaSza) • [LinkedIn](https://www.linkedin.com/in/csaba-bolyós-00a11767/)
+                
+                ---
+                
+                > *"Movement is a language. Technology helps us understand what the body is saying."*
+                """)
+         
         # 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) 

space.py

@@ -46,8 +46,8 @@ 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
 
 # Import agent API if available
 # Initialize agent API if available
@@ -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) 
 

src/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(/Users/csabi/.nvm/versions/node/v18.20.5/lib/node_modules/@anthropic-ai/claude-code/vendor/ripgrep/arm64-darwin/rg -n \"smooth_metrics\" /Users/csabi/Develop/Laban-Movement-Analysis/backend/gradio_labanmovementanalysis/notation_engine.py)",
+      "Bash(/Users/csabi/.nvm/versions/node/v18.20.5/lib/node_modules/@anthropic-ai/claude-code/vendor/ripgrep/arm64-darwin/rg -n \"_smooth_metrics\" /Users/csabi/Develop/Laban-Movement-Analysis/backend/gradio_labanmovementanalysis/notation_engine.py)",
+      "Bash(/Users/csabi/.nvm/versions/node/v18.20.5/lib/node_modules/@anthropic-ai/claude-code/vendor/ripgrep/arm64-darwin/rg -n \"# Footer\" /Users/csabi/Develop/Laban-Movement-Analysis/demo/app.py)",
+      "Bash(find:*)"
+    ],
+    "deny": []
+  }
+}

src/.gitignore

@@ -327,4 +327,7 @@ tb_logs/
 outputs/
 .hydra/ 
 
-.working/
+.working/
+
+# Claude Code project instructions
+CLAUDE.md

src/.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-----

src/README.md

@@ -1,6 +1,6 @@
 ---
 title: Laban Movement Analysis
-emoji: 🏃
+emoji: 🩰
 colorFrom: purple
 colorTo: green
 app_file: app.py
@@ -20,14 +20,43 @@ tags:
 - mediapipe
 - yolo
 - gradio
-short_description: Professional movement analysis with pose estimation and AI
+- agentic-analysis
+- overlay-video
+- temporal-patterns
+short_description: Laban Movement Analysis (LMA) from pose estimation
 license: apache-2.0
 ---
 
-# `gradio_labanmovementanalysis`
+# 🩰 Laban Movement Analysis
 <a href="https://pypi.org/project/gradio_labanmovementanalysis/" target="_blank"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/gradio_labanmovementanalysis"></a>  
 
-A Gradio 5 component for video movement analysis using Laban Movement Analysis (LMA) with MCP support for AI agents
+**Advanced video movement analysis platform** combining Laban Movement Analysis (LMA) principles with modern AI pose estimation, intelligent analysis, and interactive visualization.
+
+## 🌟 Key Features
+
+### 📊 **Multi-Model Pose Estimation** 
+- **15 different pose estimation models** from multiple sources:
+  - **MediaPipe**: `mediapipe-lite`, `mediapipe-full`, `mediapipe-heavy`
+  - **MoveNet**: `movenet-lightning`, `movenet-thunder`  
+  - **YOLO v8**: `yolo-v8-n/s/m/l/x` (5 variants)
+  - **YOLO v11**: `yolo-v11-n/s/m/l/x` (5 variants)
+
+### 🎥 **Comprehensive Video Processing**
+- **JSON Analysis Output**: Detailed movement metrics with temporal data
+- **Annotated Video Generation**: Pose overlay with Laban movement data
+- **URL Support**: Direct processing from YouTube, Vimeo, and video URLs
+- **Custom Overlay Component**: `gradio_overlay_video` for controlled layered visualization
+
+### 🤖 **Agentic Intelligence** 
+- **SUMMARY Analysis**: Narrative movement interpretation with temporal patterns
+- **STRUCTURED Analysis**: Quantitative breakdowns and statistical insights  
+- **MOVEMENT FILTERS**: Pattern detection with intelligent filtering
+- **Laban Interpretation**: Professional movement quality assessment
+
+### 🎨 **Interactive Visualization**
+- **Standard Analysis Tab**: Core pose estimation and LMA processing
+- **Overlay Visualization Tab**: Interactive layered video display
+- **Agentic Analysis Tab**: AI-powered movement insights and filtering
 
 ## Installation
 
@@ -46,8 +75,8 @@ 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
 
 # Import agent API if available
 # Initialize agent API if available
@@ -59,15 +88,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 +123,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 +163,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 +255,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) 
 

src/backend/gradio_labanmovementanalysis/agentic_analysis.py

@@ -0,0 +1,450 @@
+"""
+Agentic Analysis Module for Laban Movement Analysis
+
+This module provides intelligent analysis capabilities that go beyond raw pose detection
+to offer meaningful insights about movement patterns, quality, and characteristics.
+"""
+
+import numpy as np
+from collections import Counter
+from typing import Dict, List, Any, Optional
+
+
+def generate_agentic_analysis(
+    json_data: Dict[str, Any], 
+    analysis_type: str, 
+    filter_direction: str = "any", 
+    filter_intensity: str = "any", 
+    filter_min_fluidity: float = 0.0, 
+    filter_min_expansion: float = 0.0
+) -> Dict[str, Any]:
+    """
+    Generate intelligent analysis based on JSON data and selected type.
+    
+    Args:
+        json_data: Movement analysis data from pose estimation
+        analysis_type: Type of analysis ("summary", "structured", "movement_filters")
+        filter_direction: Direction filter for movement_filters analysis
+        filter_intensity: Intensity filter for movement_filters analysis
+        filter_min_fluidity: Minimum fluidity threshold for movement_filters
+        filter_min_expansion: Minimum expansion threshold for movement_filters
+        
+    Returns:
+        Dictionary containing analysis results or error information
+    """
+    if not json_data or "error" in json_data:
+        return {"error": "No valid analysis data available. Please run Standard Analysis first."}
+    
+    try:
+        # Extract movement data
+        if "movement_analysis" not in json_data or "frames" not in json_data["movement_analysis"]:
+            return {"error": "Invalid analysis format - missing movement data"}
+        
+        frames = json_data["movement_analysis"]["frames"]
+        video_info = json_data.get("video_info", {})
+        model_info = json_data.get("analysis_metadata", {}).get("model_info", {})
+        
+        if not frames:
+            return {"error": "No movement data found in analysis"}
+        
+        if analysis_type == "summary":
+            return generate_summary_analysis(frames, video_info, model_info)
+        elif analysis_type == "structured":
+            return generate_structured_analysis(frames, video_info, model_info)
+        elif analysis_type == "movement_filters":
+            return generate_movement_filter_analysis(
+                frames, video_info, model_info, 
+                filter_direction, filter_intensity, 
+                filter_min_fluidity, filter_min_expansion
+            )
+        else:
+            return {"error": "Unknown analysis type"}
+    
+    except Exception as e:
+        return {"error": f"Analysis failed: {str(e)}"}
+
+
+def generate_summary_analysis(frames: List[Dict], video_info: Dict, model_info: Dict) -> Dict[str, Any]:
+    """
+    Generate a comprehensive movement summary with temporal patterns.
+    
+    Args:
+        frames: List of frame analysis data
+        video_info: Video metadata
+        model_info: Model information
+        
+    Returns:
+        Dictionary containing summary analysis with narrative interpretation
+    """
+    # Extract metrics
+    directions = [f.get("metrics", {}).get("direction", "stationary") for f in frames]
+    intensities = [f.get("metrics", {}).get("intensity", "low") for f in frames]
+    speeds = [f.get("metrics", {}).get("speed", "slow") for f in frames]
+    velocities = [f.get("metrics", {}).get("velocity", 0) for f in frames]
+    accelerations = [f.get("metrics", {}).get("acceleration", 0) for f in frames]
+    fluidities = [f.get("metrics", {}).get("fluidity", 0) for f in frames]
+    expansions = [f.get("metrics", {}).get("expansion", 0) for f in frames]
+    
+    # Calculate dominant characteristics
+    dominant_direction = Counter(directions).most_common(1)[0][0]
+    dominant_intensity = Counter(intensities).most_common(1)[0][0]
+    dominant_speed = Counter(speeds).most_common(1)[0][0]
+    
+    # Calculate temporal patterns
+    direction_changes = sum(1 for i in range(1, len(directions)) if directions[i] != directions[i-1])
+    intensity_changes = sum(1 for i in range(1, len(intensities)) if intensities[i] != intensities[i-1])
+    
+    # Statistical analysis
+    avg_velocity = np.mean(velocities) if velocities else 0
+    max_velocity = np.max(velocities) if velocities else 0
+    avg_acceleration = np.mean(accelerations) if accelerations else 0
+    avg_fluidity = np.mean(fluidities) if fluidities else 0
+    avg_expansion = np.mean(expansions) if expansions else 0
+    
+    # Movement complexity score
+    complexity_score = (direction_changes / len(frames)) * 0.4 + (intensity_changes / len(frames)) * 0.3 + (avg_fluidity * 0.3)
+    
+    # Generate narrative summary
+    duration = video_info.get("duration_seconds", len(frames) / video_info.get("fps", 25))
+    
+    return {
+        "analysis_type": "Movement Summary",
+        "model_used": model_info.get("name", "unknown"),
+        "video_duration": f"{duration:.1f} seconds",
+        "total_frames": len(frames),
+        
+        "dominant_characteristics": {
+            "primary_direction": dominant_direction,
+            "primary_intensity": dominant_intensity,
+            "primary_speed": dominant_speed
+        },
+        
+        "temporal_patterns": {
+            "direction_transitions": direction_changes,
+            "intensity_variations": intensity_changes,
+            "movement_consistency": f"{(1 - direction_changes/len(frames))*100:.1f}%",
+            "complexity_score": f"{complexity_score:.3f}"
+        },
+        
+        "movement_quality": {
+            "average_fluidity": f"{avg_fluidity:.3f}",
+            "average_expansion": f"{avg_expansion:.3f}",
+            "peak_velocity": f"{max_velocity:.3f}",
+            "average_velocity": f"{avg_velocity:.3f}"
+        },
+        
+        "narrative_summary": f"This {duration:.1f}-second movement sequence shows predominantly {dominant_direction} movement with {dominant_intensity} intensity. "
+                           f"The performer demonstrates {direction_changes} directional changes and {intensity_changes} intensity variations, "
+                           f"indicating a {'complex' if complexity_score > 0.3 else 'simple'} movement pattern. "
+                           f"Movement quality shows {avg_fluidity:.2f} fluidity and {avg_expansion:.2f} spatial expansion, "
+                           f"suggesting {'expressive' if avg_expansion > 0.5 else 'contained'} movement vocabulary.",
+        
+        "laban_interpretation": {
+            "effort_qualities": f"Primary effort: {dominant_intensity} intensity with {dominant_speed} timing",
+            "space_usage": f"{'Expansive' if avg_expansion > 0.5 else 'Contracted'} spatial patterns",
+            "flow_quality": f"{'Bound' if avg_fluidity < 0.3 else 'Free' if avg_fluidity > 0.7 else 'Balanced'} flow"
+        }
+    }
+
+
+def generate_structured_analysis(frames: List[Dict], video_info: Dict, model_info: Dict) -> Dict[str, Any]:
+    """
+    Generate detailed structured analysis with metrics breakdown.
+    
+    Args:
+        frames: List of frame analysis data
+        video_info: Video metadata
+        model_info: Model information
+        
+    Returns:
+        Dictionary containing detailed quantitative analysis
+    """
+    # Extract all metrics
+    directions = [f.get("metrics", {}).get("direction", "stationary") for f in frames]
+    intensities = [f.get("metrics", {}).get("intensity", "low") for f in frames]
+    speeds = [f.get("metrics", {}).get("speed", "slow") for f in frames]
+    velocities = [f.get("metrics", {}).get("velocity", 0) for f in frames]
+    accelerations = [f.get("metrics", {}).get("acceleration", 0) for f in frames]
+    fluidities = [f.get("metrics", {}).get("fluidity", 0) for f in frames]
+    expansions = [f.get("metrics", {}).get("expansion", 0) for f in frames]
+    
+    # Direction analysis
+    direction_stats = Counter(directions)
+    direction_percentages = {k: (v/len(frames))*100 for k, v in direction_stats.items()}
+    
+    # Intensity analysis  
+    intensity_stats = Counter(intensities)
+    intensity_percentages = {k: (v/len(frames))*100 for k, v in intensity_stats.items()}
+    
+    # Speed analysis
+    speed_stats = Counter(speeds)
+    speed_percentages = {k: (v/len(frames))*100 for k, v in speed_stats.items()}
+    
+    # Temporal segmentation (divide into segments)
+    segment_size = max(1, len(frames) // 8)  # 8 segments
+    segments = []
+    for i in range(0, len(frames), segment_size):
+        segment_frames = frames[i:i+segment_size]
+        if segment_frames:
+            seg_directions = [f.get("metrics", {}).get("direction", "stationary") for f in segment_frames]
+            seg_intensities = [f.get("metrics", {}).get("intensity", "low") for f in segment_frames]
+            seg_fluidities = [f.get("metrics", {}).get("fluidity", 0) for f in segment_frames]
+            
+            segments.append({
+                "segment_index": len(segments) + 1,
+                "time_range": f"{i/video_info.get('fps', 25):.1f}-{(i+len(segment_frames))/video_info.get('fps', 25):.1f}s",
+                "dominant_direction": Counter(seg_directions).most_common(1)[0][0],
+                "dominant_intensity": Counter(seg_intensities).most_common(1)[0][0],
+                "average_fluidity": np.mean(seg_fluidities) if seg_fluidities else 0
+            })
+    
+    return {
+        "analysis_type": "Structured Analysis",
+        "model_used": model_info.get("name", "unknown"),
+        "video_info": {
+            "duration": video_info.get("duration_seconds", 0),
+            "fps": video_info.get("fps", 0),
+            "resolution": f"{video_info.get('width', 0)}x{video_info.get('height', 0)}",
+            "total_frames": len(frames)
+        },
+        
+        "direction_breakdown": {
+            "statistics": dict(direction_stats),
+            "percentages": {k: f"{v:.1f}%" for k, v in direction_percentages.items()},
+            "most_common": direction_stats.most_common(3)
+        },
+        
+        "intensity_breakdown": {
+            "statistics": dict(intensity_stats),
+            "percentages": {k: f"{v:.1f}%" for k, v in intensity_percentages.items()},
+            "distribution": intensity_stats.most_common()
+        },
+        
+        "speed_breakdown": {
+            "statistics": dict(speed_stats),
+            "percentages": {k: f"{v:.1f}%" for k, v in speed_percentages.items()},
+            "distribution": speed_stats.most_common()
+        },
+        
+        "quantitative_metrics": {
+            "velocity": {
+                "mean": f"{np.mean(velocities):.4f}",
+                "std": f"{np.std(velocities):.4f}",
+                "min": f"{np.min(velocities):.4f}",
+                "max": f"{np.max(velocities):.4f}"
+            },
+            "acceleration": {
+                "mean": f"{np.mean(accelerations):.4f}",
+                "std": f"{np.std(accelerations):.4f}",
+                "min": f"{np.min(accelerations):.4f}",
+                "max": f"{np.max(accelerations):.4f}"
+            },
+            "fluidity": {
+                "mean": f"{np.mean(fluidities):.4f}",
+                "std": f"{np.std(fluidities):.4f}",
+                "min": f"{np.min(fluidities):.4f}",
+                "max": f"{np.max(fluidities):.4f}"
+            },
+            "expansion": {
+                "mean": f"{np.mean(expansions):.4f}",
+                "std": f"{np.std(expansions):.4f}",
+                "min": f"{np.min(expansions):.4f}",
+                "max": f"{np.max(expansions):.4f}"
+            }
+        },
+        
+        "temporal_segments": segments,
+        
+        "movement_patterns": {
+            "consistency_index": f"{1 - (len(set(directions))/len(frames)):.3f}",
+            "dynamic_range": f"{np.max(velocities) - np.min(velocities):.4f}",
+            "complexity_score": f"{len(set(directions)) * len(set(intensities)) / len(frames):.3f}"
+        }
+    }
+
+
+def generate_movement_filter_analysis(
+    frames: List[Dict], 
+    video_info: Dict, 
+    model_info: Dict, 
+    filter_direction: str, 
+    filter_intensity: str, 
+    filter_min_fluidity: float, 
+    filter_min_expansion: float
+) -> Dict[str, Any]:
+    """
+    Generate movement filter analysis with pattern detection.
+    
+    Args:
+        frames: List of frame analysis data
+        video_info: Video metadata
+        model_info: Model information
+        filter_direction: Direction filter criteria
+        filter_intensity: Intensity filter criteria
+        filter_min_fluidity: Minimum fluidity threshold
+        filter_min_expansion: Minimum expansion threshold
+        
+    Returns:
+        Dictionary containing filter analysis results and recommendations
+    """
+    # Apply filters
+    matching_frames = []
+    total_frames = len(frames)
+    
+    for frame in frames:
+        metrics = frame.get("metrics", {})
+        direction = metrics.get("direction", "stationary")
+        intensity = metrics.get("intensity", "low")
+        fluidity = metrics.get("fluidity", 0)
+        expansion = metrics.get("expansion", 0)
+        
+        # Check filters
+        direction_match = filter_direction == "any" or direction == filter_direction
+        intensity_match = filter_intensity == "any" or intensity == filter_intensity
+        fluidity_match = fluidity >= filter_min_fluidity
+        expansion_match = expansion >= filter_min_expansion
+        
+        if direction_match and intensity_match and fluidity_match and expansion_match:
+            matching_frames.append(frame)
+    
+    match_percentage = (len(matching_frames) / total_frames) * 100 if total_frames > 0 else 0
+    
+    # Pattern detection in matching frames
+    if matching_frames:
+        match_velocities = [f.get("metrics", {}).get("velocity", 0) for f in matching_frames]
+        match_accelerations = [f.get("metrics", {}).get("acceleration", 0) for f in matching_frames]
+        
+        # Find continuous sequences
+        frame_indices = [f.get("frame_index", 0) for f in matching_frames]
+        sequences = []
+        if frame_indices:
+            current_seq = [frame_indices[0]]
+            for i in range(1, len(frame_indices)):
+                if frame_indices[i] == frame_indices[i-1] + 1:
+                    current_seq.append(frame_indices[i])
+                else:
+                    if len(current_seq) > 1:
+                        sequences.append(current_seq)
+                    current_seq = [frame_indices[i]]
+            if len(current_seq) > 1:
+                sequences.append(current_seq)
+        
+        longest_sequence = max(sequences, key=len) if sequences else []
+        
+        pattern_analysis = {
+            "total_matching_frames": len(matching_frames),
+            "match_percentage": f"{match_percentage:.1f}%",
+            "continuous_sequences": len(sequences),
+            "longest_sequence": {
+                "length": len(longest_sequence),
+                "start_frame": longest_sequence[0] if longest_sequence else 0,
+                "end_frame": longest_sequence[-1] if longest_sequence else 0,
+                "duration": f"{len(longest_sequence) / video_info.get('fps', 25):.2f}s" if longest_sequence else "0s"
+            },
+            "velocity_in_matches": {
+                "mean": f"{np.mean(match_velocities):.4f}" if match_velocities else "0",
+                "peak": f"{np.max(match_velocities):.4f}" if match_velocities else "0"
+            }
+        }
+    else:
+        pattern_analysis = {
+            "total_matching_frames": 0,
+            "match_percentage": "0%",
+            "message": "No frames match the specified criteria"
+        }
+    
+    return {
+        "analysis_type": "Movement Filter Analysis",
+        "model_used": model_info.get("name", "unknown"),
+        "filter_criteria": {
+            "direction": filter_direction,
+            "intensity": filter_intensity,
+            "min_fluidity": filter_min_fluidity,
+            "min_expansion": filter_min_expansion
+        },
+        "results": pattern_analysis,
+        "recommendations": generate_filter_recommendations(matching_frames, total_frames, filter_direction, filter_intensity)
+    }
+
+
+def generate_filter_recommendations(matching_frames: List[Dict], total_frames: int, filter_direction: str, filter_intensity: str) -> str:
+    """
+    Generate recommendations based on filter results.
+    
+    Args:
+        matching_frames: List of frames that match filter criteria
+        total_frames: Total number of frames analyzed
+        filter_direction: Applied direction filter
+        filter_intensity: Applied intensity filter
+        
+    Returns:
+        String containing intelligent recommendations
+    """
+    match_ratio = len(matching_frames) / total_frames if total_frames > 0 else 0
+    
+    if match_ratio > 0.7:
+        return f"Strong pattern detected: {match_ratio*100:.1f}% of movement matches your criteria. This suggests consistent {filter_direction} movement with {filter_intensity} intensity."
+    elif match_ratio > 0.3:
+        return f"Moderate pattern: {match_ratio*100:.1f}% match suggests intermittent {filter_direction} movement patterns. Consider analyzing temporal distribution."
+    elif match_ratio > 0.1:
+        return f"Weak pattern: Only {match_ratio*100:.1f}% match. The movement may be more varied than your filter criteria suggest."
+    else:
+        return f"No significant pattern found ({match_ratio*100:.1f}% match). Consider broadening filter criteria or analyzing different movement qualities."
+
+
+def process_standard_for_agent(json_data: Dict[str, Any], output_format: str = "summary") -> Dict[str, Any]:
+    """
+    Convert standard analysis JSON to agent format.
+    
+    Args:
+        json_data: Standard movement analysis data
+        output_format: Desired output format ("summary", "structured", "json")
+        
+    Returns:
+        Dictionary containing converted analysis in agent format
+    """
+    if not json_data or "error" in json_data:
+        return json_data
+    
+    try:
+        # Extract key metrics from standard analysis
+        if "movement_analysis" in json_data and "frames" in json_data["movement_analysis"]:
+            frames = json_data["movement_analysis"]["frames"]
+            if not frames:
+                return {"error": "No movement data found"}
+            
+            # Compute dominant characteristics
+            directions = [f.get("metrics", {}).get("direction", "stationary") for f in frames]
+            intensities = [f.get("metrics", {}).get("intensity", "low") for f in frames]
+            speeds = [f.get("metrics", {}).get("speed", "slow") for f in frames]
+            fluidities = [f.get("metrics", {}).get("fluidity", 0.0) for f in frames]
+            expansions = [f.get("metrics", {}).get("expansion", 0.5) for f in frames]
+            
+            # Find dominant values
+            dominant_direction = Counter(directions).most_common(1)[0][0]
+            dominant_intensity = Counter(intensities).most_common(1)[0][0]
+            dominant_speed = Counter(speeds).most_common(1)[0][0]
+            avg_fluidity = sum(fluidities) / len(fluidities) if fluidities else 0.0
+            avg_expansion = sum(expansions) / len(expansions) if expansions else 0.5
+            
+            if output_format == "summary":
+                return {
+                    "summary": f"Movement Analysis: Predominantly {dominant_direction} direction with {dominant_intensity} intensity. "
+                              f"Speed: {dominant_speed}. Fluidity: {avg_fluidity:.2f}, Expansion: {avg_expansion:.2f}"
+                }
+            elif output_format == "structured":
+                return {
+                    "success": True,
+                    "direction": dominant_direction,
+                    "intensity": dominant_intensity,
+                    "speed": dominant_speed,
+                    "fluidity": avg_fluidity,
+                    "expansion": avg_expansion,
+                    "segments": len(frames)
+                }
+            else:  # json
+                return json_data
+        
+        return {"error": "Invalid analysis format"}
+    except Exception as e:
+        return {"error": f"Conversion failed: {str(e)}"}

src/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() 

src/backend/gradio_labanmovementanalysis/labanmovementanalysis.pyi

@@ -16,18 +16,13 @@ from .json_generator import generate_json, format_for_display
 from .visualizer import PoseVisualizer
 from .video_downloader import SmartVideoInput
 
-# Optional advanced features
-try:
-    from .skateformer_integration import SkateFormerAnalyzer
-    HAS_SKATEFORMER = True
-except ImportError:
-    HAS_SKATEFORMER = False
+# Advanced features reserved for Version 2
+# SkateFormer AI integration will be available in future release
 
-try:
-    from .webrtc_handler import WebRTCMovementAnalyzer, WebRTCGradioInterface
-    HAS_WEBRTC = True
-except ImportError:
-    HAS_WEBRTC = False
+
+
+# SkateFormerCompatibility class removed for Version 1 stability
+# Will be reimplemented in Version 2 with enhanced AI features
 
 from gradio.events import Dependency
 
@@ -44,7 +39,7 @@ class LabanMovementAnalysis(Component):
                  default_model: str = DEFAULT_MODEL,
                  enable_visualization: bool = True,
                  include_keypoints: bool = False,
-                 enable_webrtc: bool = False,
+
                  label: Optional[str] = None,
                  every: Optional[float] = None,
                  show_label: Optional[bool] = None,
@@ -57,6 +52,7 @@ class LabanMovementAnalysis(Component):
                  elem_classes: Optional[List[str]] = None,
                  render: bool = True,
                  **kwargs):
+        # print("[TRACE] LabanMovementAnalysis.__init__ called")
         """
         Initialize the Laban Movement Analysis component.
         
@@ -64,7 +60,7 @@ class LabanMovementAnalysis(Component):
             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
-            enable_webrtc: Whether to enable WebRTC real-time analysis
+
             label: Component label
             ... (other standard Gradio component args)
         """
@@ -86,8 +82,6 @@ class LabanMovementAnalysis(Component):
         self.default_model = default_model
         self.enable_visualization = enable_visualization
         self.include_keypoints = include_keypoints
-        self.enable_webrtc = enable_webrtc and HAS_WEBRTC
-        
         # Cache for pose estimators
         self._estimators = {}
         
@@ -95,16 +89,9 @@ class LabanMovementAnalysis(Component):
         self.video_input = SmartVideoInput()
         
         # SkateFormer features reserved for Version 2
-        
-        self.webrtc_analyzer = None
-        if self.enable_webrtc:
-            try:
-                self.webrtc_analyzer = WebRTCMovementAnalyzer(model=default_model)
-            except Exception as e:
-                print(f"Warning: Failed to initialize WebRTC: {e}")
-                self.enable_webrtc = False
     
     def preprocess(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        # print("[TRACE] LabanMovementAnalysis.preprocess called")
         """
         Preprocess input from the frontend.
         
@@ -142,6 +129,7 @@ class LabanMovementAnalysis(Component):
         return options
     
     def postprocess(self, value: Any) -> Dict[str, Any]:
+        # print("[TRACE] LabanMovementAnalysis.postprocess called")
         """
         Postprocess analysis results for the frontend.
         
@@ -169,6 +157,7 @@ class LabanMovementAnalysis(Component):
     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.
         
@@ -282,6 +271,7 @@ class LabanMovementAnalysis(Component):
         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.
         
@@ -294,77 +284,39 @@ class LabanMovementAnalysis(Component):
         """
         return self.process_video(video_path, **kwargs)
     
-    def start_webrtc_stream(self, model: str = None) -> bool:
+    def process(self, video_input: Union[str, os.PathLike], model: str = DEFAULT_MODEL, include_keypoints: bool = False) -> Dict[str, Any]:
         """
-        Start WebRTC real-time analysis stream.
-        
+        Processes a video and returns only the JSON analysis result.
+
         Args:
-            model: Pose model to use for real-time analysis
-            
-        Returns:
-            True if stream started successfully
-        """
-        if not self.enable_webrtc or not self.webrtc_analyzer:
-            print("WebRTC not enabled or available")
-            return False
-            
-        try:
-            if model:
-                self.webrtc_analyzer.model = model
-                self.webrtc_analyzer.pose_estimator = get_pose_estimator(model)
-            
-            self.webrtc_analyzer.start_stream()
-            print(f"WebRTC stream started with {self.webrtc_analyzer.model} model")
-            return True
-        except Exception as e:
-            print(f"Failed to start WebRTC stream: {e}")
-            return False
-    
-    def stop_webrtc_stream(self) -> bool:
-        """
-        Stop WebRTC real-time analysis stream.
-        
-        Returns:
-            True if stream stopped successfully
-        """
-        if not self.webrtc_analyzer:
-            return False
-            
-        try:
-            self.webrtc_analyzer.stop_stream()
-            print("WebRTC stream stopped")
-            return True
-        except Exception as e:
-            print(f"Failed to stop WebRTC stream: {e}")
-            return False
-    
-    def get_webrtc_interface(self):
-        """
-        Get WebRTC Gradio interface for real-time streaming.
-        
+            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:
-            WebRTCGradioInterface instance or None
+            dict: Movement analysis results in JSON format
         """
-        if not self.enable_webrtc or not self.webrtc_analyzer:
-            return None
-            
-        return WebRTCGradioInterface(self.webrtc_analyzer)
+        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()
-        
-        # Stop WebRTC if running
-        if self.webrtc_analyzer and self.webrtc_analyzer.is_running:
-            self.stop_webrtc_stream()
     
     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"},
@@ -374,6 +326,7 @@ class LabanMovementAnalysis(Component):
         }
     
     def example_value(self) -> Dict[str, Any]:
+        # print("[TRACE] LabanMovementAnalysis.example_value called")
         """Example output value for documentation."""
         return {
             "json_output": {
@@ -422,6 +375,7 @@ class LabanMovementAnalysis(Component):
         }
     
     def api_info(self) -> Dict[str, Any]:
+        # print("[TRACE] LabanMovementAnalysis.api_info called")
         """API information for the component."""
         return {
             "type": "composite",

src/backend/gradio_labanmovementanalysis/notation_engine.py

@@ -60,74 +60,169 @@ class MovementMetrics:
     total_displacement: float = 0.0
 
 
+class SimpleKalmanFilter:
+    """Lightweight Kalman filter for position/velocity tracking."""
+    
+    def __init__(self, process_noise: float = 0.01, measurement_noise: float = 0.1):
+        self.process_noise = process_noise
+        self.measurement_noise = measurement_noise
+        self.is_initialized = False
+        
+        # State: [x, y, vx, vy]
+        self.state = np.zeros(4)
+        self.covariance = np.eye(4) * 0.1
+        
+        # Transition matrix (constant velocity model)
+        self.F = np.array([[1, 0, 1, 0],
+                          [0, 1, 0, 1],
+                          [0, 0, 1, 0],
+                          [0, 0, 0, 1]])
+        
+        # Measurement matrix (observe position only)
+        self.H = np.array([[1, 0, 0, 0],
+                          [0, 1, 0, 0]])
+        
+        # Process noise matrix
+        self.Q = np.eye(4) * process_noise
+        
+        # Measurement noise matrix
+        self.R = np.eye(2) * measurement_noise
+    
+    def predict(self, dt: float = 1.0):
+        """Predict next state."""
+        # Update transition matrix with time step
+        self.F[0, 2] = dt
+        self.F[1, 3] = dt
+        
+        # Predict state
+        self.state = self.F @ self.state
+        self.covariance = self.F @ self.covariance @ self.F.T + self.Q
+    
+    def update(self, measurement: Tuple[float, float]):
+        """Update with measurement."""
+        z = np.array([measurement[0], measurement[1]])
+        
+        if not self.is_initialized:
+            self.state[:2] = z
+            self.is_initialized = True
+            return
+        
+        # Calculate Kalman gain
+        S = self.H @ self.covariance @ self.H.T + self.R
+        K = self.covariance @ self.H.T @ np.linalg.inv(S)
+        
+        # Update state
+        y = z - self.H @ self.state
+        self.state = self.state + K @ y
+        self.covariance = (np.eye(4) - K @ self.H) @ self.covariance
+    
+    def get_position(self) -> Tuple[float, float]:
+        """Get filtered position."""
+        return (self.state[0], self.state[1])
+    
+    def get_velocity(self) -> Tuple[float, float]:
+        """Get filtered velocity."""
+        return (self.state[2], self.state[3])
+
+
 class MovementAnalyzer:
     """Analyzes pose sequences to extract LMA-style movement metrics."""
     
     def __init__(self, fps: float = 30.0, 
-                 velocity_threshold_slow: float = 0.01, # Normalized units / sec
-                 velocity_threshold_fast: float = 0.1,  # Normalized units / sec
-                 intensity_accel_threshold: float = 0.05): # Normalized units / sec^2
+                 velocity_threshold_slow: float = 0.01,
+                 velocity_threshold_fast: float = 0.1,
+                 intensity_accel_threshold: float = 0.05,
+                 use_kalman_filter: bool = True,
+                 use_adaptive_thresholds: bool = True):
         """
-        Initialize movement analyzer.
+        Initialize movement analyzer with advanced features.
         
         Args:
             fps: Frames per second of the video
-            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)
+            velocity_threshold_slow: Initial threshold for slow movement
+            velocity_threshold_fast: Initial threshold for fast movement  
+            intensity_accel_threshold: Initial acceleration threshold for intensity
+            use_kalman_filter: Whether to use Kalman filtering for tracking
+            use_adaptive_thresholds: Whether to adapt thresholds based on video content
         """
         self.fps = 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
+        self.use_kalman_filter = use_kalman_filter
+        self.use_adaptive_thresholds = use_adaptive_thresholds
+        
+        # Kalman filter for tracking
+        self.kalman_filter = SimpleKalmanFilter() if use_kalman_filter else None
+        
+        # Adaptive threshold parameters
+        self.adaptive_thresholds_computed = False
     
     def analyze_movement(self, pose_sequence: List[List[PoseResult]]) -> List[MovementMetrics]:
         """
         Analyze a sequence of poses to compute movement metrics.
         
         Args:
-            pose_sequence: List of pose results per frame. Each inner list contains PoseResult
-                           objects for detected persons in that 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 (analyzing the first detected person only).
+            List of movement metrics per frame (currently for the first detected person).
         """
         if not pose_sequence:
             return []
         
         metrics = []
-        prev_center_for_person = None # Tracks the center of the first person from the previous frame
-        prev_velocity_for_person = None # Tracks the velocity of the first person from the previous frame
+        # 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):
-            current_timestamp = frame_idx * self.frame_duration if self.frame_duration else None
-
-            if not frame_poses or not frame_poses[0].keypoints:
-                # No pose detected, or first pose has no keypoints
+            if not frame_poses:
+                # No pose detected in this frame
                 metrics.append(MovementMetrics(
                     frame_index=frame_idx,
-                    timestamp=current_timestamp
+                    timestamp=frame_idx * self.frame_duration if self.frame_duration else None
                 ))
-                # Reset tracking for the next frame where a person might appear
-                prev_center_for_person = None
-                prev_velocity_for_person = None
                 continue
             
-            # Focus on the first detected person
-            pose = frame_poses[0]
+            # --- 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 confidence-weighted body center
+            center = self._compute_body_center_weighted(pose.keypoints)
             
-            center = self._compute_body_center(pose.keypoints)
+            # Apply Kalman filtering if enabled
+            if self.kalman_filter:
+                self.kalman_filter.predict(self.frame_duration)
+                self.kalman_filter.update(center)
+                center = self.kalman_filter.get_position()
             
+            # Initialize metrics for this frame
             frame_metrics = MovementMetrics(
                 frame_index=frame_idx,
-                timestamp=current_timestamp
+                timestamp=frame_idx * self.frame_duration if self.frame_duration else None
             )
             
-            if prev_center_for_person is not None and frame_idx > 0 and self.fps > 0:
+            # 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_center_for_person[0],
-                    center[1] - prev_center_for_person[1]
+                    center[0] - prev_centers[0],
+                    center[1] - prev_centers[1]
                 )
                 frame_metrics.center_displacement = displacement
                 frame_metrics.total_displacement = np.sqrt(
@@ -138,9 +233,10 @@ class MovementAnalyzer:
                 frame_metrics.direction = self._compute_direction(displacement)
                 frame_metrics.speed = self._categorize_speed(frame_metrics.velocity)
                 
-                if prev_velocity_for_person is not None:
-                    delta_velocity = frame_metrics.velocity - prev_velocity_for_person
-                    frame_metrics.acceleration = delta_velocity * self.fps
+                if prev_velocity is not None:
+                    # 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,
@@ -153,13 +249,47 @@ class MovementAnalyzer:
             frame_metrics.expansion = self._compute_expansion(pose.keypoints)
             metrics.append(frame_metrics)
             
-            # Update for the next iteration, specifically for the first person
-            prev_center_for_person = center
-            prev_velocity_for_person = frame_metrics.velocity
+            # Update for next iteration (for the currently tracked person)
+            prev_centers = center
+            prev_velocity = frame_metrics.velocity
+        
+        # Apply adaptive thresholds if enabled
+        if self.use_adaptive_thresholds and not self.adaptive_thresholds_computed:
+            self._compute_adaptive_thresholds(metrics)
+            # Recompute speed and intensity with new thresholds
+            metrics = self._recompute_with_adaptive_thresholds(metrics)
         
         metrics = self._smooth_metrics(metrics)
         return metrics
     
+    def _compute_body_center_weighted(self, keypoints: List[Keypoint]) -> Tuple[float, float]:
+        """Compute confidence-weighted center of mass of the body."""
+        major_joints = ["left_hip", "right_hip", "left_shoulder", "right_shoulder"]
+        
+        weighted_x = 0.0
+        weighted_y = 0.0
+        total_weight = 0.0
+        
+        for kp in keypoints:
+            if kp.name in major_joints and kp.confidence > 0.5:
+                weight = kp.confidence
+                weighted_x += kp.x * weight
+                weighted_y += kp.y * weight
+                total_weight += weight
+        
+        # Fallback to all keypoints if no major joints found
+        if total_weight == 0:
+            for kp in keypoints:
+                if kp.confidence > 0.3:
+                    weight = kp.confidence
+                    weighted_x += kp.x * weight
+                    weighted_y += kp.y * weight
+                    total_weight += weight
+        
+        if total_weight > 0:
+            return (weighted_x / total_weight, weighted_y / total_weight)
+        return (0.5, 0.5)
+    
     def _compute_body_center(self, keypoints: List[Keypoint]) -> Tuple[float, float]:
         """Compute the center of mass of the body."""
         major_joints = ["left_hip", "right_hip", "left_shoulder", "right_shoulder"]
@@ -168,20 +298,20 @@ class MovementAnalyzer:
         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 or not y_coords:
+        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 and y_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)
+        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 and kp.name:
@@ -191,7 +321,7 @@ class MovementAnalyzer:
     def _compute_direction(self, displacement: Tuple[float, float]) -> Direction:
         """Compute movement direction from displacement vector."""
         dx, dy = displacement
-        threshold = 0.005 
+        threshold = 0.005 # Normalized units per frame
         
         if abs(dx) < threshold and abs(dy) < threshold:
             return Direction.STATIONARY
@@ -199,22 +329,23 @@ class MovementAnalyzer:
         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 (velocity is in normalized units/sec)."""
         if velocity < self.velocity_threshold_slow:
             return Speed.SLOW
         elif velocity < self.velocity_threshold_fast:
-            return Speed.MODERATE 
+            return Speed.MODERATE # Corrected from Speed.FAST
         else:
             return Speed.FAST
     
     def _compute_intensity(self, acceleration: float, velocity: float) -> Intensity:
         """Compute movement intensity (accel in norm_units/sec^2, vel in norm_units/sec)."""
-        if abs(acceleration) > self.intensity_accel_threshold * 2 or velocity > self.velocity_threshold_fast:
+        # 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 abs(acceleration) > self.intensity_accel_threshold or velocity > self.velocity_threshold_slow:
+        elif acceleration > self.intensity_accel_threshold or velocity > self.velocity_threshold_slow:
             return Intensity.MEDIUM
         else:
             return Intensity.LOW
@@ -224,7 +355,8 @@ class MovementAnalyzer:
         Compute fluidity score (0-1) based on acceleration (norm_units/sec^2).
         Lower acceleration = higher fluidity.
         """
-        max_expected_accel = 0.2 
+        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
     
@@ -238,26 +370,54 @@ class MovementAnalyzer:
             ("left_ankle", "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 and kp.name}
-        if not kp_dict: return 0.5
+        if not kp_dict: return 0.5 # No reliable keypoints
 
         distances = []
         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:
             avg_dist = np.mean(distances)
-            max_possible_dist_heuristic = 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
+        return 0.5  # Default neutral expansion if no valid pairs
+    
+    def _compute_adaptive_thresholds(self, metrics: List[MovementMetrics]):
+        """Compute adaptive thresholds based on movement characteristics in the video."""
+        velocities = [m.velocity for m in metrics if m.velocity > 0]
+        accelerations = [abs(m.acceleration) for m in metrics if m.acceleration != 0]
+        
+        if velocities:
+            velocity_percentiles = np.percentile(velocities, [25, 75])
+            self.velocity_threshold_slow = max(velocity_percentiles[0], 0.005)
+            self.velocity_threshold_fast = velocity_percentiles[1]
+        
+        if accelerations:
+            accel_75th = np.percentile(accelerations, 75)
+            self.intensity_accel_threshold = max(accel_75th * 0.5, 0.01)
+        
+        self.adaptive_thresholds_computed = True
+    
+    def _recompute_with_adaptive_thresholds(self, metrics: List[MovementMetrics]) -> List[MovementMetrics]:
+        """Recompute speed and intensity classifications with adaptive thresholds."""
+        for metric in metrics:
+            if metric.velocity > 0:
+                metric.speed = self._categorize_speed(metric.velocity)
+                metric.intensity = self._compute_intensity(metric.acceleration, metric.velocity)
+        return metrics
     
     def _smooth_metrics(self, metrics_list: List[MovementMetrics]) -> List[MovementMetrics]:
         """Apply smoothing to reduce noise in metrics using a simple moving average."""
@@ -267,8 +427,9 @@ class MovementAnalyzer:
         if num_metrics <= window_size:
             return metrics_list
 
-        smoothed_metrics_list = 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):

src/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

src/demo/app.py

@@ -3,11 +3,12 @@
 Laban Movement Analysis – modernised Gradio Space
 Author: Csaba (BladeSzaSza)
 """
-
 import gradio as gr
 import os
+from pathlib import Path
+# from backend.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,14 +20,11 @@ try:
         MovementDirection,
         MovementIntensity
     )
+    agent_api = LabanAgentAPI()
     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:
+except Exception as e:
+    print(f"Warning: Agent API not available: {e}")
+    agent_api = None
     HAS_AGENT_API = False
 # Initialize components
 try:
@@ -59,21 +57,86 @@ 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
+        return json_output
+    except (RuntimeError, ValueError, OSError) as e:
+        return {"error": str(e)}
+
+def process_video_for_agent(video, model, output_format="summary"):
+    """Process video with agent-friendly output format."""
+    if not HAS_AGENT_API or agent_api is None:
+        return {"error": "Agent API not available"}
+    
+    if not video:
+        return {"error": "No video provided"}
+    
+    try:
+        model_enum = PoseModel(model)
+        result = agent_api.analyze(video, model=model_enum, generate_visualization=False)
+        
+        if output_format == "summary":
+            return {"summary": agent_api.get_movement_summary(result)}
+        elif output_format == "structured":
+            return {
+                "success": result.success,
+                "direction": result.dominant_direction.value,
+                "intensity": result.dominant_intensity.value,
+                "speed": result.dominant_speed,
+                "fluidity": result.fluidity_score,
+                "expansion": result.expansion_score,
+                "segments": len(result.movement_segments)
+            }
+        else:  # json
+            return result.raw_data
     except Exception as e:
-        return {"error": str(e)}, None
+        return {"error": str(e)}
+
+# Batch processing removed due to MediaPipe compatibility issues
+
+# process_standard_for_agent is now imported from backend
+
+# Movement filtering removed due to MediaPipe compatibility issues
+
+# Import agentic analysis functions from backend
+try:
+    from gradio_labanmovementanalysis.agentic_analysis import (
+        generate_agentic_analysis,
+        process_standard_for_agent
+    )
+except ImportError:
+    # Fallback if backend module is not available
+    def generate_agentic_analysis(json_data, analysis_type, filter_direction="any", filter_intensity="any", filter_min_fluidity=0.0, filter_min_expansion=0.0):
+        return {"error": "Agentic analysis backend not available"}
+    
+    def process_standard_for_agent(json_data, output_format="summary"):
+        return {"error": "Agent conversion backend not available"}
 
 # ── 4.  Build UI ─────────────────────────────────────────────────
 def create_demo() -> gr.Blocks:
@@ -82,18 +145,18 @@ 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(
             """
-            # 🎭 Laban Movement Analysis 
+            # 🩰 Laban Movement Analysis 
             
             Pose estimation • AI action recognition • Movement Analysis 
             """
         )
         with gr.Tabs():
             # Tab 1: Standard Analysis
-            with gr.Tab("🎬 Standard Analysis"):
+            with gr.Tab("🎭 Standard Analysis"):
                 gr.Markdown("""
                 ### Upload a video file to analyze movement using traditional LMA metrics with pose estimation.
                 """)
@@ -130,8 +193,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 +219,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 +230,295 @@ 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=240):
+                    with gr.Column(scale=1):
+                        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]
+                )
+
+            # Tab 3: Agentic Analysis
+            with gr.Tab("🤖 Agentic Analysis"):
+                gr.Markdown("""
+                ### Intelligent Movement Interpretation
+                AI-powered analysis using the processed data from the Standard Analysis tab.
+                """)
+                
+                with gr.Row(equal_height=True):
+                    # Left column - Video display (sourced from first tab)
+                    with gr.Column(scale=1, min_width=400):
+                        gr.Markdown("**Source Video** *(from Standard Analysis)*")
+                        agentic_video_display = gr.Video(
+                            label="Analyzed Video", 
+                            interactive=False,
+                            height=350
+                        )
+                        
+                        # Model info display (sourced from first tab)
+                        gr.Markdown("**Model Used** *(from Standard Analysis)*")
+                        agentic_model_display = gr.Textbox(
+                            label="Pose Model",
+                            interactive=False,
+                            value="No analysis completed yet"
+                        )
+                    
+                    # Right column - Analysis options and output
+                    with gr.Column(scale=1, min_width=400):
+                        gr.Markdown("**Analysis Type**")
+                        agentic_analysis_type = gr.Radio(
+                            choices=[
+                                ("🎯 SUMMARY", "summary"),
+                                ("📊 STRUCTURED", "structured"), 
+                                ("🔍 MOVEMENT FILTERS", "movement_filters")
+                            ],
+                            value="summary",
+                            label="Choose Analysis",
+                            info="Select the type of intelligent analysis"
+                        )
+                        
+                        # Movement filters options (shown when movement_filters is selected)
+                        with gr.Group(visible=False) as movement_filter_options:
+                            gr.Markdown("**Filter Criteria**")
+                            filter_direction = gr.Dropdown(
+                                choices=["any", "up", "down", "left", "right", "forward", "backward", "stationary"],
+                                value="any",
+                                label="Dominant Direction"
+                            )
+                            filter_intensity = gr.Dropdown(
+                                choices=["any", "low", "medium", "high"],
+                                value="any", 
+                                label="Movement Intensity"
+                            )
+                            filter_min_fluidity = gr.Slider(0.0, 1.0, 0.0, label="Minimum Fluidity Score")
+                            filter_min_expansion = gr.Slider(0.0, 1.0, 0.0, label="Minimum Expansion Score")
+                        
+                        analyze_agentic_btn = gr.Button("🚀 Generate Analysis", variant="primary", size="lg")
+                        
+                        # Output display
+                        with gr.Accordion("Analysis Results", open=True):
+                            agentic_output = gr.JSON(label="Intelligent Analysis Results")
+
+                # Show/hide movement filter options based on selection
+                def toggle_filter_options(analysis_type):
+                    return gr.Group(visible=(analysis_type == "movement_filters"))
+                
+                agentic_analysis_type.change(
+                    fn=toggle_filter_options,
+                    inputs=[agentic_analysis_type],
+                    outputs=[movement_filter_options]
+                )
+                
+                # Update video display when standard analysis completes
+                def update_agentic_video_display(video_input, url_input, model):
+                    """Update agentic tab with video and model from standard analysis."""
+                    video_source = video_input if video_input else url_input
+                    return video_source, f"Model: {model}"
+                
+                # Link to standard analysis inputs
+                video_in.change(
+                    fn=update_agentic_video_display,
+                    inputs=[video_in, url_input_enh, model_sel],
+                    outputs=[agentic_video_display, agentic_model_display]
+                )
+                
+                url_input_enh.change(
+                    fn=update_agentic_video_display,
+                    inputs=[video_in, url_input_enh, model_sel],
+                    outputs=[agentic_video_display, agentic_model_display]
+                )
+                
+                model_sel.change(
+                    fn=update_agentic_video_display,
+                    inputs=[video_in, url_input_enh, model_sel],
+                    outputs=[agentic_video_display, agentic_model_display]
+                )
+                
+                # Hook up the Generate Analysis button
+                def process_agentic_analysis(json_data, analysis_type, filter_direction, filter_intensity, filter_min_fluidity, filter_min_expansion):
+                    """Process agentic analysis based on user selection."""
+                    return generate_agentic_analysis(
+                        json_data, 
+                        analysis_type, 
+                        filter_direction, 
+                        filter_intensity, 
+                        filter_min_fluidity, 
+                        filter_min_expansion
+                    )
+                
+                analyze_agentic_btn.click(
+                    fn=process_agentic_analysis,
+                    inputs=[
+                        json_out,  # JSON data from standard analysis
+                        agentic_analysis_type,
+                        filter_direction,
+                        filter_intensity, 
+                        filter_min_fluidity,
+                        filter_min_expansion
+                    ],
+                    outputs=[agentic_output],
+                    api_name="analyze_agentic"
+                )
+                
+                # Auto-update agentic analysis when JSON changes and analysis type is summary
+                def auto_update_summary(json_data, analysis_type):
+                    """Auto-update with summary when new analysis is available."""
+                    if json_data and analysis_type == "summary":
+                        return generate_agentic_analysis(json_data, "summary")
+                    return None
+                
+                json_out.change(
+                    fn=auto_update_summary,
+                    inputs=[json_out, agentic_analysis_type],
+                    outputs=[agentic_output]
+                )
+
+            # Tab 4: About
+            with gr.Tab("ℹ️ About"):
+                gr.Markdown("""
+                # 🩰 Developer Journey: Laban Movement Analysis
+                
+                ## 🎯 Project Vision
+                
+                Created to bridge the gap between traditional **Laban Movement Analysis (LMA)** principles and modern **AI-powered pose estimation**, this platform represents a comprehensive approach to understanding human movement through technology.
+                
+                ## 🛠️ Technical Architecture
+                
+                ### **Core Foundation**
+                - **15 Pose Estimation Models** from diverse sources and frameworks
+                - **Multi-format Video Processing** with URL support (YouTube, Vimeo, direct links)
+                - **Real-time Analysis Pipeline** with configurable model selection
+                - **MCP-Compatible API** for AI agent integration
+                
+                ### **Pose Model Ecosystem**
+                ```
+                📊 MediaPipe Family (Google)     → 3 variants (lite/full/heavy)
+                ⚡ MoveNet Family (TensorFlow)   → 2 variants (lightning/thunder)  
+                🎯 YOLO v8 Family (Ultralytics) → 5 variants (n/s/m/l/x)
+                🔥 YOLO v11 Family (Ultralytics)→ 5 variants (n/s/m/l/x)
+                ```
+                
+                ## 🎨 Innovation Highlights
+                
+                ### **1. Custom Gradio Component: `gradio_overlay_video`**
+                - **Layered Visualization**: Controlled overlay of pose data on original video
+                - **Interactive Controls**: Frame-by-frame analysis with movement metrics
+                - **Synchronized Playback**: Real-time correlation between video and data
+                
+                ### **2. Agentic Analysis Engine**
+                Beyond raw pose detection, we've developed intelligent interpretation layers:
+                
+                - **🎯 SUMMARY**: Narrative movement interpretation with temporal pattern analysis
+                - **📊 STRUCTURED**: Comprehensive quantitative breakdowns with statistical insights
+                - **🔍 MOVEMENT FILTERS**: Advanced pattern detection with customizable criteria
+                
+                ### **3. Temporal Pattern Recognition**
+                - **Movement Consistency Tracking**: Direction and intensity variation analysis
+                - **Complexity Scoring**: Multi-dimensional movement sophistication metrics
+                - **Sequence Detection**: Continuous movement pattern identification
+                - **Laban Integration**: Professional movement quality assessment using LMA principles
+                
+                ## 📈 Processing Pipeline
+                
+                ```mermaid
+                Video Input → Pose Detection → LMA Analysis → JSON Output
+                     ↓              ↓              ↓           ↓
+                URL/Upload → 15 Models → Temporal → Visualization
+                     ↓              ↓        Patterns    ↓
+                Preprocessing → Keypoints → Metrics → Agentic Analysis
+                ```
+                
+                ## 🎭 Laban Movement Analysis Integration
+                
+                Our implementation translates raw pose coordinates into meaningful movement qualities:
+                
+                - **Effort Qualities**: Intensity, speed, and flow characteristics
+                - **Space Usage**: Expansion patterns and directional preferences  
+                - **Temporal Dynamics**: Rhythm, acceleration, and movement consistency
+                - **Quality Assessment**: Fluidity scores and movement sophistication
+                
+                ## 🔬 Technical Achievements
+                
+                ### **Multi-Source Model Integration**
+                Successfully unified models from different frameworks:
+                - Google's MediaPipe (BlazePose architecture)
+                - TensorFlow's MoveNet (lightweight and accurate variants)
+                - Ultralytics' YOLO ecosystem (object detection adapted for pose)
+                
+                ### **Real-Time Processing Capabilities**
+                - **Streaming Support**: Frame-by-frame processing with temporal continuity
+                - **Memory Optimization**: Efficient handling of large video files
+                - **Error Recovery**: Graceful handling of pose detection failures
+                
+                ### **Agent-Ready Architecture**
+                - **MCP Server Integration**: Compatible with AI agent workflows
+                - **Structured API**: RESTful endpoints for programmatic access
+                - **Flexible Output Formats**: JSON, visualization videos, and metadata
+                
+                ## 🌟 Future Roadmap
+                
+                - **3D Pose Integration**: Depth-aware movement analysis
+                - **Multi-Person Tracking**: Ensemble and group movement dynamics
+                - **Real-Time Streaming**: Live movement analysis capabilities
+                - **Machine Learning Enhancement**: Custom models trained on movement data
+                
+                ## 🔧 Built With
+                
+                - **Frontend**: Gradio 5.33+ with custom Svelte components
+                - **Backend**: Python with FastAPI and async processing
+                - **Computer Vision**: MediaPipe, TensorFlow, PyTorch, Ultralytics
+                - **Analysis**: NumPy, OpenCV, custom Laban algorithms
+                - **Deployment**: Hugging Face Spaces with Docker support
+                
+                ---
+                
+                ### 👨‍💻 Created by **Csaba Bolyós**
+                
+                *Combining classical movement analysis with cutting-edge AI to unlock new possibilities in human movement understanding.*
+                
+                **Connect:**  
+                [GitHub](https://github.com/bladeszasza) • [Hugging Face](https://huggingface.co/BladeSzaSza) • [LinkedIn](https://www.linkedin.com/in/csaba-bolyós-00a11767/)
+                
+                ---
+                
+                > *"Movement is a language. Technology helps us understand what the body is saying."*
+                """)
+         
         # 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) 

src/demo/space.py

@@ -46,8 +46,8 @@ 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
 
 # Import agent API if available
 # Initialize agent API if available
@@ -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) 
 

src/pyproject.toml

@@ -8,8 +8,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gradio_labanmovementanalysis"
-version = "0.0.5"
-description = "A Gradio 5 component for video movement analysis using Laban Movement Analysis (LMA) with MCP support for AI agents"
+version = "0.0.7"
+description = "Video movement analysis using Laban Movement Analysis (LMA)"
 readme = "README.md"
 license = "apache-2.0"
 authors = [{ name = "Csaba Bolyós", email = "bladeszasza@gmail.com" }]
@@ -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]

src/requirements.txt

@@ -5,4 +5,5 @@
     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