Update pipeline/video_pipeline.py

pipeline/video_pipeline.py

@@ -82,7 +82,7 @@ def generate_mask_from_video_first_frame(video_path, sam2_predictor):
                 return best_mask.astype(np.uint8) * 255
     
     except Exception as e:
-        logger.error(f"Failed to generate mask: {e}")
+        logger.error(f"Failed to generate mask: {e}", exc_info=True)
         return None
 
 # ============================================================================
@@ -107,7 +107,7 @@ def smooth_alpha_video(alpha_video_path, output_path, window_size=5):
     Returns:
         Path to smoothed alpha video
     """
-    logger.info(f"🎬 Applying temporal smoothing to reduce jitter (window={window_size})")
+    logger.info(f"Applying temporal smoothing to reduce jitter (window={window_size})")
     
     try:
         cap = cv2.VideoCapture(alpha_video_path)
@@ -148,7 +148,7 @@ def smooth_alpha_video(alpha_video_path, output_path, window_size=5):
         cap.release()
         out.release()
         
-        logger.info(f"✅ Temporal smoothing complete: {frame_count} frames processed")
+        logger.info(f"Temporal smoothing complete: {frame_count} frames processed")
         return output_path
         
     except Exception as e:
@@ -231,12 +231,12 @@ def stage1_create_transparent_video(input_file):
     3. Apply temporal smoothing to alpha channel (FIXES SHAKING)
     4. Create transparent .mov file
     """
-    logger.info("🎬 Starting Stage 1: Create transparent video")
+    logger.info("Starting Stage 1: Create transparent video")
     
     # Check memory
     memory_info = get_memory_usage()
     if memory_info.get('gpu_free', 0) < 2.0:
-        st.warning("⚠️ Low GPU memory detected. Processing may be slower.")
+        st.warning("Low GPU memory detected. Processing may be slower.")
         clear_model_cache()
     
     try:
@@ -252,15 +252,31 @@ def update_progress(progress, message):
         
         # Load models
         update_progress(0.05, "Loading SAM2 model...")
-        sam2_predictor = load_sam2_predictor()
+        sam2_result = load_sam2_predictor()
+        
+        # Handle tuple return from load_sam2_predictor
+        if isinstance(sam2_result, tuple):
+            sam2_predictor = sam2_result[0]
+            logger.info("Extracted predictor from tuple")
+        else:
+            sam2_predictor = sam2_result
+        
         if sam2_predictor is None:
-            st.error("❌ Failed to load SAM2 model")
+            st.error("Failed to load SAM2 model")
             return None
         
         update_progress(0.1, "Loading MatAnyone model...")
-        matanyone_processor = load_matanyone_processor()
+        matanyone_result = load_matanyone_processor()
+        
+        # Handle tuple return from load_matanyone_processor
+        if isinstance(matanyone_result, tuple):
+            matanyone_processor = matanyone_result[0]
+            logger.info("Extracted processor from tuple")
+        else:
+            matanyone_processor = matanyone_result
+        
         if matanyone_processor is None:
-            st.error("❌ Failed to load MatAnyone model")
+            st.error("Failed to load MatAnyone model")
             return None
         
         # Process video
@@ -279,7 +295,7 @@ def update_progress(progress, message):
                 mask = generate_mask_from_video_first_frame(input_path, sam2_predictor)
             
             if mask is None:
-                st.error("❌ Failed to generate mask")
+                st.error("Failed to generate mask")
                 return None
             
             mask_path = str(temp_dir / "mask.png")
@@ -300,13 +316,13 @@ def update_progress(progress, message):
                 
                 logger.info(f"MatAnyone complete - Foreground: {foreground_path}, Alpha: {alpha_path}")
                 
-                # 🔧 FIX: Apply temporal smoothing to alpha channel
+                # Apply temporal smoothing to alpha channel
                 update_progress(0.6, "Applying temporal smoothing to eliminate jitter...")
                 
                 smoothed_alpha_path = str(temp_dir / "alpha_smoothed.mp4")
                 alpha_path = smooth_alpha_video(alpha_path, smoothed_alpha_path, window_size=5)
                 
-                logger.info("✅ Temporal smoothing applied - shaking should be eliminated")
+                logger.info("Temporal smoothing applied - shaking should be eliminated")
                 
                 update_progress(0.8, "Creating transparent .mov file...")
                 
@@ -318,21 +334,21 @@ def update_progress(progress, message):
                     persist_path = TMP_DIR / "transparent_video.mov"
                     shutil.copyfile(transparent_path, persist_path)
                     
-                    update_progress(1.0, "✅ Transparent video created successfully!")
+                    update_progress(1.0, "Transparent video created successfully")
                     time.sleep(0.5)
                     return str(persist_path)
                 else:
-                    st.error("❌ Failed to create transparent video")
+                    st.error("Failed to create transparent video")
                     return None
                     
             except Exception as e:
                 logger.error(f"MatAnyone processing failed: {e}", exc_info=True)
-                st.error(f"❌ MatAnyone processing failed: {e}")
+                st.error(f"MatAnyone processing failed: {e}")
                 return None
     
     except Exception as e:
         logger.error(f"Stage 1 error: {e}", exc_info=True)
-        st.error(f"❌ Stage 1 failed: {e}")
+        st.error(f"Stage 1 failed: {e}")
         
         # Show memory info for debugging
         try:
@@ -359,7 +375,7 @@ def stage2_composite_background(transparent_video_path, background, bg_type):
     STAGE 2: Composite transparent video with new background.
     Fast compositing that can be repeated with different backgrounds.
     """
-    logger.info("🎬 Starting Stage 2: Composite with background")
+    logger.info("Starting Stage 2: Composite with background")
     
     try:
         progress_bar = st.progress(0)
@@ -457,7 +473,7 @@ def update_progress(progress, message):
                 persist_path = TMP_DIR / "final_video.mp4"
                 shutil.copyfile(output_path, persist_path)
                 
-                update_progress(1.0, "✅ Compositing complete!")
+                update_progress(1.0, "Compositing complete")
                 time.sleep(0.5)
                 return str(persist_path)
             else:
@@ -465,5 +481,5 @@ def update_progress(progress, message):
     
     except Exception as e:
         logger.error(f"Stage 2 error: {e}", exc_info=True)
-        st.error(f"❌ Stage 2 failed: {e}")
+        st.error(f"Stage 2 failed: {e}")
         return None