Update utilities.py

utilities.py

@@ -159,26 +159,26 @@
 def download_and_setup_models():
     """ENHANCED download and setup with multiple fallback methods and lazy loading"""
     global sam2_predictor, matanyone_model, models_loaded
-    
+
     with loading_lock:
         if models_loaded:
             return "✅ High-quality models already loaded"
-        
+
         try:
             logger.info("🔄 Starting ENHANCED model loading with multiple fallbacks...")
-            
+
             # Check environment and system capabilities
             is_hf_space = os.getenv("SPACE_ID") is not None
             is_colab = 'google.colab' in sys.modules
             is_kaggle = os.environ.get('KAGGLE_KERNEL_RUN_TYPE') is not None
-            
+
             env_type = "HuggingFace Space" if is_hf_space else "Google Colab" if is_colab else "Kaggle" if is_kaggle else "Local"
             logger.info(f"Environment detected: {env_type}")
-            
+
             # Load PyTorch and check GPU
             import torch
             logger.info(f"✅ PyTorch {torch.__version__} - CUDA: {torch.cuda.is_available()}")
-            
+
             if torch.cuda.is_available():
                 try:
                     gpu_name = torch.cuda.get_device_name(0)
@@ -186,12 +186,36 @@ def download_and_setup_models():
                     logger.info(f"🎮 GPU: {gpu_name} ({gpu_memory:.1f}GB)")
                 except Exception as e:
                     logger.info(f"🎮 GPU available but details unavailable: {e}")
-            
+
             # === ENHANCED SAM2 LOADING WITH MULTIPLE METHODS ===
             sam2_loaded = False
             device = "cuda" if torch.cuda.is_available() else "cpu"
-            
-            # Method 1: Try direct import (requirements.txt installation)
+
+            # --- Improved YAML/config handling ---
+            config_paths = [
+                "./configs",            # Local ./configs directory
+                "/home/user/app/configs",  # Typical in HF spaces
+                os.path.expanduser("~/.cache/sam2/configs"),
+            ]
+            config_dir = None
+            for path in config_paths:
+                if os.path.isdir(path):
+                    config_dir = path
+                    break
+
+            # Copy bundled .yaml files to a found config_dir if not present
+            bundled_configs = ["sam2_hiera_large.yaml", "sam2_hiera_tiny.yaml"]
+            if config_dir:
+                for cfg_file in bundled_configs:
+                    src = Path(cfg_file)
+                    dest = Path(config_dir) / cfg_file
+                    if src.exists() and not dest.exists():
+                        shutil.copyfile(src, dest)
+                        logger.info(f"✅ Copied {cfg_file} to {config_dir}")
+            else:
+                logger.warning("No configs directory found for SAM2! Fallback to default logic.")
+
+            # --- Method 1: Try direct import (requirements.txt installation) ---
             try:
                 logger.info("🔄 SAM2 Method 1: Direct import from requirements...")
                 from sam2.build_sam import build_sam2
@@ -200,13 +224,12 @@ def download_and_setup_models():
                 logger.info("✅ SAM2 imported directly from installed package")
             except ImportError as e:
                 logger.info(f"❌ SAM2 Method 1 failed: {e}")
-            
-            # Method 2: Clone and properly setup SAM2
+
+            # --- Method 2: Clone and properly setup SAM2 ---
             if not sam2_loaded:
                 try:
                     logger.info("🔄 SAM2 Method 2: Cloning and setting up repository...")
                     sam2_dir = "/tmp/segment-anything-2"
-                    
                     if not os.path.exists(sam2_dir):
                         logger.info("📥 Cloning SAM2 repository...")
                         clone_cmd = f"git clone --depth 1 https://github.com/facebookresearch/segment-anything-2.git {sam2_dir}"
@@ -215,38 +238,31 @@ def download_and_setup_models():
                             logger.info("✅ SAM2 repository cloned successfully")
                         else:
                             raise Exception("Git clone failed")
-                    
                     # Add to path
                     if sam2_dir not in sys.path:
                         sys.path.insert(0, sam2_dir)
-                    
                     # Install SAM2 dependencies if needed
                     try:
                         import hydra
                     except ImportError:
                         logger.info("Installing Hydra-core for SAM2 configs...")
                         os.system("pip install hydra-core --quiet")
-                    
                     from sam2.build_sam import build_sam2
                     from sam2.sam2_image_predictor import SAM2ImagePredictor
                     sam2_loaded = True
                     logger.info("✅ SAM2 imported after cloning")
                 except Exception as e:
                     logger.info(f"❌ SAM2 Method 2 failed: {e}")
-            
-            # Method 3: Use simplified SAM2 loading without Hydra configs
+
+            # --- Method 3: Use simplified SAM2 loading without Hydra configs ---
             if not sam2_loaded:
                 try:
                     logger.info("🔄 SAM2 Method 3: Simplified loading without Hydra...")
-                    
                     # Download checkpoint first
                     cache_dir = os.path.expanduser("~/.cache/sam2")
                     os.makedirs(cache_dir, exist_ok=True)
-                    
-                    # Use tiny model for better compatibility
                     checkpoint_url = "https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_tiny.pt"
                     sam2_checkpoint = os.path.join(cache_dir, "sam2_hiera_tiny.pt")
-                    
                     if not os.path.exists(sam2_checkpoint):
                         logger.info("📥 Downloading SAM2 checkpoint...")
                         response = requests.get(checkpoint_url, stream=True)
@@ -255,93 +271,63 @@ def download_and_setup_models():
                                 if chunk:
                                     f.write(chunk)
                         logger.info("✅ Checkpoint downloaded")
-                    
-                    # Try to load the model directly without configs
-                    # This is a simplified approach that may work in some environments
                     checkpoint = torch.load(sam2_checkpoint, map_location=device)
