Update utils/utils.py

utils/utils.py

@@ -1479,4 +1479,218 @@ def _advanced_compositing(frame: np.ndarray, mask: np.ndarray, background: np.nd
         raise
 
 def _color_match_edges(frame: np.ndarray, background: np.ndarray, alpha: np.ndarray) -> np.ndarray:
-    """
+    """Subtle color matching at edges to reduce halos"""
+    try:
+        edge_mask = cv2.Sobel(alpha, cv2.CV_64F, 1, 1, ksize=3)
+        edge_mask = np.abs(edge_mask)
+        edge_mask = (edge_mask > 0.1).astype(np.float32)
+        
+        edge_areas = edge_mask > 0
+        if not np.any(edge_areas):
+            return frame
+        
+        frame_adjusted = frame.copy().astype(np.float32)
+        background_float = background.astype(np.float32)
+        
+        adjustment_strength = 0.1
+        for c in range(3):
+            frame_adjusted[:, :, c] = np.where(
+                edge_areas,
+                frame_adjusted[:, :, c] * (1 - adjustment_strength) + 
+                background_float[:, :, c] * adjustment_strength,
+                frame_adjusted[:, :, c]
+            )
+        
+        return np.clip(frame_adjusted, 0, 255).astype(np.uint8)
+        
+    except Exception as e:
+        logger.warning(f"Color matching failed: {e}")
+        return frame
+
+def _simple_compositing(frame: np.ndarray, mask: np.ndarray, background: np.ndarray) -> np.ndarray:
+    """Simple fallback compositing method"""
+    try:
+        logger.info("Using simple compositing fallback")
+        
+        background = cv2.resize(background, (frame.shape[1], frame.shape[0]))
+        
+        if len(mask.shape) == 3:
+            mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
+        if mask.max() <= 1.0:
+            mask = (mask * 255).astype(np.uint8)
+        
+        _, mask_binary = cv2.threshold(mask, 127, 255, cv2.THRESH_BINARY)
+        
+        mask_norm = mask_binary.astype(np.float32) / 255.0
+        mask_3ch = np.stack([mask_norm] * 3, axis=2)
+        
+        result = frame * mask_3ch + background * (1 - mask_3ch)
+        return result.astype(np.uint8)
+        
+    except Exception as e:
+        logger.error(f"Simple compositing failed: {e}")
+        return frame
+
+def _create_solid_background(bg_config: Dict[str, Any], width: int, height: int) -> np.ndarray:
+    """Create solid color background"""
+    color_hex = bg_config["colors"][0].lstrip('#')
+    color_rgb = tuple(int(color_hex[i:i+2], 16) for i in (0, 2, 4))
+    color_bgr = color_rgb[::-1]
+    return np.full((height, width, 3), color_bgr, dtype=np.uint8)
+
+def _create_gradient_background_enhanced(bg_config: Dict[str, Any], width: int, height: int) -> np.ndarray:
+    """Create enhanced gradient background with better quality"""
+    try:
+        colors = bg_config["colors"]
+        direction = bg_config.get("direction", "vertical")
+        
+        rgb_colors = []
+        for color_hex in colors:
+            color_hex = color_hex.lstrip('#')
+            rgb = tuple(int(color_hex[i:i+2], 16) for i in (0, 2, 4))
+            rgb_colors.append(rgb)
+        
+        if not rgb_colors:
+            rgb_colors = [(128, 128, 128)]
+        
+        if direction == "vertical":
+            background = _create_vertical_gradient(rgb_colors, width, height)
+        elif direction == "horizontal":
+            background = _create_horizontal_gradient(rgb_colors, width, height)
+        elif direction == "diagonal":
+            background = _create_diagonal_gradient(rgb_colors, width, height)
+        elif direction in ["radial", "soft_radial"]:
+            background = _create_radial_gradient(rgb_colors, width, height, direction == "soft_radial")
+        else:
+            background = _create_vertical_gradient(rgb_colors, width, height)
+        
+        return cv2.cvtColor(background, cv2.COLOR_RGB2BGR)
+        
+    except Exception as e:
+        logger.error(f"Gradient creation error: {e}")
+        return np.full((height, width, 3), (128, 128, 128), dtype=np.uint8)
+
+def _create_vertical_gradient(colors: list, width: int, height: int) -> np.ndarray:
+    """Create vertical gradient using NumPy for performance"""
+    gradient = np.zeros((height, width, 3), dtype=np.uint8)
+    
+    for y in range(height):
+        progress = y / height if height > 0 else 0
+        color = _interpolate_color(colors, progress)
+        gradient[y, :] = color
+    
+    return gradient
+
+def _create_horizontal_gradient(colors: list, width: int, height: int) -> np.ndarray:
+    """Create horizontal gradient using NumPy for performance"""
+    gradient = np.zeros((height, width, 3), dtype=np.uint8)
+    
+    for x in range(width):
+        progress = x / width if width > 0 else 0
+        color = _interpolate_color(colors, progress)
+        gradient[:, x] = color
+    
+    return gradient
+
+def _create_diagonal_gradient(colors: list, width: int, height: int) -> np.ndarray:
+    """Create diagonal gradient using vectorized operations"""
+    y_coords, x_coords = np.mgrid[0:height, 0:width]
+    max_distance = width + height
+    progress = (x_coords + y_coords) / max_distance
+    progress = np.clip(progress, 0, 1)
+    
+    gradient = np.zeros((height, width, 3), dtype=np.uint8)
+    for c in range(3):
+        gradient[:, :, c] = _vectorized_color_interpolation(colors, progress, c)
+    
+    return gradient
+
+def _create_radial_gradient(colors: list, width: int, height: int, soft: bool = False) -> np.ndarray:
+    """Create radial gradient using vectorized operations"""
+    center_x, center_y = width // 2, height // 2
+    max_distance = np.sqrt(center_x**2 + center_y**2)
+    
+    y_coords, x_coords = np.mgrid[0:height, 0:width]
+    distances = np.sqrt((x_coords - center_x)**2 + (y_coords - center_y)**2)
+    progress = distances / max_distance
+    progress = np.clip(progress, 0, 1)
+    
+    if soft:
+        progress = np.power(progress, 0.7)
+    
+    gradient = np.zeros((height, width, 3), dtype=np.uint8)
+    for c in range(3):
+        gradient[:, :, c] = _vectorized_color_interpolation(colors, progress, c)
+    
+    return gradient
+
+def _vectorized_color_interpolation(colors: list, progress: np.ndarray, channel: int) -> np.ndarray:
+    """Vectorized color interpolation for performance"""
+    if len(colors) == 1:
+        return np.full_like(progress, colors[0][channel], dtype=np.uint8)
+    
+    num_segments = len(colors) - 1
+    segment_progress = progress * num_segments
+    segment_indices = np.floor(segment_progress).astype(int)
+    segment_indices = np.clip(segment_indices, 0, num_segments - 1)
+    local_progress = segment_progress - segment_indices
+    
+    start_colors = np.array([colors[i][channel] for i in range(len(colors))])
+    end_colors = np.array([colors[min(i + 1, len(colors) - 1)][channel] for i in range(len(colors))])
+    
+    start_vals = start_colors[segment_indices]
+    end_vals = end_colors[segment_indices]
+    
+    result = start_vals + (end_vals - start_vals) * local_progress
+    return np.clip(result, 0, 255).astype(np.uint8)
+
+def _interpolate_color(colors: list, progress: float) -> tuple:
+    """Interpolate between multiple colors"""
+    if len(colors) == 1:
+        return colors[0]
+    elif len(colors) == 2:
+        r = int(colors[0][0] + (colors[1][0] - colors[0][0]) * progress)
+        g = int(colors[0][1] + (colors[1][1] - colors[0][1]) * progress)
+        b = int(colors[0][2] + (colors[1][2] - colors[0][2]) * progress)
+        return (r, g, b)
+    else:
+        segment = progress * (len(colors) - 1)
+        idx = int(segment)
+        local_progress = segment - idx
+        if idx >= len(colors) - 1:
+            return colors[-1]
+        c1, c2 = colors[idx], colors[idx + 1]
+        r = int(c1[0] + (c2[0] - c1[0]) * local_progress)
+        g = int(c1[1] + (c2[1] - c1[1]) * local_progress)
+        b = int(c1[2] + (c2[2] - c1[2]) * local_progress)
+        return (r, g, b)
+
+def _apply_background_adjustments(background: np.ndarray, bg_config: Dict[str, Any]) -> np.ndarray:
+    """Apply brightness and contrast adjustments to background"""
+    try:
+        brightness = bg_config.get("brightness", 1.0)
+        contrast = bg_config.get("contrast", 1.0)
+        
+        if brightness != 1.0 or contrast != 1.0:
+            background = background.astype(np.float32)
+            background = background * contrast * brightness
+            background = np.clip(background, 0, 255).astype(np.uint8)
+        
+        return background
+        
+    except Exception as e:
+        logger.warning(f"Background adjustment failed: {e}")
+        return background
+
+# ============================================================================
+# DEFAULT INSTANCES
+# ============================================================================
+
+_default_file_manager = None
+
+def get_file_manager(base_dir: Optional[str] = None) -> FileManager:
+    """Get or create the default FileManager instance"""
+    global _default_file_manager
+    if _default_file_manager is None or base_dir is not None:
+        _default_file_manager = FileManager(base_dir)
+    return _default_file_manager