Update app.py

app.py

@@ -4,17 +4,8 @@
 import torch
 import tempfile
 import os
-import logging
-from pathlib import Path
 import time
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='[%(asctime)s] %(levelname)s: %(message)s',
-    datefmt='%H:%M:%S'
-)
-logger = logging.getLogger(__name__)
+from pathlib import Path
 
 # Import model loaders
 from model_loaders import load_sam2, load_matanyone, pose
@@ -25,7 +16,6 @@ def log_and_progress(progress_callback, stage, progress, message):
     """Unified logging and progress reporting"""
     timestamp = time.strftime("%H:%M:%S")
     log_msg = f"[{timestamp}] Stage {stage} ({progress:.0%}): {message}"
-    logger.info(log_msg)
     print(log_msg, flush=True)
     progress_callback(stage, progress, message)
 
@@ -35,18 +25,18 @@ def process_video(input_path, output_path, progress_callback):
     # ============================================================
     # STAGE 1: SEGMENTATION (Load models, read video, segment all frames)
     # ============================================================
-    logger.info("="*60)
-    logger.info("STAGE 1: PERSON SEGMENTATION")
-    logger.info("="*60)
+    print("="*60, flush=True)
+    print("STAGE 1: PERSON SEGMENTATION", flush=True)
+    print("="*60, flush=True)
     stage1_start = time.time()
     
     # 1.1: Load SAM2
     log_and_progress(progress_callback, 1, 0.0, "Loading SAM2 model...")
     try:
         sam_predictor = load_sam2()
-        logger.info(f"✅ SAM2 loaded successfully")
+        print(f"✅ SAM2 loaded successfully", flush=True)
     except Exception as e:
-        logger.error(f"❌ SAM2 loading failed: {e}")
+        print(f"❌ SAM2 loading failed: {e}", flush=True)
         raise
     
     # 1.2: Load video
@@ -61,9 +51,9 @@ def process_video(input_path, output_path, progress_callback):
         height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
         
-        logger.info(f"📹 Video: {width}x{height} @ {fps:.2f}fps, {total_frames} frames")
+        print(f"📹 Video: {width}x{height} @ {fps:.2f}fps, {total_frames} frames", flush=True)
     except Exception as e:
-        logger.error(f"❌ Video opening failed: {e}")
+        print(f"❌ Video opening failed: {e}", flush=True)
         raise
     
     # 1.3: Read all frames
@@ -75,7 +65,7 @@ def process_video(input_path, output_path, progress_callback):
             break
         frames.append(frame)
     cap.release()
-    logger.info(f"✅ Read {len(frames)} frames")
+    print(f"✅ Read {len(frames)} frames", flush=True)
     
     # 1.4: Segment all frames
     log_and_progress(progress_callback, 1, 0.2, "Starting person segmentation...")
@@ -117,31 +107,31 @@ def process_video(input_path, output_path, progress_callback):
                 masks.append(np.zeros((h, w), dtype=bool))
                 
         except Exception as e:
-            logger.error(f"❌ Frame {i+1} segmentation failed: {e}")
+            print(f"❌ Frame {i+1} segmentation failed: {e}", flush=True)
             h, w = frame.shape[:2]
             masks.append(np.zeros((h, w), dtype=bool))
     
     stage1_time = time.time() - stage1_start
-    logger.info("="*60)
-    logger.info(f"✅ STAGE 1 COMPLETE in {stage1_time:.1f}s")
-    logger.info(f"   Segmented {len(masks)} frames")
-    logger.info("="*60)
+    print("="*60, flush=True)
+    print(f"✅ STAGE 1 COMPLETE in {stage1_time:.1f}s", flush=True)
+    print(f"   Segmented {len(masks)} frames", flush=True)
+    print("="*60, flush=True)
     
     # ============================================================
     # STAGE 2: MATTING (Refine all masks, smooth, write video)
     # ============================================================
-    logger.info("="*60)
-    logger.info("STAGE 2: HIGH-QUALITY MATTING")
-    logger.info("="*60)
+    print("="*60, flush=True)
+    print("STAGE 2: HIGH-QUALITY MATTING", flush=True)
+    print("="*60, flush=True)
     stage2_start = time.time()
     
     # 2.1: Load MatAnyone
     log_and_progress(progress_callback, 2, 0.0, "Loading MatAnyone model...")
     try:
         matanyone = load_matanyone()
-        logger.info(f"✅ MatAnyone loaded successfully")
+        print(f"✅ MatAnyone loaded successfully", flush=True)
     except Exception as e:
-        logger.error(f"❌ MatAnyone loading failed: {e}")
+        print(f"❌ MatAnyone loading failed: {e}", flush=True)
         raise
     
     # 2.2: Process all frames with MatAnyone
@@ -168,10 +158,10 @@ def process_video(input_path, output_path, progress_callback):
             alphas.append(alpha)
             
         except Exception as e:
-            logger.error(f"❌ Frame {i+1} matting failed: {e}")
+            print(f"❌ Frame {i+1} matting failed: {e}", flush=True)
             alphas.append(np.zeros((frame.shape[0], frame.shape[1]), dtype=np.float32))
     