-                    
-                    # Create a simple predictor wrapper
                     class SimpleSAM2Predictor:
                         def __init__(self, checkpoint_path, device):
                             self.device = device
                             self.checkpoint_path = checkpoint_path
                             self.image = None
                             logger.info("Using simplified SAM2 predictor")
-                        
                         def set_image(self, image):
                             self.image = image.copy()
-                        
                         def predict(self, point_coords, point_labels, multimask_output=True):
-                            # Simplified mask prediction
                             if self.image is None:
                                 raise ValueError("No image set")
-                            
                             h, w = self.image.shape[:2]
                             mask = np.zeros((h, w), dtype=np.uint8)
-                            
-                            # Create mask based on points
                             for point in point_coords:
                                 x, y = int(point[0]), int(point[1])
-                                # Create circular mask around point
                                 cv2.circle(mask, (x, y), min(w, h)//4, 255, -1)
-                            
-                            # Refine mask with GrabCut
                             try:
                                 mask_3d = np.zeros((h, w), dtype=np.uint8)
                                 mask_3d[mask > 0] = cv2.GC_PR_FGD
                                 mask_3d[mask == 0] = cv2.GC_PR_BGD
-                                
                                 bgd_model = np.zeros((1, 65), np.float64)
                                 fgd_model = np.zeros((1, 65), np.float64)
-                                
                                 cv2.grabCut(self.image, mask_3d, None, bgd_model, fgd_model, 5, cv2.GC_INIT_WITH_MASK)
-                                
                                 mask = np.where((mask_3d == cv2.GC_FGD) | (mask_3d == cv2.GC_PR_FGD), 255, 0).astype('uint8')
                             except:
                                 pass
-                            
                             return [mask], [1.0], None
-                    
                     sam2_predictor = SimpleSAM2Predictor(sam2_checkpoint, device)
                     sam2_loaded = True
                     logger.info("✅ Using simplified SAM2 predictor")
-                    
                 except Exception as e:
                     logger.info(f"❌ SAM2 Method 3 failed: {e}")
-            
-            # Method 4: Install via pip and try again
+
+            # --- Method 4: Install via pip and try again ---
             if not sam2_loaded:
                 try:
                     logger.info("🔄 SAM2 Method 4: Installing via pip...")
-                    
-                    # Install dependencies first
                     os.system("pip install hydra-core omegaconf --quiet")
-                    
-                    # Clone and install SAM2
                     sam2_dir = "/tmp/sam2_install"
                     if os.path.exists(sam2_dir):
                         shutil.rmtree(sam2_dir)
-                    
                     clone_cmd = f"git clone https://github.com/facebookresearch/segment-anything-2.git {sam2_dir}"
                     os.system(clone_cmd)
-                    
-                    # Install SAM2
                     install_cmd = f"cd {sam2_dir} && pip install -e . --quiet"
                     os.system(install_cmd)
-                    
-                    # Try import again
                     from sam2.build_sam import build_sam2
                     from sam2.sam2_image_predictor import SAM2ImagePredictor
                     sam2_loaded = True
                     logger.info("✅ SAM2 installed and imported via pip")
                 except Exception as e:
                     logger.info(f"❌ SAM2 Method 4 failed: {e}")
-            
+
             if not sam2_loaded:
                 logger.warning("❌ All SAM2 loading methods failed, using OpenCV fallback")
                 sam2_predictor = create_opencv_segmentation_fallback()
             else:
-                # If SAM2 is loaded properly, initialize it
                 if not isinstance(sam2_predictor, object) or sam2_predictor is None:
                     try:
                         # Choose model size based on environment and resources
@@ -353,19 +339,16 @@ def predict(self, point_coords, point_labels, multimask_output=True):
                             model_name = "sam2_hiera_large"
                             checkpoint_url = "https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_large.pt"
                             logger.info("🔧 Using SAM2 Large for maximum quality")
-                        
-                        # Download checkpoint with progress tracking and caching
+                        # Download checkpoint
                         cache_dir = os.path.expanduser("~/.cache/sam2")
                         os.makedirs(cache_dir, exist_ok=True)
                         sam2_checkpoint = os.path.join(cache_dir, f"{model_name}.pt")
-                        
                         if not os.path.exists(sam2_checkpoint):
                             logger.info(f"📥 Downloading {model_name} checkpoint...")
                             try:
                                 response = requests.get(checkpoint_url, stream=True)
                                 total_size = int(response.headers.get('content-length', 0))
                                 downloaded = 0
-                                
                                 with open(sam2_checkpoint, 'wb') as f:
                                     for chunk in response.iter_content(chunk_size=8192):
                                         if chunk:
@@ -374,38 +357,28 @@ def predict(self, point_coords, point_labels, multimask_output=True):
                                             if total_size > 0 and downloaded % (total_size // 20) < 8192:
                                                 percent = (downloaded / total_size) * 100
                                                 logger.info(f"📥 Download progress: {percent:.1f}%")
-                                
                                 logger.info(f"✅ {model_name} downloaded successfully")
                             except Exception as e:
                                 logger.error(f"❌ Download failed: {e}")
                                 raise
                         else:
                             logger.info(f"✅ Using cached {model_name}")
-                        
                         # Load SAM2 model - use the config name without .yaml extension
                         try:
                             logger.info(f"🚀 Loading SAM2 {model_name} on {device}...")
-                            
-                            # The config should be just the model name, not the full filename
-                            model_cfg = model_name  # Use "sam2_hiera_tiny" not "sam2_hiera_tiny.yaml"
-                            
-                            # Memory optimization for limited resources
+                            model_cfg = model_name
                             if device == "cpu" or is_hf_space:
                                 torch.set_num_threads(min(4, os.cpu_count() or 1))
                                 if torch.cuda.is_available():
                                     torch.cuda.empty_cache()
-                            
-                            # Try loading on specified device
                             sam2_model = build_sam2(model_cfg, sam2_checkpoint, device=device)
                             sam2_predictor = SAM2ImagePredictor(sam2_model)
                             logger.info(f"✅ SAM2 model loaded successfully on {device}")
-                            
                         except Exception as e:
                             if device == "cuda":
                                 logger.warning(f"❌ GPU loading failed: {e}")
                                 logger.info("🔄 Trying CPU fallback...")
                                 try:
-                                    # Force CPU loading
                                     sam2_model = build_sam2(model_cfg, sam2_checkpoint, device="cpu")
                                     sam2_predictor = SAM2ImagePredictor(sam2_model)
                                     device = "cpu"
@@ -418,14 +391,12 @@ def predict(self, point_coords, point_labels, multimask_output=True):
                                 logger.error(f"❌ SAM2 loading failed: {e}")
                                 logger.info("🔄 Using OpenCV segmentation fallback")
                                 sam2_predictor = create_opencv_segmentation_fallback()
-                    
                     except Exception as e:
                         logger.error(f"❌ SAM2 initialization failed: {e}")
                         sam2_predictor = create_opencv_segmentation_fallback()
-            
+
             # === ENHANCED MATANYONE LOADING WITH MULTIPLE METHODS ===
             matanyone_loaded = False
-            
             # Method 1: Try HuggingFace Hub integration
             try:
                 logger.info("🔄 MatAnyone Method 1: HuggingFace Hub...")
@@ -436,7 +407,6 @@ def predict(self, point_coords, point_labels, multimask_output=True):
                 logger.info("✅ MatAnyone loaded via HuggingFace Hub")
             except Exception as e:
                 logger.info(f"❌ MatAnyone Method 1 failed: {e}")
-            
             # Method 2: Try direct import
             if not matanyone_loaded:
                 try:
@@ -447,19 +417,16 @@ def predict(self, point_coords, point_labels, multimask_output=True):
                         '/content/MatAnyone',
                         '/kaggle/working/MatAnyone'
                     ]
-                    
                     for path in matanyone_paths:
                         if os.path.exists(path):
                             sys.path.append(path)
                             break
-                    
                     from inference import MatAnyoneInference
                     matanyone_model = MatAnyoneInference()
                     matanyone_loaded = True
                     logger.info("✅ MatAnyone loaded via direct import")
                 except Exception as e:
                     logger.info(f"❌ MatAnyone Method 2 failed: {e}")
-            
             # Method 3: Try GitHub installation
             if not matanyone_loaded:
                 try:
@@ -475,18 +442,16 @@ def predict(self, point_coords, point_labels, multimask_output=True):
                         raise Exception("GitHub install failed")
                 except Exception as e:
                     logger.info(f"❌ MatAnyone Method 3 failed: {e}")
-            
             # Method 4: Enhanced OpenCV fallback (CINEMA QUALITY)
             if not matanyone_loaded:
                 logger.info("🎨 Using ENHANCED OpenCV fallback for cinema-quality matting...")
                 matanyone_model = create_enhanced_matting_fallback()
                 matanyone_loaded = True
-            
+
             # Memory cleanup
             gc.collect()
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()
-            
             models_loaded = True
             gpu_info = ""
             if torch.cuda.is_available() and device == "cuda":
@@ -496,120 +461,85 @@ def predict(self, point_coords, point_labels, multimask_output=True):
                     gpu_info = " (GPU)"
             else:
                 gpu_info = " (CPU)"
-            
             success_msg = f"✅ ENHANCED high-quality models loaded successfully!{gpu_info}"
             logger.info(success_msg)
             return success_msg
-            
+
         except Exception as e:
             error_msg = f"❌ Enhanced loading failed: {str(e)}"
             logger.error(error_msg)
             logger.error(f"Full traceback: {traceback.format_exc()}")
             return error_msg
 
+# ... next: create_opencv_segmentation_fallback(), create_enhanced_matting_fallback(), and much more
+
 def create_opencv_segmentation_fallback():
     """Create comprehensive OpenCV-based segmentation fallback"""
     class OpenCVSegmentationFallback:
         def __init__(self):
             logger.info("🔧 Initializing OpenCV segmentation fallback")
-            # Initialize background subtractor for better segmentation
             self.bg_subtractor = cv2.createBackgroundSubtractorMOG2(detectShadows=True)
             self.image = None
-        
+
         def set_image(self, image):
             self.image = image.copy()
-        
+
         def predict(self, point_coords, point_labels, multimask_output=True):
             """Advanced OpenCV-based person segmentation with multiple techniques"""
             if self.image is None:
                 raise ValueError("No image set")
-            
             h, w = self.image.shape[:2]
-            
             try:
-                # Multi-method segmentation approach
+                # Multi-method segmentation
                 masks = []
-                
-                # Method 1: Skin tone detection
+                # Skin tone detection (HSV ranges)
                 hsv = cv2.cvtColor(self.image, cv2.COLOR_BGR2HSV)
-                
-                # Enhanced skin tone ranges
                 lower_skin1 = np.array([0, 20, 70], dtype=np.uint8)
                 upper_skin1 = np.array([20, 255, 255], dtype=np.uint8)
                 lower_skin2 = np.array([0, 20, 70], dtype=np.uint8)
                 upper_skin2 = np.array([25, 255, 255], dtype=np.uint8)
-                
                 skin_mask1 = cv2.inRange(hsv, lower_skin1, upper_skin1)
                 skin_mask2 = cv2.inRange(hsv, lower_skin2, upper_skin2)
                 skin_mask = cv2.bitwise_or(skin_mask1, skin_mask2)
-                
-                # Method 2: Edge detection for person outline
+                # Edge detection for person outline
                 gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)
                 edges = cv2.Canny(gray, 50, 150)
