Update utils_init_fixed.py

utils_init_fixed.py

@@ -1,261 +0,0 @@
-"""
-Complete utils/__init__.py with all required functions
-Provides direct implementations to avoid import recursion
-"""
-
-import cv2
-import numpy as np
-from PIL import Image
-import torch
-import logging
-from typing import Optional, Tuple, Dict, Any, List
-import tempfile
-import os
-from app.video_enhancer.matanyone_processor import MatAnyoneProcessor
-
-logger = logging.getLogger(__name__)
-
-# Cached MatAnyone processor (initialized on first use)
-_MATANYONE_PROCESSOR: Optional[MatAnyoneProcessor] = None
-
-# Professional backgrounds configuration
-PROFESSIONAL_BACKGROUNDS = {
-    "office": {"color": (240, 248, 255), "gradient": True},
-    "studio": {"color": (32, 32, 32), "gradient": False},
-    "nature": {"color": (34, 139, 34), "gradient": True},
-    "abstract": {"color": (75, 0, 130), "gradient": True},
-    "white": {"color": (255, 255, 255), "gradient": False},
-    "black": {"color": (0, 0, 0), "gradient": False}
-}
-
-def validate_video_file(video_path: str) -> bool:
-    """Validate if video file is readable"""
-    try:
-        if not os.path.exists(video_path):
-            return False
-        
-        cap = cv2.VideoCapture(video_path)
-        if not cap.isOpened():
-            return False
-            
-        ret, frame = cap.read()
-        cap.release()
-        return ret and frame is not None
-        
-    except Exception as e:
-        logger.error(f"Video validation failed: {e}")
-        return False
-
-def segment_person_hq(frame: np.ndarray, use_sam2: bool = True) -> Optional[np.ndarray]:
-    """High-quality person segmentation using SAM2 or fallback methods"""
-    try:
-        if use_sam2:
-            # Try SAM2 segmentation
-            try:
-                from sam2.sam2_image_predictor import SAM2ImagePredictor
-                from sam2.build_sam import build_sam2
-                from huggingface_hub import hf_hub_download
-                
-                # Load SAM2 model
-                sam_checkpoint = hf_hub_download("facebook/sam2-hiera-base-plus", "sam2_hiera_b+.pt")
-                sam_model = build_sam2(model_name='sam2_hiera_base_plus_t', ckpt_path=sam_checkpoint)
-                predictor = SAM2ImagePredictor(sam_model)
-                
-                # Set image and predict
-                predictor.set_image(frame)
-                
-                # Use center point as prompt (assuming person is in center)
-                h, w = frame.shape[:2]
-                center_point = np.array([[w//2, h//2]])
-                center_label = np.array([1])
-                
-                masks, scores, _ = predictor.predict(
-                    point_coords=center_point,
-                    point_labels=center_label,
-                    multimask_output=False
-                )
-                
-                return masks[0] if len(masks) > 0 else None
-                
-            except Exception as e:
-                logger.warning(f"SAM2 segmentation failed: {e}, falling back to simple method")
-        
-        # Fallback: Simple person detection using background subtraction
-        return _simple_person_segmentation(frame)
-        
-    except Exception as e:
-        logger.error(f"Person segmentation failed: {e}")
-        return None
-
-def _simple_person_segmentation(frame: np.ndarray) -> np.ndarray:
-    """Simple person segmentation using color-based methods"""
-    # Convert to HSV for better color detection
-    hsv = cv2.cvtColor(frame, cv2.COLOR_RGB2HSV)
-    
-    # Create mask for common background colors (green screen, white, etc.)
-    # Green screen detection
-    lower_green = np.array([40, 40, 40])
-    upper_green = np.array([80, 255, 255])
-    green_mask = cv2.inRange(hsv, lower_green, upper_green)
-    
-    # White background detection
-    lower_white = np.array([0, 0, 200])
-    upper_white = np.array([180, 30, 255])
-    white_mask = cv2.inRange(hsv, lower_white, upper_white)
-    
-    # Combine masks
-    bg_mask = cv2.bitwise_or(green_mask, white_mask)
-    
-    # Invert to get person mask
-    person_mask = cv2.bitwise_not(bg_mask)
-    
-    # Clean up mask with morphological operations
-    kernel = np.ones((5, 5), np.uint8)
-    person_mask = cv2.morphologyEx(person_mask, cv2.MORPH_CLOSE, kernel)
-    person_mask = cv2.morphologyEx(person_mask, cv2.MORPH_OPEN, kernel)
-    
-    # Convert to float and normalize
-    return person_mask.astype(np.float32) / 255.0
-
-def refine_mask_hq(mask: np.ndarray, frame: np.ndarray, use_matanyone: bool = True) -> np.ndarray:
-    """High-quality mask refinement using MatAnyone or fallback methods"""
-    try:
-        if use_matanyone:
-            try:
-                global _MATANYONE_PROCESSOR
-                if _MATANYONE_PROCESSOR is None:
-                    _MATANYONE_PROCESSOR = MatAnyoneProcessor()
-
-                # Ensure proper dtypes
-                frame_in = frame if frame.dtype == np.uint8 else frame.astype(np.uint8)
-
-                # Use MatAnyone to produce a refined alpha matte (0..1 float, HxW)
-                alpha = _MATANYONE_PROCESSOR.segment_frame(frame_in, mask_path=None)
-
-                # Sanity clamp and return
-                alpha = np.clip(alpha, 0.0, 1.0).astype(np.float32)
-                return alpha
-
-            except Exception as e:
-                logger.warning(f"MatAnyone refinement failed: {e}, using simple refinement")
-
-        # Fallback: Simple mask refinement
-        return _simple_mask_refinement(mask, frame)
-
-    except Exception as e:
-        logger.error(f"Mask refinement failed: {e}")
-        return mask
-
-def _simple_mask_refinement(mask: np.ndarray, frame: np.ndarray) -> np.ndarray:
-    """Simple mask refinement using OpenCV operations"""
-    # Convert mask to uint8
-    mask_uint8 = (mask * 255).astype(np.uint8)
-    
-    # Apply Gaussian blur for smoother edges
-    mask_blurred = cv2.GaussianBlur(mask_uint8, (5, 5), 0)
-    
-    # Apply bilateral filter to preserve edges while smoothing
-    mask_refined = cv2.bilateralFilter(mask_blurred, 9, 75, 75)
-    
-    # Convert back to float
-    return mask_refined.astype(np.float32) / 255.0
-
-def replace_background_hq(frame: np.ndarray, mask: np.ndarray, background: np.ndarray) -> np.ndarray:
-    """High-quality background replacement with proper compositing"""
-    try:
-        # Ensure all inputs are the same size
-        h, w = frame.shape[:2]
-        background_resized = cv2.resize(background, (w, h))
-        
-        # Ensure mask has 3 channels
-        if len(mask.shape) == 2:
-            mask_3d = np.stack([mask] * 3, axis=-1)
-        else:
-            mask_3d = mask
-        
-        # Apply feathering to mask edges for smoother blending
-        mask_feathered = _apply_feathering(mask_3d)
-        
-        # Composite the image
-        result = frame * mask_feathered + background_resized * (1 - mask_feathered)
-        
-        return result.astype(np.uint8)
-        
-    except Exception as e:
-        logger.error(f"Background replacement failed: {e}")
-        return frame
-
-def _apply_feathering(mask: np.ndarray, feather_amount: int = 3) -> np.ndarray:
-    """Apply feathering to mask edges for smoother blending"""
-    if len(mask.shape) == 3:
-        # Work with single channel
-        mask_single = mask[:, :, 0]
-    else:
-        mask_single = mask
-    
-    # Apply Gaussian blur for feathering
-    mask_feathered = cv2.GaussianBlur(mask_single, (feather_amount*2+1, feather_amount*2+1), 0)
-    
-    # Restore 3 channels if needed
-    if len(mask.shape) == 3:
-        mask_feathered = np.stack([mask_feathered] * 3, axis=-1)
-    
-    return mask_feathered
-
-def create_professional_background(bg_type: str, width: int, height: int) -> np.ndarray:
-    """Create professional background of specified type and size"""
-    try:
-        if bg_type not in PROFESSIONAL_BACKGROUNDS:
-            bg_type = "office"  # Default fallback
-        
-        config = PROFESSIONAL_BACKGROUNDS[bg_type]
-        color = config["color"]
-        use_gradient = config["gradient"]
-        
-        if use_gradient:
-            # Create gradient background
-            background = _create_gradient_background(color, width, height)
-        else:
-            # Create solid color background
-            background = np.full((height, width, 3), color, dtype=np.uint8)
-        
-        return background
-        
-    except Exception as e:
-        logger.error(f"Background creation failed: {e}")
-        # Return white background as fallback
-        return np.full((height, width, 3), (255, 255, 255), dtype=np.uint8)
-
-def _create_gradient_background(base_color: Tuple[int, int, int], width: int, height: int) -> np.ndarray:
-    """Create a gradient background from base color"""
-    # Create gradient from darker to lighter version of base color
-    r, g, b = base_color
-    
-    # Create darker version (multiply by 0.7)
-    dark_color = (int(r * 0.7), int(g * 0.7), int(b * 0.7))
-    
-    # Create gradient
-    background = np.zeros((height, width, 3), dtype=np.uint8)
-    
-    for y in range(height):
-        # Calculate blend factor (0 to 1)
-        blend = y / height
-        
-        # Interpolate between dark and light color
-        current_r = int(dark_color[0] * (1 - blend) + r * blend)
-        current_g = int(dark_color[1] * (1 - blend) + g * blend)
-        current_b = int(dark_color[2] * (1 - blend) + b * blend)
-        
-        background[y, :] = [current_r, current_g, current_b]
-    
-    return background
-
-# Export all functions
-__all__ = [
-    "segment_person_hq",
-    "refine_mask_hq", 
-    "replace_background_hq",
-    "create_professional_background",
-    "PROFESSIONAL_BACKGROUNDS",
-    "validate_video_file"
-]