Update video_processor.py

video_processor.py

@@ -1,6 +1,7 @@
 """
-Core Video Processing Module
-Handles the main video processing pipeline, frame processing, and background replacement
+Core Video Processing Module - Enhanced with Temporal Consistency
+VERSION: 2.0-temporal-enhanced
+ROLLBACK: Set USE_TEMPORAL_ENHANCEMENT = False to revert to original behavior
 """
 
 import os
@@ -9,7 +10,7 @@
 import time
 import logging
 import threading
-from typing import Optional, Tuple, Dict, Any, Callable
+from typing import Optional, Tuple, Dict, Any, Callable, List
 from pathlib import Path
 
 # Import modular components
@@ -28,11 +29,21 @@
     validate_video_file
 )
 
+# ============================================================================
+# VERSION CONTROL AND FEATURE FLAGS - EASY ROLLBACK
+# ============================================================================
+
+# ROLLBACK CONTROL: Set to False to use original functions
+USE_TEMPORAL_ENHANCEMENT = True
+USE_HAIR_DETECTION = True
+USE_OPTICAL_FLOW_TRACKING = True
+USE_ADAPTIVE_REFINEMENT = True
+
 logger = logging.getLogger(__name__)
 
 class CoreVideoProcessor:
     """
-    Core video processing pipeline for background replacement
+    ENHANCED: Core video processing pipeline with temporal consistency and fine-detail handling
     """
     
     def __init__(self, sam2_predictor: Any, matanyone_model: Any, 
@@ -47,6 +58,12 @@ def __init__(self, sam2_predictor: Any, matanyone_model: Any,
         self.last_refined_mask = None
         self.frame_cache = {}
         
+        # ENHANCED: Temporal consistency state
+        self.mask_history = []  # Store recent masks for temporal smoothing
+        self.optical_flow_data = None  # Previous frame for optical flow
+        self.hair_regions_cache = {}  # Cache detected hair regions
+        self.quality_scores_history = []  # Track quality over time
+        
         # Statistics
         self.stats = {
             'videos_processed': 0,
@@ -57,7 +74,10 @@ def __init__(self, sam2_predictor: Any, matanyone_model: Any,
             'successful_frames': 0,
             'cache_hits': 0,
             'segmentation_errors': 0,
-            'refinement_errors': 0
+            'refinement_errors': 0,
+            'temporal_corrections': 0,  # NEW: Track temporal fixes
+            'hair_detections': 0,       # NEW: Track hair detection success
+            'flow_tracking_failures': 0  # NEW: Track optical flow issues
         }
         
         # Quality settings based on config
@@ -66,6 +86,11 @@ def __init__(self, sam2_predictor: Any, matanyone_model: Any,
         logger.info("CoreVideoProcessor initialized")
         logger.info(f"Quality preset: {config.quality_preset}")
         logger.info(f"Quality settings: {self.quality_settings}")
+        
+        if USE_TEMPORAL_ENHANCEMENT:
+            logger.info("ENHANCED: Temporal consistency enabled")
+        if USE_HAIR_DETECTION:
+            logger.info("ENHANCED: Hair detection enabled")
     
     def process_video(
         self,
@@ -78,19 +103,7 @@ def process_video(
         preview_greenscreen: bool = False
     ) -> Tuple[Optional[str], str]:
         """
-        Process video with background replacement
-        
-        Args:
-            video_path: Input video path
-            background_choice: Background type or name
-            custom_background_path: Path to custom background (if applicable)
-            progress_callback: Progress update callback
-            cancel_event: Event to cancel processing
-            preview_mask: Generate mask preview instead of final output
-            preview_greenscreen: Generate greenscreen preview
-            
-        Returns:
-            Tuple of (output_path, status_message)
+        ENHANCED: Process video with temporal consistency and fine-detail handling
         """
         if self.processing_active:
             return None, "Processing already in progress"
@@ -98,6 +111,9 @@ def process_video(
         self.processing_active = True
         start_time = time.time()
         
+        # ENHANCED: Reset temporal state for new video
+        self._reset_temporal_state()
+        
         try:
             # Validate input video
             is_valid, validation_msg = validate_video_file(video_path)
@@ -140,8 +156,8 @@ def process_video(
                 cap.release()
                 return None, "Could not create output video writer"
             
-            # Process video frames
-            result = self._process_video_frames(
+            # ENHANCED: Process video frames with temporal consistency
+            result = self._process_video_frames_enhanced(
                 cap, out, background, video_info, 
                 progress_callback, cancel_event, 
                 preview_mask, preview_greenscreen
@@ -161,6 +177,8 @@ def process_video(
                     f"Processed: {result['successful_frames']}/{result['total_frames']} frames\n"
                     f"Time: {processing_time:.1f}s\n"
                     f"Average FPS: {result['total_frames'] / processing_time:.1f}\n"
+                    f"Temporal corrections: {self.stats['temporal_corrections']}\n"
+                    f"Hair detections: {self.stats['hair_detections']}\n"
                     f"Background: {background_choice}"
                 )
                 
@@ -180,6 +198,17 @@ def process_video(
         finally:
             self.processing_active = False
     
+    def _reset_temporal_state(self):
+        """ENHANCED: Reset temporal consistency state"""
+        self.mask_history.clear()
+        self.optical_flow_data = None
+        self.hair_regions_cache.clear()
+        self.quality_scores_history.clear()
+        self.last_refined_mask = None
+        self.stats['temporal_corrections'] = 0
+        self.stats['hair_detections'] = 0
+        self.stats['flow_tracking_failures'] = 0
+    
     def _get_video_info(self, cap: cv2.VideoCapture) -> Dict[str, Any]:
         """Extract comprehensive video information"""
         return {
@@ -232,7 +261,7 @@ def _create_video_writer(self, output_path: str,
             logger.error(f"Error creating video writer: {e}")
             return None
     
-    def _process_video_frames(
+    def _process_video_frames_enhanced(
         self,
         cap: cv2.VideoCapture,
         out: cv2.VideoWriter,
@@ -243,7 +272,7 @@ def _process_video_frames(
         preview_mask: bool,
         preview_greenscreen: bool
     ) -> Dict[str, Any]:
-        """Process all video frames"""
+        """ENHANCED: Process all video frames with temporal consistency"""
         
         # Initialize progress tracking
         prog_tracker = progress_tracker.ProgressTracker(
@@ -256,12 +285,11 @@ def _process_video_frames(
         successful_frames = 0
         failed_frames = 0
         
-        # Reset mask cache
-        self.last_refined_mask = None
-        self.frame_cache.clear()
+        # Reset enhanced state
+        self._reset_temporal_state()
         
         try:
-            prog_tracker.set_stage("Processing frames")
+            prog_tracker.set_stage("Processing frames with temporal enhancement")
             
             while True:
                 # Check for cancellation
@@ -281,13 +309,19 @@ def _process_video_frames(
                 
                 try:
                     # Update progress
-                    prog_tracker.update(frame_count, "Processing frame")
+                    prog_tracker.update(frame_count, "Processing frame with temporal consistency")
                     
-                    # Process frame
-                    processed_frame = self._process_single_frame(
-                        frame, background, frame_count, 
-                        preview_mask, preview_greenscreen
-                    )
+                    # ENHANCED: Process frame with temporal consistency
+                    if USE_TEMPORAL_ENHANCEMENT:
+                        processed_frame = self._process_single_frame_enhanced(
+                            frame, background, frame_count, 
+                            preview_mask, preview_greenscreen
+                        )
+                    else:
+                        processed_frame = self._process_single_frame_original(
+                            frame, background, frame_count, 
+                            preview_mask, preview_greenscreen
+                        )
                     
                     # Write processed frame
                     out.write(processed_frame)
@@ -337,7 +371,7 @@ def _process_video_frames(
                 'failed_frames': failed_frames
             }
     
-    def _process_single_frame(
+    def _process_single_frame_enhanced(
         self,
         frame: np.ndarray,
         background: np.ndarray,
@@ -345,7 +379,459 @@ def _process_single_frame(
         preview_mask: bool,
         preview_greenscreen: bool
     ) -> np.ndarray:
-        """Process a single video frame"""
+        """ENHANCED: Process a single video frame with temporal consistency"""
+        
+        try:
+            # Person segmentation
+            mask = self._segment_person_enhanced(frame, frame_number)
+            
+            # ENHANCED: Detect hair and fine details
+            if USE_HAIR_DETECTION:
+                hair_regions = self._detect_hair_regions(frame, mask, frame_number)
+            else:
+                hair_regions = None
+            
+            # ENHANCED: Apply temporal consistency
+            if USE_TEMPORAL_ENHANCEMENT and len(self.mask_history) > 0:
+                mask = self._apply_temporal_consistency_enhanced(frame, mask, frame_number)
+            
+            # ENHANCED: Adaptive mask refinement based on frame content
+            if USE_ADAPTIVE_REFINEMENT:
+                refined_mask = self._adaptive_mask_refinement(frame, mask, frame_number, hair_regions)
+            else:
+                refined_mask = self._refine_mask_original(frame, mask, frame_number)
+            
+            # Store mask in history for temporal consistency
+            self._update_mask_history(refined_mask)
+            
+            # Generate output based on mode
+            if preview_mask:
+                return self._create_mask_preview_enhanced(frame, refined_mask, hair_regions)
+            elif preview_greenscreen:
+                return self._create_greenscreen_preview(frame, refined_mask)
+            else:
+                return self._replace_background_enhanced(frame, refined_mask, background, hair_regions)
+                
+        except Exception as e:
+            logger.warning(f"Enhanced single frame processing failed: {e}")
+            # Fallback to original processing
+            return self._process_single_frame_original(frame, background, frame_number, preview_mask, preview_greenscreen)
+    
+    def _detect_hair_regions(self, frame: np.ndarray, mask: np.ndarray, frame_number: int) -> Optional[np.ndarray]:
+        """ENHANCED: Detect hair and fine detail regions automatically"""
+        try:
+            # Check cache first
+            if frame_number in self.hair_regions_cache:
+                self.stats['cache_hits'] += 1
+                return self.hair_regions_cache[frame_number]
+            
+            # Convert frame to different color spaces for better hair detection
+            hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            
+            # Method 1: Texture-based hair detection
+            # Hair typically has high frequency texture
+            laplacian = cv2.Laplacian(gray, cv2.CV_64F)
+            texture_strength = np.abs(laplacian)
+            
+            # Method 2: Color-based hair detection
+            # Hair is typically in darker hue ranges
+            hair_hue_mask = ((hsv[:,:,0] >= 0) & (hsv[:,:,0] <= 30)) | \
+                           ((hsv[:,:,0] >= 150) & (hsv[:,:,0] <= 180))
+            hair_value_mask = hsv[:,:,2] < 100  # Darker regions
+            
+            # Combine texture and color information
+            hair_probability = np.zeros_like(gray, dtype=np.float32)
+            
+            # High texture regions
+            texture_norm = (texture_strength - texture_strength.min()) / (texture_strength.max() - texture_strength.min() + 1e-8)
+            hair_probability += texture_norm * 0.6
+            
+            # Color-based probability
+            color_prob = (hair_hue_mask.astype(np.float32) * hair_value_mask.astype(np.float32))
+            hair_probability += color_prob * 0.4
+            
+            # Only consider regions near the mask boundary (where hair typically is)
+            mask_boundary = self._get_mask_boundary_region(mask, boundary_width=20)
+            hair_probability *= mask_boundary
+            
+            # Threshold to get hair regions
+            hair_threshold = np.percentile(hair_probability[hair_probability > 0], 75)
+            hair_regions = (hair_probability > hair_threshold).astype(np.uint8)
+            
+            # Clean up hair regions
+            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
+            hair_regions = cv2.morphologyEx(hair_regions, cv2.MORPH_CLOSE, kernel)
+            
+            # Cache the result
+            self.hair_regions_cache[frame_number] = hair_regions
+            
+            # Update stats if hair was detected
+            if np.any(hair_regions):
+                self.stats['hair_detections'] += 1
+                logger.debug(f"Hair regions detected in frame {frame_number}")
+            
+            return hair_regions
+            
+        except Exception as e:
+            logger.warning(f"Hair detection failed for frame {frame_number}: {e}")
+            return None
+    
+    def _get_mask_boundary_region(self, mask: np.ndarray, boundary_width: int = 20) -> np.ndarray:
+        """Get region around mask boundary where hair/fine details are likely"""
+        try:
+            # Create dilated and eroded versions of mask
+            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (boundary_width, boundary_width))
+            dilated = cv2.dilate(mask, kernel, iterations=1)
+            eroded = cv2.erode(mask, kernel, iterations=1)
+            
+            # Boundary region is dilated minus eroded
+            boundary_region = ((dilated > 0) & (eroded == 0)).astype(np.float32)
+            
+            return boundary_region
+            
+        except Exception as e:
+            logger.warning(f"Boundary region detection failed: {e}")
+            return np.ones_like(mask, dtype=np.float32)
+    
+    def _apply_temporal_consistency_enhanced(self, frame: np.ndarray, current_mask: np.ndarray, frame_number: int) -> np.ndarray:
+        """ENHANCED: Apply temporal consistency using optical flow and history"""
+        try:
+            if len(self.mask_history) == 0:
+                return current_mask
+            
+            previous_mask = self.mask_history[-1]
+            
+            # Method 1: Optical flow-based consistency
+            if USE_OPTICAL_FLOW_TRACKING and self.optical_flow_data is not None:
+                try:
+                    flow_corrected_mask = self._apply_optical_flow_consistency(
+                        frame, current_mask, previous_mask
+                    )
+                    
+                    # Blend flow-corrected with current mask
+                    alpha = 0.7  # Weight for current mask
+                    beta = 0.3   # Weight for flow-corrected mask
+                    
+                    blended_mask = cv2.addWeighted(
+                        current_mask.astype(np.float32), alpha,
+                        flow_corrected_mask.astype(np.float32), beta, 0
+                    ).astype(np.uint8)
+                    
+                    self.stats['temporal_corrections'] += 1
+                    
+                except Exception as e:
+                    logger.debug(f"Optical flow consistency failed: {e}")
+                    self.stats['flow_tracking_failures'] += 1
+                    blended_mask = current_mask
+            else:
+                blended_mask = current_mask
+            
+            # Method 2: Multi-frame temporal smoothing
+            if len(self.mask_history) >= 3:
+                # Use weighted average of recent masks
+                weights = [0.5, 0.3, 0.2]  # Current, previous, before previous
+                masks_to_blend = [blended_mask] + self.mask_history[-2:]
+                
+                temporal_mask = np.zeros_like(blended_mask, dtype=np.float32)
+                for mask, weight in zip(masks_to_blend, weights):
+                    temporal_mask += mask.astype(np.float32) * weight
+                
+                blended_mask = np.clip(temporal_mask, 0, 255).astype(np.uint8)
+            
+            # Method 3: Edge-aware temporal filtering
+            blended_mask = self._temporal_edge_filtering(frame, blended_mask, current_mask)
+            
+            return blended_mask
+            
+        except Exception as e:
+            logger.warning(f"Temporal consistency failed: {e}")
+            return current_mask
+    
+    def _apply_optical_flow_consistency(self, current_frame: np.ndarray, 
+                                      current_mask: np.ndarray, previous_mask: np.ndarray) -> np.ndarray:
+        """Apply optical flow to warp previous mask to current frame"""
+        try:
+            # Convert frames to grayscale for optical flow
+            current_gray = cv2.cvtColor(current_frame, cv2.COLOR_BGR2GRAY)
+            previous_gray = self.optical_flow_data
+            
+            # Calculate dense optical flow
+            flow = cv2.calcOpticalFlowPyrLK(previous_gray, current_gray, None, None)
+            
+            # Warp previous mask using optical flow
+            h, w = previous_mask.shape
+            flow_map = np.zeros((h, w, 2), dtype=np.float32)
+            
+            # Create flow field
+            y_coords, x_coords = np.mgrid[0:h, 0:w]
+            flow_map[:, :, 0] = x_coords + flow[0] if flow[0] is not None else x_coords
+            flow_map[:, :, 1] = y_coords + flow[1] if flow[1] is not None else y_coords
+            
+            # Warp previous mask
+            warped_mask = cv2.remap(previous_mask, flow_map, None, cv2.INTER_LINEAR)
+            
+            return warped_mask
+            
+        except Exception as e:
+            logger.debug(f"Optical flow warping failed: {e}")
+            return previous_mask
+    
+    def _temporal_edge_filtering(self, frame: np.ndarray, blended_mask: np.ndarray, current_mask: np.ndarray) -> np.ndarray:
+        """Apply edge-aware temporal filtering"""
+        try:
+            # Detect edges in current frame
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            edges = cv2.Canny(gray, 50, 150)
+            
+            # In edge regions, favor the current mask (more responsive)
+            # In smooth regions, favor the blended mask (more stable)
+            edge_weight = cv2.GaussianBlur(edges.astype(np.float32), (5, 5), 1.0) / 255.0
+            
+            filtered_mask = (current_mask.astype(np.float32) * edge_weight + 
+                           blended_mask.astype(np.float32) * (1 - edge_weight))
+            
+            return np.clip(filtered_mask, 0, 255).astype(np.uint8)
+            
+        except Exception as e:
+            logger.warning(f"Temporal edge filtering failed: {e}")
+            return blended_mask
+    
+    def _adaptive_mask_refinement(self, frame: np.ndarray, mask: np.ndarray, 
+                                frame_number: int, hair_regions: Optional[np.ndarray]) -> np.ndarray:
+        """ENHANCED: Adaptive mask refinement based on content analysis"""
+        try:
+            # Determine refinement strategy based on frame content
+            refinement_needed = self._assess_refinement_needs(frame, mask, hair_regions)
+            
+            if refinement_needed['hair_refinement'] and hair_regions is not None:
+                # Special handling for hair regions
+                mask = self._refine_hair_regions(frame, mask, hair_regions)
+            
+            if refinement_needed['edge_refinement']:
+                # Enhanced edge refinement
+                mask = self._enhanced_edge_refinement(frame, mask)
+            
+            if refinement_needed['temporal_refinement']:
+                # Apply temporal-aware refinement
+                mask = self._temporal_aware_refinement(frame, mask, frame_number)
+            
+            # Standard refinement if needed
+            if self._should_refine_mask(frame_number):
+                if self.matanyone_model is not None and self.quality_settings.get('edge_refinement', True):
+                    mask = refine_mask_hq(frame, mask, self.matanyone_model)
+                else:
+                    mask = self._fallback_mask_refinement_enhanced(mask)
+            
+            return mask
+            
+        except Exception as e:
+            logger.warning(f"Adaptive mask refinement failed: {e}")
+            return self._refine_mask_original(frame, mask, frame_number)
+    
+    def _assess_refinement_needs(self, frame: np.ndarray, mask: np.ndarray, 
+                               hair_regions: Optional[np.ndarray]) -> Dict[str, bool]:
+        """Assess what type of refinement is needed for this frame"""
+        try:
+            needs = {
+                'hair_refinement': False,
+                'edge_refinement': False,
+                'temporal_refinement': False
+            }
+            
+            # Check if hair refinement is needed
+            if hair_regions is not None and np.any(hair_regions):
+                needs['hair_refinement'] = True
+            
+            # Check edge quality
+            edges = cv2.Canny(mask, 50, 150)
+            edge_density = np.sum(edges > 0) / (mask.shape[0] * mask.shape[1])
+            if edge_density > 0.1:  # High edge density suggests rough boundaries
+                needs['edge_refinement'] = True
+            
+            # Check temporal consistency needs
+            if len(self.mask_history) > 0:
+                prev_mask = self.mask_history[-1]
+                diff = cv2.absdiff(mask, prev_mask)
+                change_ratio = np.sum(diff > 50) / (mask.shape[0] * mask.shape[1])
+                if change_ratio > 0.15:  # High change suggests temporal inconsistency
+                    needs['temporal_refinement'] = True
+            
+            return needs
+            
+        except Exception as e:
+            logger.warning(f"Refinement assessment failed: {e}")
+            return {'hair_refinement': False, 'edge_refinement': True, 'temporal_refinement': False}
+    
+    def _refine_hair_regions(self, frame: np.ndarray, mask: np.ndarray, hair_regions: np.ndarray) -> np.ndarray:
+        """Special refinement for hair and fine detail regions"""
+        try:
+            # Create a more aggressive mask for hair regions
+            hair_mask = hair_regions > 0
+            
+            # Use different thresholding for hair areas
+            refined_mask = mask.copy()
+            
+            # In hair regions, use lower threshold (include more pixels)
+            hair_area_values = mask[hair_mask]
+            if len(hair_area_values) > 0:
+                hair_threshold = max(100, np.percentile(hair_area_values, 25))  # Lower threshold for hair
+                refined_mask[hair_mask] = np.where(mask[hair_mask] > hair_threshold, 255, 0)
+            
+            # Apply morphological closing to connect hair strands
+            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2, 2))
+            refined_mask = cv2.morphologyEx(refined_mask, cv2.MORPH_CLOSE, kernel)
+            
+            return refined_mask
+            
+        except Exception as e:
+            logger.warning(f"Hair region refinement failed: {e}")
+            return mask
+    
+    def _enhanced_edge_refinement(self, frame: np.ndarray, mask: np.ndarray) -> np.ndarray:
+        """Enhanced edge refinement using image gradients"""
+        try:
+            # Use bilateral filter to preserve edges while smoothing
+            refined = cv2.bilateralFilter(mask, 9, 75, 75)
+            
+            # Edge-guided smoothing
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            edges = cv2.Canny(gray, 50, 150)
+            
+            # In edge areas, preserve original mask more
+            edge_weight = cv2.GaussianBlur(edges.astype(np.float32), (3, 3), 1.0) / 255.0
+            edge_weight = np.clip(edge_weight * 2, 0, 1)  # Amplify edge influence
+            
+            final_mask = (mask.astype(np.float32) * edge_weight + 
+                         refined.astype(np.float32) * (1 - edge_weight))
+            
+            return np.clip(final_mask, 0, 255).astype(np.uint8)
+            
+        except Exception as e:
+            logger.warning(f"Enhanced edge refinement failed: {e}")
+            return mask
+    
+    def _temporal_aware_refinement(self, frame: np.ndarray, mask: np.ndarray, frame_number: int) -> np.ndarray:
+        """Temporal-aware refinement considering motion and stability"""
+        try:
+            if len(self.mask_history) == 0:
+                return mask
+            
+            # Calculate motion between frames
+            if self.optical_flow_data is not None:
+                current_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+                motion_magnitude = cv2.absdiff(current_gray, self.optical_flow_data)
+                motion_mask = motion_magnitude > 10  # Areas with motion
+                
+                # In high-motion areas, trust current mask more
+                # In low-motion areas, use temporal smoothing
+                prev_mask = self.mask_history[-1]
+                
+                motion_weight = cv2.GaussianBlur(motion_mask.astype(np.float32), (5, 5), 1.0)
+                motion_weight = np.clip(motion_weight, 0.3, 1.0)  # Don't completely ignore temporal info
+                
+                temporal_mask = (mask.astype(np.float32) * motion_weight + 
+                               prev_mask.astype(np.float32) * (1 - motion_weight))
+                
+                return np.clip(temporal_mask, 0, 255).astype(np.uint8)
+            
+            return mask
+            
+        except Exception as e:
+            logger.warning(f"Temporal-aware refinement failed: {e}")
+            return mask
+    
+    def _update_mask_history(self, mask: np.ndarray):
+        """Update mask history for temporal consistency"""
+        self.mask_history.append(mask.copy())
+        
+        # Keep only recent history (limit memory usage)
+        max_history = 5
+        if len(self.mask_history) > max_history:
+            self.mask_history.pop(0)
+    
+    def _create_mask_preview_enhanced(self, frame: np.ndarray, mask: np.ndarray, 
+                                    hair_regions: Optional[np.ndarray]) -> np.ndarray:
+        """ENHANCED: Create mask visualization with hair regions highlighted"""
+        try:
+            # Create colored mask overlay
+            mask_colored = np.zeros_like(frame)
+            mask_colored[:, :, 1] = mask  # Green channel for person
+            
+            # Highlight hair regions in blue if available
+            if hair_regions is not None:
+                mask_colored[:, :, 2] = np.maximum(mask_colored[:, :, 2], hair_regions * 255)
+            
+            # Blend with original frame
+            alpha = 0.6
+            preview = cv2.addWeighted(frame, 1-alpha, mask_colored, alpha, 0)
+            
+            return preview
+            
+        except Exception as e:
+            logger.warning(f"Enhanced mask preview creation failed: {e}")
+            return self._create_mask_preview_original(frame, mask)
+    
+    def _replace_background_enhanced(self, frame: np.ndarray, mask: np.ndarray, 
+                                   background: np.ndarray, hair_regions: Optional[np.ndarray]) -> np.ndarray:
+        """ENHANCED: Replace background with special handling for hair regions"""
+        try:
+            # Standard background replacement
+            result = replace_background_hq(frame, mask, background)
+            
+            # If hair regions detected, apply additional processing
+            if hair_regions is not None and np.any(hair_regions):
+                result = self._enhance_hair_compositing(frame, mask, background, hair_regions, result)
+            
+            return result
+            
+        except Exception as e:
+            logger.warning(f"Enhanced background replacement failed: {e}")
+            return replace_background_hq(frame, mask, background)
+    
+    def _enhance_hair_compositing(self, frame: np.ndarray, mask: np.ndarray, 
+                                background: np.ndarray, hair_regions: np.ndarray, 
+                                initial_result: np.ndarray) -> np.ndarray:
+        """Enhanced compositing specifically for hair regions"""
+        try:
+            # In hair regions, use softer alpha blending
+            hair_mask = hair_regions > 0
+            
+            if np.any(hair_mask):
+                # Create soft alpha for hair regions
+                hair_alpha = cv2.GaussianBlur((hair_regions * mask / 255.0).astype(np.float32), (3, 3), 1.0)
+                hair_alpha = np.clip(hair_alpha, 0, 1)
+                
+                # Apply softer blending only in hair regions
+                for c in range(3):
+                    channel_blend = (frame[:, :, c].astype(np.float32) * hair_alpha + 
+                                   background[:, :, c].astype(np.float32) * (1 - hair_alpha))
+                    
+                    initial_result[:, :, c] = np.where(
+                        hair_mask,
+                        np.clip(channel_blend, 0, 255).astype(np.uint8),
+                        initial_result[:, :, c]
+                    )
+            
+            return initial_result
+            
+        except Exception as e:
+            logger.warning(f"Hair compositing enhancement failed: {e}")
+            return initial_result
+    
+    # ============================================================================
+    # ORIGINAL FUNCTIONS PRESERVED FOR ROLLBACK
+    # ============================================================================
+    
+    def _process_single_frame_original(
+        self,
+        frame: np.ndarray,
+        background: np.ndarray,
+        frame_number: int,
+        preview_mask: bool,
+        preview_greenscreen: bool
+    ) -> np.ndarray:
+        """ORIGINAL: Process a single video frame (preserved for rollback)"""
         
         try:
             # Person segmentation
@@ -353,15 +839,15 @@ def _process_single_frame(
             
             # Mask refinement (keyframe-based for performance)
             if self._should_refine_mask(frame_number):
-                refined_mask = self._refine_mask(frame, mask, frame_number)
+                refined_mask = self._refine_mask_original(frame, mask, frame_number)
                 self.last_refined_mask = refined_mask.copy()
             else:
                 # Use temporal consistency with previous refined mask
-                refined_mask = self._apply_temporal_consistency(mask, frame_number)
+                refined_mask = self._apply_temporal_consistency_original(mask, frame_number)
             
             # Generate output based on mode
             if preview_mask:
-                return self._create_mask_preview(frame, refined_mask)
+                return self._create_mask_preview_original(frame, refined_mask)
             elif preview_greenscreen:
                 return self._create_greenscreen_preview(frame, refined_mask)
             else:
@@ -379,12 +865,35 @@ def _segment_person(self, frame: np.ndarray, frame_number: int) -> np.ndarray:
             if mask is None or mask.size == 0:
                 raise exceptions.SegmentationError(frame_number, "Segmentation returned empty mask")
             
+            # Store current frame for optical flow (if enhanced mode enabled)
+            if USE_OPTICAL_FLOW_TRACKING:
+                current_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+                self.optical_flow_data = current_gray
+            
             return mask
             
         except Exception as e:
             self.stats['segmentation_errors'] += 1
             raise exceptions.SegmentationError(frame_number, f"Segmentation failed: {str(e)}")
     
+    def _segment_person_enhanced(self, frame: np.ndarray, frame_number: int) -> np.ndarray:
+        """ENHANCED: Perform person segmentation with improvements"""
+        try:
+            mask = segment_person_hq(frame, self.sam2_predictor)
+            
+            if mask is None or mask.size == 0:
+                raise exceptions.SegmentationError(frame_number, "Segmentation returned empty mask")
+            
+            # Store current frame for optical flow
+            current_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            self.optical_flow_data = current_gray
+            
+            return mask
+            
+        except Exception as e:
+            self.stats['segmentation_errors'] += 1
+            raise exceptions.SegmentationError(frame_number, f"Enhanced segmentation failed: {str(e)}")
+    
     def _should_refine_mask(self, frame_number: int) -> bool:
         """Determine if mask should be refined for this frame"""
         # Refine on keyframes or if no previous refined mask exists
@@ -394,8 +903,8 @@ def _should_refine_mask(self, frame_number: int) -> bool:
             not self.quality_settings.get('temporal_consistency', True)
         )
     
-    def _refine_mask(self, frame: np.ndarray, mask: np.ndarray, frame_number: int) -> np.ndarray:
-        """Refine mask using MatAnyone or fallback methods"""
+    def _refine_mask_original(self, frame: np.ndarray, mask: np.ndarray, frame_number: int) -> np.ndarray:
+        """ORIGINAL: Refine mask using MatAnyone or fallback methods"""
         try:
             if self.matanyone_model is not None and self.quality_settings.get('edge_refinement', True):
                 refined_mask = refine_mask_hq(frame, mask, self.matanyone_model)
@@ -412,7 +921,7 @@ def _refine_mask(self, frame: np.ndarray, mask: np.ndarray, frame_number: int) -
             return mask
     
     def _fallback_mask_refinement(self, mask: np.ndarray) -> np.ndarray:
-        """Fallback mask refinement using basic OpenCV operations"""
+        """ORIGINAL: Fallback mask refinement using basic OpenCV operations"""
         try:
             # Morphological operations to clean up mask
             kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
@@ -428,8 +937,29 @@ def _fallback_mask_refinement(self, mask: np.ndarray) -> np.ndarray:
             logger.warning(f"Fallback mask refinement failed: {e}")
             return mask
     
-    def _apply_temporal_consistency(self, current_mask: np.ndarray, frame_number: int) -> np.ndarray:
-        """Apply temporal consistency using previous refined mask"""
+    def _fallback_mask_refinement_enhanced(self, mask: np.ndarray) -> np.ndarray:
+        """ENHANCED: Improved fallback mask refinement"""
+        try:
+            # More aggressive morphological operations
+            kernel_small = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2, 2))
+            kernel_large = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+            
+            # Remove small noise
+            refined = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel_small)
+            # Fill gaps
+            refined = cv2.morphologyEx(refined, cv2.MORPH_CLOSE, kernel_large)
+            
+            # Edge smoothing with bilateral filter instead of Gaussian
+            refined = cv2.bilateralFilter(refined, 9, 75, 75)
+            
+            return refined
+            
+        except Exception as e:
+            logger.warning(f"Enhanced fallback mask refinement failed: {e}")
+            return mask
+    
+    def _apply_temporal_consistency_original(self, current_mask: np.ndarray, frame_number: int) -> np.ndarray:
+        """ORIGINAL: Apply temporal consistency using previous refined mask"""
         if self.last_refined_mask is None or not self.quality_settings.get('temporal_consistency', True):
             return current_mask
         
@@ -457,8 +987,8 @@ def _apply_temporal_consistency(self, current_mask: np.ndarray, frame_number: in
             logger.warning(f"Temporal consistency application failed: {e}")
             return current_mask
     
-    def _create_mask_preview(self, frame: np.ndarray, mask: np.ndarray) -> np.ndarray:
-        """Create mask visualization preview"""
+    def _create_mask_preview_original(self, frame: np.ndarray, mask: np.ndarray) -> np.ndarray:
+        """ORIGINAL: Create mask visualization preview"""
         try:
             # Create colored mask overlay
             mask_colored = np.zeros_like(frame)
@@ -510,18 +1040,7 @@ def prepare_background(
         width: int,
         height: int
     ) -> Optional[np.ndarray]:
-        """
-        Prepare background image for processing
-        
-        Args:
-            background_choice: Background type or name
-            custom_background_path: Path to custom background
-            width: Target width
-            height: Target height
-            
-        Returns:
-            Prepared background image or None if failed
-        """
+        """Prepare background image for processing (unchanged)"""
         try:
             if background_choice == "custom" and custom_background_path:
                 if not os.path.exists(custom_background_path):
@@ -576,7 +1095,7 @@ def _update_processing_stats(self, video_info: Dict[str, Any],
     
     def get_processing_capabilities(self) -> Dict[str, Any]:
         """Get current processing capabilities"""
-        return {
+        capabilities = {
             'sam2_available': self.sam2_predictor is not None,
             'matanyone_available': self.matanyone_model is not None,
             'quality_preset': self.config.quality_preset,
@@ -587,10 +1106,21 @@ def get_processing_capabilities(self) -> Dict[str, Any]:
             'supported_formats': ['.mp4', '.avi', '.mov', '.mkv'],
             'memory_limit_gb': self.memory_manager.memory_limit_gb
         }
+        
+        # Add enhanced capabilities
+        if USE_TEMPORAL_ENHANCEMENT:
+            capabilities.update({
+                'temporal_enhancement': True,
+                'hair_detection': USE_HAIR_DETECTION,
+                'optical_flow_tracking': USE_OPTICAL_FLOW_TRACKING,
+                'adaptive_refinement': USE_ADAPTIVE_REFINEMENT
+            })
+        
+        return capabilities
     
     def get_status(self) -> Dict[str, Any]:
         """Get current processor status"""
-        return {
+        status = {
             'processing_active': self.processing_active,
             'models_available': {
                 'sam2': self.sam2_predictor is not None,
@@ -602,6 +1132,16 @@ def get_status(self) -> Dict[str, Any]:
             'memory_usage': self.memory_manager.get_memory_usage(),
             'capabilities': self.get_processing_capabilities()
         }
+        
+        # Add enhanced status
+        if USE_TEMPORAL_ENHANCEMENT:
+            status.update({
+                'mask_history_length': len(self.mask_history),
+                'hair_cache_size': len(self.hair_regions_cache),
+                'optical_flow_active': self.optical_flow_data is not None
+            })
+        
+        return status
     
     def optimize_for_video(self, video_info: Dict[str, Any]) -> Dict[str, Any]:
         """Optimize settings for specific video characteristics"""
@@ -656,6 +1196,7 @@ def reset_cache(self):
         self.frame_cache.clear()
         self.last_refined_mask = None
         self.stats['cache_hits'] = 0
+        self._reset_temporal_state()
         logger.debug("Frame cache and temporal state reset")
     
     def cleanup(self):