-    logger.info(f"✅ Matted {len(alphas)} frames")
+    print(f"✅ Matted {len(alphas)} frames", flush=True)
     
     # 2.3: Temporal smoothing
     log_and_progress(progress_callback, 2, 0.65, "Applying temporal smoothing to eliminate jitter...")
@@ -181,6 +171,9 @@ def process_video(input_path, output_path, progress_callback):
         half_window = window_size // 2
         
         for i in range(len(alphas)):
+            if i % 100 == 0:
+                print(f"Smoothing frame {i}/{len(alphas)}...", flush=True)
+            
             start_idx = max(0, i - half_window)
             end_idx = min(len(alphas), i + half_window + 1)
             window_alphas = alphas[start_idx:end_idx]
@@ -189,11 +182,11 @@ def process_video(input_path, output_path, progress_callback):
             smoothed = np.mean(window_alphas, axis=0)
             smoothed_alphas.append(smoothed)
         
-        logger.info(f"✅ Applied {window_size}-frame temporal smoothing")
+        print(f"✅ Applied {window_size}-frame temporal smoothing", flush=True)
         alphas = smoothed_alphas
         
     except Exception as e:
-        logger.error(f"⚠️ Smoothing failed: {e}, using unsmoothed alphas")
+        print(f"⚠️ Smoothing failed: {e}, using unsmoothed alphas", flush=True)
     
     # 2.4: Write output video
     log_and_progress(progress_callback, 2, 0.75, "Writing output video...")
@@ -215,23 +208,23 @@ def process_video(input_path, output_path, progress_callback):
             out.write(output)
         
         out.release()
-        logger.info(f"✅ Video written to {output_path}")
+        print(f"✅ Video written to {output_path}", flush=True)
         
     except Exception as e:
-        logger.error(f"❌ Video writing failed: {e}")
+        print(f"❌ Video writing failed: {e}", flush=True)
         raise
     
     stage2_time = time.time() - stage2_start
     total_time = stage1_time + stage2_time
     
-    logger.info("="*60)
-    logger.info(f"✅ STAGE 2 COMPLETE in {stage2_time:.1f}s")
-    logger.info("="*60)
-    logger.info(f"🎉 TOTAL PROCESSING TIME: {total_time:.1f}s")
-    logger.info(f"   Stage 1 (Segmentation): {stage1_time:.1f}s")
-    logger.info(f"   Stage 2 (Matting): {stage2_time:.1f}s")
-    logger.info(f"   Average: {total_time/len(frames):.2f}s per frame")
-    logger.info("="*60)
+    print("="*60, flush=True)
+    print(f"✅ STAGE 2 COMPLETE in {stage2_time:.1f}s", flush=True)
+    print("="*60, flush=True)
+    print(f"🎉 TOTAL PROCESSING TIME: {total_time:.1f}s", flush=True)
+    print(f"   Stage 1 (Segmentation): {stage1_time:.1f}s", flush=True)
+    print(f"   Stage 2 (Matting): {stage2_time:.1f}s", flush=True)
+    print(f"   Average: {total_time/len(frames):.2f}s per frame", flush=True)
+    print("="*60, flush=True)
     
     log_and_progress(progress_callback, 2, 1.0, "Processing complete!")
     return output_path
@@ -251,6 +244,10 @@ def main():
         output_path = tempfile.mktemp(suffix='_output.mp4')
         
         if st.button("🚀 Process Video", type="primary"):
+            print(f"\n\n{'='*60}", flush=True)
+            print(f"🎬 NEW VIDEO PROCESSING STARTED", flush=True)
+            print(f"{'='*60}\n", flush=True)
+            
             # Progress tracking
             stage1_progress = st.progress(0, text="Stage 1: Initializing...")
             stage1_status = st.empty()
@@ -267,7 +264,6 @@ def update_progress(stage, progress, message):
                     stage2_status.info(f"🔄 {message}")
             
             try:
-                logger.info("🎬 Starting video processing...")
                 result_path = process_video(input_path, output_path, update_progress)
                 
                 stage1_status.success("✅ Stage 1: Segmentation complete!")
@@ -288,9 +284,15 @@ def update_progress(stage, progress, message):
                 st.video(result_path)
                 
             except Exception as e:
-                logger.exception("Processing failed")
+                print(f"\n{'='*60}", flush=True)
+                print(f"❌❌❌ PROCESSING FAILED ❌❌❌", flush=True)
+                print(f"Error: {str(e)}", flush=True)
+                print(f"{'='*60}\n", flush=True)
+                import traceback
+                traceback.print_exc()
+                
                 st.error(f"❌ Processing failed: {str(e)}")
-                st.error("Check the logs above for details")
+                st.error("Check the container logs for full details")
             
             finally:
                 # Cleanup
@@ -302,4 +304,4 @@ def update_progress(stage, progress, message):
                             pass
 
 if __name__ == "__main__":
-    main()
+    main()