Create debug_positioning.py

debug_positioning.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+"""
+Quick test script to validate positioning fixes before full video processing.
+Run this to verify coordinate calculations are working correctly.
+"""
+
+import numpy as np
+import cv2
+import os
+from pathlib import Path
+
+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)
+    
+    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},
+    ]
+    
+    for h, w in video_dims:
+        print(f"Video Resolution: {w}x{h}")
+        print("-" * 40)
+        
+        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}")
+            
+            if not valid:
+                print(f"    ERROR: Invalid bounds ({xs0}, {ys0}) to ({xs1}, {ys1})")
+        
+        print()
+
+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
+    ]
+    
+    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})")
+        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}")
+    
+    return output_path
+
+def test_ui_parameter_flow():
+    """Test that UI slider values correctly flow through to positioning"""
+    
+    print("=== UI PARAMETER FLOW TEST ===\n")
+    
+    # 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"]
+    
+    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}")
+    
+    return px == expected_x and py == expected_y
+
+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))
+            
+            print(f"  Scale {scale:4.2f} | int(): {sw_int:4d}x{sh_int:4d} | round(): {sw_round:4d}x{sh_round:4d}")
+            
+            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}")
+    
+    if not ui_flow_ok:
+        print("\n⚠️  UI parameter flow issues detected!")
+        print("   Check that Gradio slider values are correctly passed to placement dict.")
+    
+    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")
+
+if __name__ == "__main__":
+    main()