-                
-                # Method 3: Color-based segmentation
-                lab = cv2.cvtColor(self.image, cv2.COLOR_BGR2LAB)
-                
-                # Method 4: Focus on center region with point guidance
+                # Focus on center region (with point guidance)
                 center_x, center_y = w//2, h//2
                 if len(point_coords) > 0:
-                    # Use provided points as guidance
                     center_x = int(np.mean(point_coords[:, 0]))
                     center_y = int(np.mean(point_coords[:, 1]))
-                
-                # Create center-biased mask
                 center_mask = np.zeros((h, w), dtype=np.uint8)
                 roi_width = w // 3
                 roi_height = h // 2
                 cv2.ellipse(center_mask, (center_x, center_y), (roi_width, roi_height), 0, 0, 360, 255, -1)
-                
-                # Combine different segmentation methods
+                # Combine masks
                 combined_mask = cv2.bitwise_or(skin_mask, edges // 4)
                 combined_mask = cv2.bitwise_and(combined_mask, center_mask)
-                
-                # Morphological operations for cleanup
                 kernel_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
                 kernel_open = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-                
                 combined_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_CLOSE, kernel_close)
                 combined_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_OPEN, kernel_open)
-                
-                # Fill holes using contour detection
                 contours, _ = cv2.findContours(combined_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-                
                 if contours:
-                    # Find largest contour (likely person)
                     largest_contour = max(contours, key=cv2.contourArea)
-                    
-                    # Create mask from largest contour
                     mask = np.zeros((h, w), dtype=np.uint8)
                     cv2.fillPoly(mask, [largest_contour], 255)
-                    
-                    # Smooth the mask
                     mask = cv2.GaussianBlur(mask, (5, 5), 2.0)
                     mask = (mask > 127).astype(np.uint8)
                 else:
-                    # Fallback: use center region
                     mask = center_mask
-                
-                # Additional refinement
                 mask = cv2.medianBlur(mask, 5)
-                
-                # Return in SAM2-compatible format
                 masks.append(mask)
                 scores = [1.0]
-                
                 return masks, scores, None
-                
             except Exception as e:
                 logger.warning(f"OpenCV segmentation error: {e}")
-                # Ultimate fallback: center rectangle
                 mask = np.zeros((h, w), dtype=np.uint8)
                 x1, y1 = w//4, h//6
                 x2, y2 = 3*w//4, 5*h//6
                 mask[y1:y2, x1:x2] = 255
                 return [mask], [1.0], None
-    
     return OpenCVSegmentationFallback()
 
 def create_enhanced_matting_fallback():
@@ -617,66 +547,36 @@ def create_enhanced_matting_fallback():
     class EnhancedMattingFallback:
         def __init__(self):
             logger.info("🎨 Initializing enhanced matting fallback")
-        
         def infer(self, image, mask):
             """Enhanced mask refinement using advanced OpenCV techniques"""
             try:
-                # Ensure proper format
                 if len(mask.shape) == 3:
                     mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
-                
-                # Multi-stage refinement process
-                
-                # Stage 1: Bilateral filter for edge-preserving smoothing
                 refined_mask = cv2.bilateralFilter(mask, 9, 75, 75)
-                
-                # Stage 2: Morphological operations for structure cleanup
                 kernel_ellipse = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
                 refined_mask = cv2.morphologyEx(refined_mask, cv2.MORPH_CLOSE, kernel_ellipse)
                 refined_mask = cv2.morphologyEx(refined_mask, cv2.MORPH_OPEN, kernel_ellipse)
-                
-                # Stage 3: Gaussian blur for smooth edges
                 refined_mask = cv2.GaussianBlur(refined_mask, (3, 3), 1.0)
-                
-                # Stage 4: Edge enhancement for cinema quality
                 edges = cv2.Canny(refined_mask, 50, 150)
                 edge_enhancement = cv2.dilate(edges, np.ones((2, 2), np.uint8), iterations=1)
                 refined_mask = cv2.bitwise_or(refined_mask, edge_enhancement // 4)
-                
-                # Stage 5: Distance transform for smooth transitions
                 dist_transform = cv2.distanceTransform(refined_mask, cv2.DIST_L2, 5)
                 dist_transform = cv2.normalize(dist_transform, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
-                
-                # Combine distance transform with original mask
                 alpha = 0.7
                 refined_mask = cv2.addWeighted(refined_mask, alpha, dist_transform, 1-alpha, 0)
-                
-                # Stage 6: Final smoothing and cleanup
                 refined_mask = cv2.medianBlur(refined_mask, 3)
-                
-                # Stage 7: Ensure smooth gradients at edges
                 refined_mask = cv2.GaussianBlur(refined_mask, (1, 1), 0.5)
-                
                 return refined_mask
-                
             except Exception as e:
                 logger.warning(f"Enhanced matting error: {e}")
                 return mask if len(mask.shape) == 2 else cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
-    
     return EnhancedMattingFallback()
 
-# Keep all other functions unchanged (segment_person_hq, refine_mask_hq, etc.)
-# ... [Include all the remaining functions from the original file here]
-
 def segment_person_hq(image):
     """High-quality person segmentation using SAM2 or fallback with optimized points"""
     try:
-        # Set image for segmentation
         sam2_predictor.set_image(image)
-        
         h, w = image.shape[:2]
-        
-        # Enhanced point selection (covers head, torso, limbs, and edges)
         points = np.array([
             [w//2, h//4],    # Top-center (head)
             [w//2, h//2],    # Center (torso)
@@ -686,39 +586,24 @@ def segment_person_hq(image):
             [w//5, h//5],    # Top-left (hair/accessories)
             [4*w//5, h//5]   # Top-right (hair/accessories)
         ])
-        labels = np.ones(len(points))  # All positive points
-        
-        # Predict with high quality settings
+        labels = np.ones(len(points))
         masks, scores, _ = sam2_predictor.predict(
             point_coords=points,
             point_labels=labels,
             multimask_output=True
         )
-        
-        # Select best mask based on score and size
         best_idx = np.argmax(scores)
         best_mask = masks[best_idx]
-        
-        # Post-processing for better quality
         if len(best_mask.shape) > 2:
             best_mask = best_mask.squeeze()
-        
-        # Ensure binary mask
         if best_mask.dtype != np.uint8:
             best_mask = (best_mask * 255).astype(np.uint8)
-        
-        # Sharper edges (reduced blur)
         kernel = np.ones((3, 3), np.uint8)
         best_mask = cv2.morphologyEx(best_mask, cv2.MORPH_CLOSE, kernel)
-        
-        # Apply reduced Gaussian smoothing for sharper edges
-        best_mask = cv2.GaussianBlur(best_mask.astype(np.float32), (3, 3), 0.8)  # Reduced from 1.0
-        
+        best_mask = cv2.GaussianBlur(best_mask.astype(np.float32), (3, 3), 0.8)
         return (best_mask * 255).astype(np.uint8) if best_mask.max() <= 1.0 else best_mask.astype(np.uint8)
-        
     except Exception as e:
         logger.error(f"Segmentation error: {e}")
-        # Return center region as fallback
         h, w = image.shape[:2]
         fallback_mask = np.zeros((h, w), dtype=np.uint8)
         x1, y1 = w//4, h//6
@@ -729,57 +614,38 @@ def segment_person_hq(image):
 def refine_mask_hq(image, mask):
     """Cinema-quality mask refinement with stronger edge preservation"""
     try:
-        # Apply pre-processing to image for better matting
-        image_filtered = cv2.bilateralFilter(image, 10, 75, 75)  # Increased from 9 to 10
-        
-        # Use MatAnyone or fallback for professional matting
+        image_filtered = cv2.bilateralFilter(image, 10, 75, 75)
         refined_mask = matanyone_model.infer(image_filtered, mask)
-        
-        # Ensure proper format
         if len(refined_mask.shape) == 3:
             refined_mask = cv2.cvtColor(refined_mask, cv2.COLOR_BGR2GRAY)
-        
-        # Stronger edge preservation with bilateral filter
-        refined_mask = cv2.bilateralFilter(refined_mask, 10, 75, 75)  # Increased from default
-        
-        # Post-process for smooth edges
+        refined_mask = cv2.bilateralFilter(refined_mask, 10, 75, 75)
         refined_mask = cv2.medianBlur(refined_mask, 3)
-        
         return refined_mask
-        
     except Exception as e:
         logger.error(f"Mask refinement error: {e}")
-        # Return original mask if refinement fails
         return mask if len(mask.shape) == 2 else cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
 
 def create_green_screen_background(frame):
     """Create green screen background (Stage 1 of two-stage process)"""
     h, w = frame.shape[:2]
-    green_screen = np.full((h, w, 3), (0, 177, 64), dtype=np.uint8)  # Professional green screen color
+    green_screen = np.full((h, w, 3), (0, 177, 64), dtype=np.uint8)
     return green_screen
 
 def create_professional_background(bg_config, width, height):
     """Create professional background based on configuration"""
     try:
         if bg_config["type"] == "color":
-            # 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]  # Convert RGB to BGR
+            color_bgr = color_rgb[::-1]
             background = np.full((height, width, 3), color_bgr, dtype=np.uint8)
-            
         elif bg_config["type"] == "gradient":
             background = create_gradient_background(bg_config, width, height)
-        
         else:
-            # Fallback to solid color
             background = np.full((height, width, 3), (128, 128, 128), dtype=np.uint8)
-        
         return background
-        
     except Exception as e:
         logger.error(f"Background creation error: {e}")
-        # Return neutral gray background as fallback
         return np.full((height, width, 3), (128, 128, 128), dtype=np.uint8)
 
 def create_gradient_background(bg_config, width, height):
@@ -787,8 +653,7 @@ def create_gradient_background(bg_config, width, height):
     try:
         colors = bg_config["colors"]
         direction = bg_config.get("direction", "vertical")
-        
-        # Convert hex colors to RGB
+        # Convert hex to RGB
         rgb_colors = []
         for color_hex in colors:
             color_hex = color_hex.lstrip('#')
@@ -796,17 +661,11 @@ def create_gradient_background(bg_config, width, height):
                 rgb = tuple(int(color_hex[i:i+2], 16) for i in (0, 2, 4))
                 rgb_colors.append(rgb)
             except ValueError:
-                # Fallback for invalid color
                 rgb_colors.append((128, 128, 128))
-        
         if not rgb_colors:
-            rgb_colors = [(128, 128, 128)]  # Fallback color
-        
-        # Create PIL image for high-quality gradients
+            rgb_colors = [(128, 128, 128)]
         pil_img = Image.new('RGB', (width, height))
         draw = ImageDraw.Draw(pil_img)
-        
-        # Helper function for color interpolation
         def interpolate_color(colors, progress):
             if len(colors) == 1:
                 return colors[0]
@@ -816,11 +675,9 @@ def interpolate_color(colors, progress):
                 b = int(colors[0][2] + (colors[1][2] - colors[0][2]) * progress)
                 return (r, g, b)
             else:
-                # Multi-color gradient
                 segment = progress * (len(colors) - 1)
                 idx = int(segment)
                 local_progress = segment - idx
-                
                 if idx >= len(colors) - 1:
                     return colors[-1]
                 else:
@@ -829,23 +686,17 @@ def interpolate_color(colors, 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)
-        
         if direction == "vertical":
-            # Vertical gradient - optimized line drawing
             for y in range(height):
                 progress = y / height if height > 0 else 0
                 color = interpolate_color(rgb_colors, progress)
                 draw.line([(0, y), (width, y)], fill=color)
-        
         elif direction == "horizontal":
-            # Horizontal gradient - optimized line drawing
             for x in range(width):
                 progress = x / width if width > 0 else 0
                 color = interpolate_color(rgb_colors, progress)
                 draw.line([(x, 0), (x, height)], fill=color)
-        
         elif direction == "diagonal":
-            # Diagonal gradient - optimized pixel setting
             max_distance = width + height
             for y in range(height):
                 for x in range(width):
@@ -853,38 +704,27 @@ def interpolate_color(colors, progress):
                     progress = min(1.0, progress)
                     color = interpolate_color(rgb_colors, progress)
                     pil_img.putpixel((x, y), color)
-        
         elif direction in ["radial", "soft_radial"]:
-            # Radial gradient - optimized with center calculation
             center_x, center_y = width // 2, height // 2
             max_distance = np.sqrt(center_x**2 + center_y**2)
-            
             for y in range(height):
                 for x in range(width):
                     distance = np.sqrt((x - center_x)**2 + (y - center_y)**2)
                     progress = distance / max_distance if max_distance > 0 else 0
                     progress = min(1.0, progress)
-                    
                     if direction == "soft_radial":
-                        progress = progress**0.7  # Softer falloff
-                    
+                        progress = progress**0.7
                     color = interpolate_color(rgb_colors, progress)
                     pil_img.putpixel((x, y), color)
-        
         else:
-            # Default to vertical gradient for unknown directions
             for y in range(height):
                 progress = y / height if height > 0 else 0
                 color = interpolate_color(rgb_colors, progress)
                 draw.line([(0, y), (width, y)], fill=color)
-        
-        # Convert PIL to OpenCV format (RGB to BGR)
         background = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
         return background
-        
     except Exception as e:
         logger.error(f"Gradient creation error: {e}")
-        # Return simple gradient fallback
         background = np.zeros((height, width, 3), dtype=np.uint8)
         for y in range(height):
             intensity = int(255 * (y / height)) if height > 0 else 128
@@ -894,53 +734,31 @@ def interpolate_color(colors, progress):
 def replace_background_hq(frame, mask, background):
     """High-quality background replacement with advanced compositing"""
     try:
-        # Resize background to match frame exactly with high-quality interpolation
-        background = cv2.resize(background, (frame.shape[1], frame.shape[0]), 
-                              interpolation=cv2.INTER_LANCZOS4)
-        
-        # Ensure mask is single channel
+        background = cv2.resize(background, (frame.shape[1], frame.shape[0]), interpolation=cv2.INTER_LANCZOS4)
         if len(mask.shape) == 3:
             mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
-        
-        # Convert mask to float and normalize
         mask_float = mask.astype(np.float32) / 255.0
-        
-        # Apply edge feathering for smooth transitions
         feather_radius = 3
         kernel_size = feather_radius * 2 + 1
         mask_feathered = cv2.GaussianBlur(mask_float, (kernel_size, kernel_size), feather_radius/3)
-        
-        # Create 3-channel mask
         mask_3channel = np.stack([mask_feathered] * 3, axis=2)
-        
-        # High-quality compositing with gamma correction for realistic lighting
         frame_linear = np.power(frame.astype(np.float32) / 255.0, 2.2)
         background_linear = np.power(background.astype(np.float32) / 255.0, 2.2)
-        
-        # Composite in linear color space for accurate blending
         result_linear = frame_linear * mask_3channel + background_linear * (1 - mask_3channel)
-        
-        # Convert back to sRGB color space
         result = np.power(result_linear, 1/2.2) * 255.0
         result = np.clip(result, 0, 255).astype(np.uint8)
-        
         return result
-        
     except Exception as e:
         logger.error(f"Background replacement error: {e}")
-        # Simple fallback compositing
         try:
             if len(mask.shape) == 3:
                 mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
-            
             background = cv2.resize(background, (frame.shape[1], frame.shape[0]))
             mask_normalized = mask.astype(np.float32) / 255.0
             mask_3channel = np.stack([mask_normalized] * 3, axis=2)
-            
             result = frame * mask_3channel + background * (1 - mask_3channel)
             return result.astype(np.uint8)
         except:
-            # Ultimate fallback - return original frame
             return frame
 
 def get_model_status():
@@ -957,20 +775,107 @@ def get_model_status():
                     gpu_info = " (GPU Available)"
             else:
                 gpu_info = " (CPU Mode)"
-            
             return f"✅ ENHANCED high-quality models loaded{gpu_info}"
         except:
             return "✅ ENHANCED high-quality models loaded"
     else:
         return "⏳ Models not loaded. Click 'Load Models' for ENHANCED cinema-quality processing."
 
+def validate_video_file(video_path):
+    """Validate video file format and basic properties"""
+    if not video_path or not os.path.exists(video_path):
+        return False, "Video file not found"
+    try:
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            return False, "Cannot open video file"
+        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        if frame_count == 0:
+            return False, "Video appears to be empty"
+        cap.release()
+        return True, "Video file valid"
+    except Exception as e:
+        return False, f"Error validating video: {str(e)}"
+
+def cleanup_temp_files():
+    """Clean up temporary files to free disk space"""
+    try:
+        temp_patterns = [
+            "/tmp/processed_video_*.mp4",
+            "/tmp/final_output_*.mp4",
+            "/tmp/greenscreen_*.mp4",
+            "/tmp/gradient_*.png",
+            "/tmp/*.pt",  # Model checkpoints
+        ]
+        import glob
+        for pattern in temp_patterns:
+            for file_path in glob.glob(pattern):
+                try:
+                    if os.path.exists(file_path):
+                        if time.time() - os.path.getmtime(file_path) > 3600:
+                            os.remove(file_path)
+                            logger.info(f"Cleaned up: {file_path}")
+                except Exception as e:
+                    logger.warning(f"Could not clean up {file_path}: {e}")
+    except Exception as e:
+        logger.warning(f"Cleanup error: {e}")
+
+def get_available_backgrounds():
+    """Get list of available professional backgrounds"""
+    return {key: config["name"] for key, config in PROFESSIONAL_BACKGROUNDS.items()}
+
+def create_custom_gradient(colors, direction="vertical", width=1920, height=1080):
+    """
+    Create a custom gradient background
+    Args:
+        colors: List of hex colors (e.g., ["#ff0000", "#00ff00"])
+        direction: "vertical", "horizontal", "diagonal", "radial"
+        width, height: Dimensions
+    Returns:
+        numpy array of the generated background
+    """
+    try:
+        bg_config = {
+            "type": "gradient",
+            "colors": colors,
+            "direction": direction
+        }
+        return create_gradient_background(bg_config, width, height)
+    except Exception as e:
+        logger.error(f"Error creating custom gradient: {e}")
+        return None
+
+def create_directories():
+    """Create necessary directories for the application"""
+    try:
+        directories = [
+            "/tmp/MyAvatar",
+            "/tmp/MyAvatar/My_Videos",
+            os.path.expanduser("~/.cache/sam2"),
+        ]
+        for directory in directories:
+            os.makedirs(directory, exist_ok=True)
+            logger.info(f"📁 Created/verified directory: {directory}")
+        return True
+    except Exception as e:
+        logger.error(f"Error creating directories: {e}")
+        return False
+
+def optimize_memory_usage():
+    """Optimize memory usage by cleaning up unused resources"""
+    try:
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        gc.collect()
+        cv2.ocl.setUseOpenCL(False)
+        return True
+    except Exception as e:
+        logger.warning(f"Memory optimization failed: {e}")
+        return False
 def create_procedural_background(prompt, style, width, height):
     """Create procedural background based on text prompt and style"""
     try:
-        # Analyze prompt for colors and patterns
         prompt_lower = prompt.lower()
-        
-        # Color mapping based on prompt keywords
         color_map = {
             'blue': ['#1e3c72', '#2a5298', '#3498db'],
             'ocean': ['#74b9ff', '#0984e3', '#00cec9'], 
@@ -994,15 +899,12 @@ def create_procedural_background(prompt, style, width, height):
             'minimal': ['#ffffff', '#f1f2f6', '#ddd'],
             'abstract': ['#6c5ce7', '#a29bfe', '#fd79a8']
         }
-        
-        # Find matching colors
-        selected_colors = ['#3498db', '#2ecc71', '#e74c3c']  # Default
+        selected_colors = ['#3498db', '#2ecc71', '#e74c3c']
         for keyword, colors in color_map.items():
             if keyword in prompt_lower:
                 selected_colors = colors
                 break
-        
-        # Create background based on style
+
         if style == "abstract":
             return create_abstract_background(selected_colors, width, height)
         elif style == "minimalist":
@@ -1014,14 +916,12 @@ def create_procedural_background(prompt, style, width, height):
         elif style == "artistic":
             return create_artistic_background(selected_colors, width, height)
         else:
-            # Default: photorealistic gradient
             bg_config = {
                 "type": "gradient",
                 "colors": selected_colors[:2],
                 "direction": "diagonal"
             }
             return create_gradient_background(bg_config, width, height)
-    
     except Exception as e:
         logger.error(f"Procedural background creation failed: {e}")
         return None
@@ -1030,16 +930,12 @@ def create_abstract_background(colors, width, height):
     """Create abstract geometric background"""
     try:
         background = np.zeros((height, width, 3), dtype=np.uint8)
-        
-        # Convert hex colors to BGR
         bgr_colors = []
         for color in colors:
             hex_color = color.lstrip('#')
             rgb = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
             bgr = rgb[::-1]
             bgr_colors.append(bgr)
-        
-        # Base gradient
         for y in range(height):
             progress = y / height
             color = [
@@ -1047,23 +943,17 @@ def create_abstract_background(colors, width, height):
                 for i in range(3)
             ]
             background[y, :] = color
-        
-        # Add geometric shapes
         import random
-        random.seed(42)  # Reproducible
-        
+        random.seed(42)
         for _ in range(8):
             center_x = random.randint(width//4, 3*width//4)
             center_y = random.randint(height//4, 3*height//4)
             radius = random.randint(width//20, width//8)
             color = bgr_colors[random.randint(0, len(bgr_colors)-1)]
-            
             overlay = background.copy()
             cv2.circle(overlay, (center_x, center_y), radius, color, -1)
             cv2.addWeighted(background, 0.7, overlay, 0.3, 0, background)
-        
         return background
-    
     except Exception as e:
         logger.error(f"Abstract background creation failed: {e}")
         return None
@@ -1077,20 +967,14 @@ def create_minimalist_background(colors, width, height):
             "direction": "soft_radial"
         }
         background = create_gradient_background(bg_config, width, height)
-        
-        # Add subtle element
         overlay = background.copy()
         center_x, center_y = width//2, height//2
-        
         hex_color = colors[0].lstrip('#')
         rgb = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
         bgr = rgb[::-1]
-        
         cv2.circle(overlay, (center_x, center_y), min(width, height)//3, bgr, -1)
         cv2.addWeighted(background, 0.95, overlay, 0.05, 0, background)
-        
         return background
-    
     except Exception as e:
         logger.error(f"Minimalist background creation failed: {e}")
         return None
@@ -1104,20 +988,14 @@ def create_corporate_background(colors, width, height):
             "direction": "diagonal"
         }
         background = create_gradient_background(bg_config, width, height)
-        
-        # Add subtle grid
         grid_color = (80, 80, 80)
         grid_spacing = width // 20
-        
         for x in range(0, width, grid_spacing):
             cv2.line(background, (x, 0), (x, height), grid_color, 1)
-        
         for y in range(0, height, grid_spacing):
             cv2.line(background, (0, y), (width, y), grid_color, 1)
-        
         background = cv2.GaussianBlur(background, (3, 3), 1.0)
         return background
-    
     except Exception as e:
         logger.error(f"Corporate background creation failed: {e}")
         return None
@@ -1131,29 +1009,20 @@ def create_nature_background(colors, width, height):
             "direction": "vertical"
         }
         background = create_gradient_background(bg_config, width, height)
-        
-        # Add organic shapes
         import random
         random.seed(42)
-        
         overlay = background.copy()
-        
         for _ in range(5):
             center_x = random.randint(width//6, 5*width//6)
             center_y = random.randint(height//6, 5*height//6)
-            
             axes_x = random.randint(width//20, width//6)
             axes_y = random.randint(height//20, height//6)
             angle = random.randint(0, 180)
-            
             color = (random.randint(40, 80), random.randint(120, 160), random.randint(30, 70))
             cv2.ellipse(overlay, (center_x, center_y), (axes_x, axes_y), angle, 0, 360, color, -1)
-        
         cv2.addWeighted(background, 0.8, overlay, 0.2, 0, background)
         background = cv2.GaussianBlur(background, (5, 5), 2.0)
-        
         return background
-    
     except Exception as e:
         logger.error(f"Nature background creation failed: {e}")
         return None
@@ -1161,154 +1030,34 @@ def create_nature_background(colors, width, height):
 def create_artistic_background(colors, width, height):
     """Create artistic background with creative elements"""
     try:
-        # Start with base gradient
         bg_config = {
             "type": "gradient",
             "colors": colors,
             "direction": "diagonal"
         }
         background = create_gradient_background(bg_config, width, height)
-        
-        # Add artistic elements
         import random
         random.seed(42)
-        
-        # Convert colors to BGR
         bgr_colors = []
         for color in colors:
             hex_color = color.lstrip('#')
             rgb = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
             bgr_colors.append(rgb[::-1])
-        
         overlay = background.copy()
-        
-        # Add flowing curves
         for i in range(3):
             pts = []
             for x in range(0, width, width//10):
                 y = int(height//2 + (height//4) * np.sin(2 * np.pi * x / width + i))
                 pts.append([x, y])
-            
             pts = np.array(pts, np.int32)
             color = bgr_colors[i % len(bgr_colors)]
             cv2.polylines(overlay, [pts], False, color, thickness=width//50)
-        
-        # Blend with base
         cv2.addWeighted(background, 0.7, overlay, 0.3, 0, background)
-        
-        # Add texture
         background = cv2.GaussianBlur(background, (3, 3), 1.0)
-        
         return background
-    
     except Exception as e:
         logger.error(f"Artistic background creation failed: {e}")
         return None
 
-# Utility functions for validation and cleanup
-def validate_video_file(video_path):
-    """Validate video file format and basic properties"""
-    if not video_path or not os.path.exists(video_path):
-        return False, "Video file not found"
-    
-    try:
-        cap = cv2.VideoCapture(video_path)
-        if not cap.isOpened():
-            return False, "Cannot open video file"
-        
-        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        if frame_count == 0:
-            return False, "Video appears to be empty"
-        
-        cap.release()
-        return True, "Video file valid"
-    except Exception as e:
-        return False, f"Error validating video: {str(e)}"
-
-def cleanup_temp_files():
-    """Clean up temporary files to free disk space"""
-    try:
-        temp_patterns = [
-            "/tmp/processed_video_*.mp4",
-            "/tmp/final_output_*.mp4",
-            "/tmp/greenscreen_*.mp4",
-            "/tmp/gradient_*.png",
-            "/tmp/*.pt",  # Model checkpoints
-        ]
-        
-        import glob
-        for pattern in temp_patterns:
-            for file_path in glob.glob(pattern):
-                try:
-                    if os.path.exists(file_path):
-                        # Only delete files older than 1 hour
-                        if time.time() - os.path.getmtime(file_path) > 3600:
-                            os.remove(file_path)
-                            logger.info(f"Cleaned up: {file_path}")
-                except Exception as e:
-                    logger.warning(f"Could not clean up {file_path}: {e}")
-    except Exception as e:
-        logger.warning(f"Cleanup error: {e}")
-
-def get_available_backgrounds():
-    """Get list of available professional backgrounds"""
-    return {key: config["name"] for key, config in PROFESSIONAL_BACKGROUNDS.items()}
-
-def create_custom_gradient(colors, direction="vertical", width=1920, height=1080):
-    """
-    Create a custom gradient background
-    
-    Args:
-        colors: List of hex colors (e.g., ["#ff0000", "#00ff00"])
-        direction: "vertical", "horizontal", "diagonal", "radial"
-        width, height: Dimensions
-    
-    Returns:
-        numpy array of the generated background
-    """
-    try:
-        bg_config = {
-            "type": "gradient",
-            "colors": colors,
-            "direction": direction
-        }
-        return create_gradient_background(bg_config, width, height)
-    except Exception as e:
-        logger.error(f"Error creating custom gradient: {e}")
-        return None
-
-def create_directories():
-    """Create necessary directories for the application"""
-    try:
-        directories = [
-            "/tmp/MyAvatar",
-            "/tmp/MyAvatar/My_Videos",
-            os.path.expanduser("~/.cache/sam2"),
-        ]
-        
-        for directory in directories:
-            os.makedirs(directory, exist_ok=True)
-            logger.info(f"📁 Created/verified directory: {directory}")
-        
-        return True
-    except Exception as e:
-        logger.error(f"Error creating directories: {e}")
-        return False
+# ========== END OF FILE ==========
 
-def optimize_memory_usage():
-    """Optimize memory usage by cleaning up unused resources"""
-    try:
-        # Clear PyTorch cache
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-        
-        # Run garbage collector
-        gc.collect()
-        
-        # Clear OpenCV cache
-        cv2.ocl.setUseOpenCL(False)
-        
-        return True
-    except Exception as e:
-        logger.warning(f"Memory optimization failed: {e}")
-        return False