version bump agentic analysis added

.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": []
+  }
+}

.gitignore

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

README.md

@@ -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: Professional movement analysis with 15 pose models, AI-powered insights, and interactive visualization
 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
 

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)}"}

backend/gradio_labanmovementanalysis/notation_engine.py

@@ -60,27 +60,104 @@ 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 / frame; will be scaled by fps
-                 velocity_threshold_fast: float = 0.1,  # Normalized units / frame; will be scaled by fps
-                 intensity_accel_threshold: float = 0.05): # Normalized units / frame^2; will be scaled by fps^2 (approx)
+                 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]:
         """
@@ -126,8 +203,14 @@ class MovementAnalyzer:
                  prev_velocity = None # Or prev_velocity.pop(person_id, None)
                  continue
 
-            # Compute body center
-            center = self._compute_body_center(pose.keypoints)
+            # Compute confidence-weighted body center
+            center = self._compute_body_center_weighted(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(
@@ -170,9 +253,43 @@ class MovementAnalyzer:
             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"]
@@ -278,6 +395,30 @@ class MovementAnalyzer:
         
         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."""
         window_size = 3

demo/app.py

@@ -5,6 +5,7 @@ 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_overlay_video import OverlayVideo
@@ -20,9 +21,11 @@ try:
         MovementIntensity
     )
     agent_api = LabanAgentAPI()
+    HAS_AGENT_API = True
 except Exception as e:
     print(f"Warning: Agent API not available: {e}")
     agent_api = None
+    HAS_AGENT_API = False
 # Initialize components
 try:
     analyzer = LabanMovementAnalysis(
@@ -86,6 +89,55 @@ def process_video_standard(video : str, model : str, include_keypoints : bool) -
     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)}
+
+# 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:
     with gr.Blocks(
@@ -184,12 +236,13 @@ def create_demo() -> gr.Blocks:
                     "## See the movement analysis in action with an interactive overlay. "
                     "Analyze video @ 🎬 Standard Analysis tab"
                 )
-                with gr.Row(equal_height=True, min_height=400):
-                    overlay_video = OverlayVideo(
-                            value=(None, json_out),
-                            autoplay=True,
-                            interactive=False
-                        )
+                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
@@ -205,6 +258,252 @@ def create_demo() -> gr.Blocks:
                     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():

pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gradio_labanmovementanalysis"
-version = "0.0.6"
+version = "0.0.7"
 description = "A Gradio 5 component for video movement analysis using Laban Movement Analysis (LMA) with MCP support for AI agents"
 readme = "README.md"
 license = "apache-2.0"