Update debug_positioning.py

debug_positioning.py

@@ -1,237 +1,403 @@
 #!/usr/bin/env python3
 """
-Quick test script to validate positioning fixes before full video processing.
-Run this to verify coordinate calculations are working correctly.
+Debug Enhanced Positioning System for Video Background Replacement
+
+Key debugging areas:
+1. UI parameter flow validation
+2. Coordinate system debugging
+3. Alpha/video alignment verification  
+4. Canvas placement mathematics
+5. Temporal synchronization checks
 """
 
-import numpy as np
 import cv2
+import numpy as np
 import os
+import time
+import random
 from pathlib import Path
+from moviepy.editor import VideoFileClip
+import logging
 
-def test_coordinate_calculations():
-    """Test coordinate calculations with various placement scenarios"""
-    
-    print("=== COORDINATE CALCULATION TESTS ===\n")
-    
-    # Simulate video dimensions
-    video_dims = [(720, 1280), (1080, 1920), (480, 640)]  # (H, W)
+# Enhanced logging for debugging
+logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s")
+debug_logger = logging.getLogger("positioning_debug")
+
+class PositioningDebugger:
+    """Comprehensive debugging for positioning system"""
     
-    test_placements = [
-        {"name": "Center", "x": 0.5, "y": 0.5, "scale": 1.0},
-        {"name": "Bottom Center", "x": 0.5, "y": 0.75, "scale": 1.0},
-        {"name": "Top Right", "x": 0.8, "y": 0.2, "scale": 0.7},
-        {"name": "Bottom Left Small", "x": 0.2, "y": 0.9, "scale": 0.5},
-        {"name": "Large Center", "x": 0.5, "y": 0.5, "scale": 1.5},
-    ]
+    def __init__(self, debug_dir="debug_positioning"):
+        self.debug_dir = Path(debug_dir)
+        self.debug_dir.mkdir(exist_ok=True, parents=True)
+        self.frame_count = 0
+        
+    def log_parameters(self, placement_dict):
+        """Log all positioning parameters"""
+        debug_logger.info("=== POSITIONING PARAMETERS ===")
+        debug_logger.info(f"Raw placement dict: {placement_dict}")
+        
+        px = float(placement_dict.get("x", 0.5))
+        py = float(placement_dict.get("y", 0.75))
+        ps = float(placement_dict.get("scale", 1.0))
+        feather_px = int(placement_dict.get("feather", 3))
+        
+        debug_logger.info(f"Parsed - px: {px}, py: {py}, ps: {ps}, feather: {feather_px}")
+        debug_logger.info(f"Clamped - px: {max(0.0, min(1.0, px))}, py: {max(0.0, min(1.0, py))}")
+        debug_logger.info(f"Scale range - ps: {max(0.3, min(2.0, ps))}")
+        
+        return px, py, ps, feather_px
     
-    for h, w in video_dims:
-        print(f"Video Resolution: {w}x{h}")
-        print("-" * 40)
+    def debug_coordinate_calculation(self, frame_dims, alpha_dims, placement):
+        """Debug coordinate calculations step by step"""
+        hh, ww = frame_dims  # Original video dimensions
+        alpha_h, alpha_w = alpha_dims  # Alpha video dimensions
         
-        for test in test_placements:
-            px, py, ps = test["x"], test["y"], test["scale"]
-            
-            # Calculate coordinates (same logic as app.py)
-            sw = max(1, round(w * ps))
-            sh = max(1, round(h * ps))
-            cx = round(px * w)
-            cy = round(py * h)
-            x0 = cx - sw // 2
-            y0 = cy - sh // 2
-            
-            # Bounds checking
-            xs0 = max(0, x0)
-            ys0 = max(0, y0)
-            xs1 = min(w, x0 + sw)
-            ys1 = min(h, y0 + sh)
-            
-            # Check validity
-            valid = xs1 > xs0 and ys1 > ys0
-            clipped = x0 < 0 or y0 < 0 or (x0 + sw) > w or (y0 + sh) > h
-            
-            print(f"  {test['name']:15} | Center: ({cx:4d}, {cy:4d}) | Size: {sw:4d}x{sh:4d} | Valid: {valid} | Clipped: {clipped}")
+        px, py, ps, feather_px = self.log_parameters(placement)
+        
+        debug_logger.info("=== COORDINATE CALCULATIONS ===")
+        debug_logger.info(f"Original video dims: {ww}x{hh}")
+        debug_logger.info(f"Alpha video dims: {alpha_w}x{alpha_h}")
+        
+        # Scale calculations
+        sw = max(1, int(ww * ps))
+        sh = max(1, int(hh * ps))
+        debug_logger.info(f"Scaled subject size: {sw}x{sh} (scale factor: {ps})")
+        
+        # Center calculations
+        cx = int(px * ww)
+        cy = int(py * hh)
+        debug_logger.info(f"Target center: ({cx}, {cy})")
+        
+        # Top-left corner calculations
+        x0 = int(cx - sw // 2)
+        y0 = int(cy - sh // 2)
+        debug_logger.info(f"Top-left corner: ({x0}, {y0})")
+        
+        # Clipping calculations
+        xs0, ys0 = max(0, x0), max(0, y0)
+        xs1, ys1 = min(ww, x0 + sw), min(hh, y0 + sh)
+        debug_logger.info(f"Clipped bounds: ({xs0}, {ys0}) to ({xs1}, {ys1})")
+        
+        if xs1 <= xs0 or ys1 <= ys0:
+            debug_logger.warning("INVALID BOUNDS - Subject will be clipped completely!")
             
-            if not valid:
-                print(f"    ERROR: Invalid bounds ({xs0}, {ys0}) to ({xs1}, {ys1})")
+        # Source region calculations
+        src_x0 = xs0 - x0
+        src_y0 = ys0 - y0
+        src_x1 = src_x0 + (xs1 - xs0)
+        src_y1 = src_y0 + (ys1 - ys0)
+        debug_logger.info(f"Source region: ({src_x0}, {src_y0}) to ({src_x1}, {src_y1})")
+        
+        return {
+            'scaled_size': (sw, sh),
+            'center': (cx, cy),
+            'top_left': (x0, y0),
+            'clipped_dest': (xs0, ys0, xs1, ys1),
+            'source_region': (src_x0, src_y0, src_x1, src_y1)
+        }
+    
+    def save_debug_frame(self, frame, alpha, composite, frame_idx, coords):
+        """Save debug visualization of frame processing"""
+        debug_path = self.debug_dir / f"frame_{frame_idx:04d}_debug.png"
+        
+        # Create debug visualization
+        h, w = frame.shape[:2]
+        debug_viz = np.zeros((h * 2, w * 2, 3), dtype=np.uint8)
+        
+        # Top-left: Original frame
+        debug_viz[0:h, 0:w] = cv2.cvtColor((frame * 255).astype(np.uint8), cv2.COLOR_RGB2BGR)
+        
+        # Top-right: Alpha mask (as RGB)
+        alpha_viz = cv2.cvtColor((alpha * 255).astype(np.uint8), cv2.COLOR_GRAY2BGR)
+        debug_viz[0:h, w:w*2] = alpha_viz
         
-        print()
+        # Bottom-left: Composite
+        debug_viz[h:h*2, 0:w] = cv2.cvtColor((composite * 255).astype(np.uint8), cv2.COLOR_RGB2BGR)
+        
+        # Bottom-right: Coordinate overlay
+        coord_viz = np.zeros((h, w, 3), dtype=np.uint8)
+        
+        # Draw placement indicators
+        cx, cy = coords['center']
+        sw, sh = coords['scaled_size']
+        x0, y0 = coords['top_left']
+        
+        # Draw center cross
+        cv2.line(coord_viz, (cx-10, cy), (cx+10, cy), (0, 255, 0), 2)
+        cv2.line(coord_viz, (cx, cy-10), (cx, cy+10), (0, 255, 0), 2)
+        
+        # Draw scaled subject bounds
+        cv2.rectangle(coord_viz, (x0, y0), (x0 + sw, y0 + sh), (255, 0, 0), 2)
+        
+        # Draw frame bounds
+        cv2.rectangle(coord_viz, (0, 0), (w-1, h-1), (255, 255, 255), 1)
+        
+        debug_viz[h:h*2, w:w*2] = coord_viz
+        
+        # Add text annotations
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        cv2.putText(debug_viz, "Original", (10, 30), font, 0.7, (255, 255, 255), 2)
+        cv2.putText(debug_viz, "Alpha", (w + 10, 30), font, 0.7, (255, 255, 255), 2)
+        cv2.putText(debug_viz, "Composite", (10, h + 30), font, 0.7, (255, 255, 255), 2)
+        cv2.putText(debug_viz, "Coordinates", (w + 10, h + 30), font, 0.7, (255, 255, 255), 2)
+        
+        cv2.imwrite(str(debug_path), debug_viz)
+        debug_logger.info(f"Debug frame saved: {debug_path}")
 
-def create_test_visualization():
-    """Create visual test to verify positioning logic"""
-    
-    print("=== CREATING POSITIONING VISUALIZATION ===\n")
-    
-    # Test canvas
-    canvas_w, canvas_h = 800, 600
-    canvas = np.zeros((canvas_h, canvas_w, 3), dtype=np.uint8)
-    canvas.fill(50)  # Dark gray background
-    
-    # Test subject dimensions (simulating scaled subject)
-    subject_w, subject_h = 200, 300
-    
-    test_positions = [
-        {"x": 0.2, "y": 0.3, "color": (255, 0, 0)},    # Red - top left
-        {"x": 0.8, "y": 0.3, "color": (0, 255, 0)},    # Green - top right  
-        {"x": 0.5, "y": 0.5, "color": (0, 0, 255)},    # Blue - center
-        {"x": 0.3, "y": 0.8, "color": (255, 255, 0)},  # Cyan - bottom left
-        {"x": 0.7, "y": 0.8, "color": (255, 0, 255)},  # Magenta - bottom right
-    ]
+def create_enhanced_composite_function(debugger=None):
+    """Create composite function with enhanced debugging"""
     
-    for i, pos in enumerate(test_positions):
-        px, py = pos["x"], pos["y"]
-        color = pos["color"]
-        
-        # Calculate placement (same as app.py logic)
-        cx = round(px * canvas_w)
-        cy = round(py * canvas_h)
-        x0 = cx - subject_w // 2
-        y0 = cy - subject_h // 2
-        
-        # Bounds
-        xs0 = max(0, x0)
-        ys0 = max(0, y0)
-        xs1 = min(canvas_w, x0 + subject_w)
-        ys1 = min(canvas_h, y0 + subject_h)
-        
-        if xs1 > xs0 and ys1 > ys0:
-            # Draw subject rectangle
-            cv2.rectangle(canvas, (xs0, ys0), (xs1-1, ys1-1), color, 2)
-            
-            # Draw center cross
-            cv2.line(canvas, (cx-10, cy), (cx+10, cy), color, 2)
-            cv2.line(canvas, (cx, cy-10), (cx, cy+10), color, 2)
-            
-            # Add label
-            cv2.putText(canvas, f"({px:.1f}, {py:.1f})", (cx-30, cy-20), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.4, color, 1)
-            
-            print(f"Position {i+1}: ({px:.1f}, {py:.1f}) -> Center ({cx}, {cy}) -> Rect ({xs0}, {ys0}) to ({xs1}, {ys1})")
+    def composite_frame_debug(get_frame, t, original_clip, alpha_clip, bg_rgb, placement, feather_px):
+        """Enhanced composite function with comprehensive debugging"""
+        
+        if debugger:
+            debugger.frame_count += 1
+            debug_logger.info(f"=== PROCESSING FRAME {debugger.frame_count} at t={t:.3f}s ===")
+        
+        # Get original frame
+        frame = get_frame(t).astype(np.float32) / 255.0
+        hh, ww = frame.shape[:2]
+        
+        # Get alpha with temporal bounds checking
+        alpha_duration = alpha_clip.duration or 0
+        if alpha_duration > 0:
+            alpha_t = min(t, max(0.0, alpha_duration - 0.01))
         else:
-            print(f"Position {i+1}: ({px:.1f}, {py:.1f}) -> OUT OF BOUNDS")
-    
-    # Save test image
-    output_path = "positioning_test_visualization.png"
-    cv2.imwrite(output_path, canvas)
-    print(f"\nVisualization saved: {output_path}")
+            alpha_t = 0.0
+            
+        debug_logger.info(f"Alpha lookup: t={t:.3f}, alpha_t={alpha_t:.3f}, alpha_duration={alpha_duration:.3f}")
+        
+        try:
+            a = alpha_clip.get_frame(alpha_t)
+            if a.ndim == 3:
+                a = a[:, :, 0]  # Take first channel if RGB
+            a = a.astype(np.float32) / 255.0
+            debug_logger.info(f"Alpha frame shape: {a.shape}, range: [{a.min():.3f}, {a.max():.3f}]")
+        except Exception as e:
+            debug_logger.error(f"Alpha frame error: {e}")
+            return (bg_rgb * 255).astype(np.uint8)
+        
+        # Extract placement parameters
+        px = max(0.0, min(1.0, float(placement.get("x", 0.5))))
+        py = max(0.0, min(1.0, float(placement.get("y", 0.75))))
+        ps = max(0.3, min(2.0, float(placement.get("scale", 1.0))))
+        
+        # Debug coordinate calculations
+        coords = None
+        if debugger:
+            coords = debugger.debug_coordinate_calculation((hh, ww), a.shape, placement)
+        
+        # Scale subject and alpha
+        sw = max(1, int(ww * ps))
+        sh = max(1, int(hh * ps))
+        
+        debug_logger.info(f"Scaling: {ww}x{hh} -> {sw}x{sh} (factor: {ps})")
+        
+        fg_scaled = cv2.resize(frame, (sw, sh), interpolation=cv2.INTER_LINEAR)
+        a_scaled = cv2.resize(a, (sw, sh), interpolation=cv2.INTER_LINEAR)
+        
+        # Create canvas
+        fg_canvas = np.zeros_like(frame, dtype=np.float32)
+        a_canvas = np.zeros((hh, ww), dtype=np.float32)
+        
+        # Calculate placement
+        cx = int(px * ww)
+        cy = int(py * hh) 
+        x0 = int(cx - sw // 2)
+        y0 = int(cy - sh // 2)
+        
+        # Bounds checking
+        xs0, ys0 = max(0, x0), max(0, y0)
+        xs1, ys1 = min(ww, x0 + sw), min(hh, y0 + sh)
+        
+        if xs1 <= xs0 or ys1 <= ys0:
+            debug_logger.warning("Subject completely outside frame bounds!")
+            if debugger:
+                debugger.save_debug_frame(frame, a, bg_rgb, debugger.frame_count, coords or {})
+            return (bg_rgb * 255).astype(np.uint8)
+        
+        # Place scaled subject
+        src_x0 = xs0 - x0
+        src_y0 = ys0 - y0  
+        src_x1 = src_x0 + (xs1 - xs0)
+        src_y1 = src_y0 + (ys1 - ys0)
+        
+        try:
+            fg_canvas[ys0:ys1, xs0:xs1, :] = fg_scaled[src_y0:src_y1, src_x0:src_x1, :]
+            a_canvas[ys0:ys1, xs0:xs1] = a_scaled[src_y0:src_y1, src_x0:src_x1]
+        except Exception as e:
+            debug_logger.error(f"Canvas placement error: {e}")
+            debug_logger.error(f"Canvas region: [{ys0}:{ys1}, {xs0}:{xs1}]")
+            debug_logger.error(f"Source region: [{src_y0}:{src_y1}, {src_x0}:{src_x1}]")
+            if debugger:
+                debugger.save_debug_frame(frame, a, bg_rgb, debugger.frame_count, coords or {})
+            return (bg_rgb * 255).astype(np.uint8)
+        
+        # Apply feathering
+        if feather_px > 0:
+            k = (feather_px * 2 + 1)
+            a_canvas = cv2.GaussianBlur(a_canvas, (k, k), feather_px)
+        
+        # Composite
+        a3 = a_canvas[:, :, None]
+        comp = a3 * fg_canvas + (1.0 - a3) * bg_rgb
+        result = np.clip(comp * 255, 0, 255).astype(np.uint8)
+        
+        # Save debug frame periodically
+        if debugger and debugger.frame_count % 30 == 1:  # Every ~1 second at 30fps
+            debugger.save_debug_frame(frame, a_canvas, comp, debugger.frame_count, coords or {})
+        
+        return result
     
-    return output_path
+    return composite_frame_debug
 
-def test_ui_parameter_flow():
-    """Test that UI slider values correctly flow through to positioning"""
-    
-    print("=== UI PARAMETER FLOW TEST ===\n")
+def validate_ui_parameter_flow():
+    """Test function to validate UI parameters reach processing correctly"""
     
-    # Simulate Gradio slider values
-    gradio_values = {
-        "place_x": 0.7,      # 70% from left  
-        "place_y": 0.3,      # 30% from top
-        "place_scale": 1.2,  # 120% scale
-        "place_feather": 5   # 5px feather
-    }
-    
-    # Simulate placement dict creation (from Gradio interface)
-    placement = {
-        "x": gradio_values["place_x"],
-        "y": gradio_values["place_y"], 
-        "scale": gradio_values["place_scale"],
-        "feather": gradio_values["place_feather"]
-    }
-    
-    print("Gradio slider values:")
-    for key, val in gradio_values.items():
-        print(f"  {key}: {val}")
-    
-    print(f"\nPlacement dict: {placement}")
-    
-    # Test parameter extraction (same as app.py)
-    px = max(0.0, min(1.0, float(placement.get("x", 0.5))))
-    py = max(0.0, min(1.0, float(placement.get("y", 0.75))))  
-    ps = max(0.3, min(2.0, float(placement.get("scale", 1.0))))
-    feather_px = max(0, min(50, int(placement.get("feather", 3))))
-    
-    print("\nExtracted and clamped values:")
-    print(f"  px (x): {px}")
-    print(f"  py (y): {py}") 
-    print(f"  ps (scale): {ps}")
-    print(f"  feather_px: {feather_px}")
-    
-    # Verify no unexpected transformations
-    expected_x = gradio_values["place_x"]
-    expected_y = gradio_values["place_y"]
-    expected_scale = gradio_values["place_scale"]
-    expected_feather = gradio_values["place_feather"]
+    # Simulate UI parameter values
+    test_placements = [
+        {"x": 0.5, "y": 0.5, "scale": 1.0, "feather": 3},    # Center
+        {"x": 0.2, "y": 0.8, "scale": 0.7, "feather": 5},    # Bottom-left, smaller
+        {"x": 0.8, "y": 0.3, "scale": 1.5, "feather": 1},    # Top-right, larger
+    ]
     
-    if abs(px - expected_x) < 0.001 and abs(py - expected_y) < 0.001:
-        print("\n✅ Parameter flow is correct!")
-    else:
-        print(f"\n❌ Parameter flow issue!")
-        print(f"   Expected x: {expected_x}, got: {px}")
-        print(f"   Expected y: {expected_y}, got: {py}")
+    debugger = PositioningDebugger()
     
-    return px == expected_x and py == expected_y
+    for i, placement in enumerate(test_placements):
+        print(f"\n=== TEST CASE {i+1} ===")
+        
+        # Simulate frame dimensions
+        frame_dims = (720, 1280)  # H, W
+        alpha_dims = (720, 1280)
+        
+        coords = debugger.debug_coordinate_calculation(frame_dims, alpha_dims, placement)
+        
+        print(f"Expected center: {coords['center']}")
+        print(f"Scaled size: {coords['scaled_size']}")
+        print(f"Placement bounds: {coords['clipped_dest']}")
 
-def test_scaling_calculations():
-    """Test scaling calculations for different scenarios"""
-    
-    print("=== SCALING CALCULATION TESTS ===\n")
-    
-    base_dims = [(720, 1280), (1080, 1920)]
-    scale_factors = [0.5, 0.75, 1.0, 1.25, 1.5]
-    
-    for h, w in base_dims:
-        print(f"Base dimensions: {w}x{h}")
-        print("-" * 30)
-        
-        for scale in scale_factors:
-            # Test both int() and round() approaches
-            sw_int = max(1, int(w * scale))
-            sh_int = max(1, int(h * scale))
-            sw_round = max(1, round(w * scale))
-            sh_round = max(1, round(h * scale))
+def create_debug_enhanced_process_video_main():
+    """Enhanced version of process_video_main with debugging"""
+    
+    def process_video_main_debug(
+        video_path: str,
+        background_path: str = None,
+        trim_duration: float = None,
+        crf: int = 18,
+        preserve_audio_flag: bool = True,
+        placement: dict = None,
+        use_chunked_processing: bool = False,
+        enable_debug: bool = True,
+        progress=None,
+    ):
+        """
+        Enhanced process_video_main with comprehensive positioning debugging
+        """
+        
+        debugger = PositioningDebugger() if enable_debug else None
+        messages = []
+        
+        try:
+            if debugger:
+                debug_logger.info("=== STARTING DEBUG SESSION ===")
+                debug_logger.info(f"Video: {video_path}")
+                debug_logger.info(f"Background: {background_path}")
+                debug_logger.info(f"Placement: {placement}")
             
-            print(f"  Scale {scale:4.2f} | int(): {sw_int:4d}x{sh_int:4d} | round(): {sw_round:4d}x{sh_round:4d}")
+            # Validate placement parameters early
+            placement = placement or {}
+            if debugger:
+                debugger.log_parameters(placement)
             
-            if sw_int != sw_round or sh_int != sh_round:
-                print(f"    ^ Different results! Using round() is more accurate.")
-        
-        print()
-
-def main():
-    """Run all positioning tests"""
-    
-    print("🎬 VIDEO BACKGROUND REPLACEMENT - POSITIONING TESTS")
-    print("=" * 60)
-    
-    # Test 1: Coordinate calculations
-    test_coordinate_calculations()
-    
-    # Test 2: UI parameter flow
-    ui_flow_ok = test_ui_parameter_flow()
-    
-    # Test 3: Scaling calculations  
-    test_scaling_calculations()
-    
-    # Test 4: Visual verification
-    viz_path = create_test_visualization()
-    
-    # Summary
-    print("=" * 60)
-    print("TEST SUMMARY:")
-    print(f"✅ Coordinate calculations: Tested")
-    print(f"{'✅' if ui_flow_ok else '❌'} UI parameter flow: {'OK' if ui_flow_ok else 'Issues detected'}")
-    print(f"✅ Scaling calculations: Tested")
-    print(f"✅ Visual verification: {viz_path}")
+            # ... [Previous initialization code remains the same] ...
+            
+            # Enhanced composite function with debugging
+            def composite_frame(get_frame, t):
+                return create_enhanced_composite_function(debugger)(
+                    get_frame, t, original_clip, alpha_clip, bg_rgb, placement, 
+                    int(placement.get("feather", 3))
+                )
+            
+            # ... [Rest of processing remains the same] ...
+            
+            if debugger:
+                debug_logger.info("=== DEBUG SESSION COMPLETE ===")
+                debug_logger.info(f"Debug files saved to: {debugger.debug_dir}")
+            
+            return result_path, "\n".join(messages)
+            
+        except Exception as e:
+            if debugger:
+                debug_logger.error(f"Processing failed: {e}")
+            raise
     
-    if not ui_flow_ok:
-        print("\n⚠️  UI parameter flow issues detected!")
-        print("   Check that Gradio slider values are correctly passed to placement dict.")
+    return process_video_main_debug
+
+# Quick fix suggestions for immediate testing
+def quick_positioning_fixes():
+    """
+    Quick fixes to test for common positioning issues
+    """
+    
+    fixes = {
+        "coordinate_system_flip": {
+            "description": "Test if Y coordinate should be flipped",
+            "change": "cy = int((1.0 - py) * hh)  # Flip Y coordinate",
+            "original": "cy = int(py * hh)"
+        },
+        
+        "anchor_point_adjustment": {
+            "description": "Test different anchor points for scaling",
+            "change": """
+            # Try bottom-center anchor instead of center-center
+            x0 = int(cx - sw // 2)  # Keep X centered
+            y0 = int(cy - sh)       # Anchor at bottom
+            """,
+            "original": """
+            x0 = int(cx - sw // 2)
+            y0 = int(cy - sh // 2)
+            """
+        },
+        
+        "alpha_scaling_sync": {
+            "description": "Ensure alpha and frame scaling are synchronized",
+            "change": """
+            # Force exact same dimensions
+            if a.shape != (hh, ww):
+                a = cv2.resize(a, (ww, hh), interpolation=cv2.INTER_LINEAR)
+            """,
+            "original": "# No explicit resize check"
+        },
+        
+        "ui_parameter_validation": {
+            "description": "Add parameter validation and logging",
+            "change": """
+            px = float(placement.get("x", 0.5))
+            py = float(placement.get("y", 0.75)) 
+            ps = float(placement.get("scale", 1.0))
+            
+            print(f"DEBUG: px={px}, py={py}, ps={ps}")
+            print(f"DEBUG: cx={px*ww}, cy={py*hh}")
+            """,
+            "original": "# No debug logging"
+        }
+    }
     
-    print(f"\n🔧 Next steps:")
-    print("1. Review coordinate calculation results above")
-    print("2. Check the generated visualization image") 
-    print("3. Apply the enhanced composite_frame function to your app.py")
-    print("4. Test with a small video file first")
+    return fixes
 
 if __name__ == "__main__":
-    main()
+    print("=== Video Background Replacement - Positioning Debug ===")
+    print("\n1. Running UI parameter validation...")
+    validate_ui_parameter_flow()
+    
+    print("\n2. Available quick fixes:")
+    fixes = quick_positioning_fixes()
+    for fix_name, fix_info in fixes.items():
+        print(f"\n{fix_name.upper()}:")
+        print(f"  Description: {fix_info['description']}")
+        print(f"  Change: {fix_info['change']}")
+    
+    print("\n3. Debug system ready!")
+    print("   - Use PositioningDebugger class in your main pipeline")
+    print("   - Enable debug mode: enable_debug=True")
+    print("   - Check debug_positioning/ folder for output")