Upload 23 files

apply_color_transfer.py

@@ -88,8 +88,7 @@ def histogram_matching_with_pixels(source, reference_pixels):
 
 def apply_color_transfer_to_output(swapped_img, original_bg, opacity=0.7, color_region=None):
     """
-    Apply color transfer to make the swapped face match the original background lighting.
-    Automatically uses face+forehead region (excluding hair) as color reference by default.
+    Apply color transfer ONLY to face regions, using face+forehead (excluding hair) as color reference.
     
     Args:
         swapped_img: PIL Image - The image after face swapping
@@ -98,9 +97,11 @@ def apply_color_transfer_to_output(swapped_img, original_bg, opacity=0.7, color_
         color_region: tuple or None - (x, y, width, height) for specific color sampling region
     
     Returns:
-        PIL Image - The color-corrected result
+        PIL Image - The color-corrected result with face-only color transfer
     """
     try:
+        from segmentation import detect_face_and_forehead_no_hair
+        
         # Clamp opacity to valid range
         opacity = max(0.0, min(1.0, opacity))
         
@@ -108,32 +109,50 @@ def apply_color_transfer_to_output(swapped_img, original_bg, opacity=0.7, color_
         swapped_np = np.array(swapped_img.convert('RGB'))
         original_np = np.array(original_bg.convert('RGB'))
         
-        # Try advanced face+forehead detection first (excluding hair)
+        # Get face mask for TARGET (where to apply color transfer)
+        target_face_mask = detect_face_and_forehead_no_hair(swapped_img)
+        
+        # Try advanced face+forehead detection for REFERENCE color
         face_pixels = get_face_forehead_region_no_hair(original_bg)
         
-        if face_pixels is not None:
-            print(f"✅ Using advanced face+forehead detection: {len(face_pixels)} pixels")
-            # Apply color transfer using extracted face+forehead pixels
-            color_corrected = histogram_matching_with_pixels(swapped_np, face_pixels)
+        if face_pixels is not None and target_face_mask.sum() > 0:
+            print(f"✅ Face-only color transfer: {len(face_pixels)} reference pixels → {target_face_mask.sum()} target pixels")
+            
+            # Apply color transfer using extracted face+forehead pixels  
+            color_corrected_full = histogram_matching_with_pixels(swapped_np, face_pixels)
+            
+            # Create result by blending ONLY face regions
+            result = swapped_np.copy()
+            face_indices = target_face_mask == 1
+            
+            # Blend only face pixels
+            result[face_indices] = (
+                swapped_np[face_indices].astype(np.float32) * (1 - opacity) + 
+                color_corrected_full[face_indices].astype(np.float32) * opacity
+            ).astype(np.uint8)
             
         elif color_region is not None:
             # Fallback to manual region if provided
             x, y, w, h = color_region
             reference_region = original_np[y:y+h, x:x+w]
-            if reference_region.size > 0:
-                print(f"⚙️ Using manual region: {color_region}")
-                color_corrected = histogram_matching_with_region(swapped_np, original_np, reference_region)
+            if reference_region.size > 0 and target_face_mask.sum() > 0:
+                print(f"⚙️ Face-only with manual region: {color_region}")
+                color_corrected_full = histogram_matching_with_region(swapped_np, original_np, reference_region)
+                
+                result = swapped_np.copy()
+                face_indices = target_face_mask == 1
+                result[face_indices] = (
+                    swapped_np[face_indices].astype(np.float32) * (1 - opacity) + 
+                    color_corrected_full[face_indices].astype(np.float32) * opacity
+                ).astype(np.uint8)
             else:
-                print("⚠️ Invalid manual region, using full image")
-                color_corrected = histogram_matching(swapped_np, original_np)
+                print("⚠️ Invalid manual region or no face detected")
+                result = swapped_np
                 
         else:
-            # Final fallback to full image
-            print("⚠️ No face detection, using full image color transfer")
-            color_corrected = histogram_matching(swapped_np, original_np)
-        
-        # Blend original and color-corrected image based on opacity
-        result = blend_images(swapped_np, color_corrected, opacity)
+            # No face detection - return original
+            print("⚠️ No face detection, no color transfer applied")
+            result = swapped_np
         
         return Image.fromarray(result)
     

roop/face_analyser.py

@@ -1,6 +1,8 @@
 import threading
 from typing import Any
 import insightface
+import numpy as np
+from PIL import Image
 
 import roop.globals
 from roop.typing import Frame
@@ -19,7 +21,69 @@ def get_face_analyser() -> Any:
     return FACE_ANALYSER
 
 
+def get_precise_face_mask(frame: Frame) -> Any:
+    """
+    Get precise face mask using advanced segmentation (same as detect_face_and_forehead_no_hair).
+    Returns both InsightFace detection and precise mask.
+    """
+    try:
+        # Import the precise detection function
+        import sys
+        import os
+        sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+        from segmentation import detect_face_and_forehead_no_hair
+        
+        # Convert frame to PIL Image
+        if isinstance(frame, np.ndarray):
+            pil_image = Image.fromarray(frame)
+        else:
+            pil_image = frame
+            
+        # Get precise face mask (clean skin only)
+        precise_mask = detect_face_and_forehead_no_hair(pil_image)
+        
+        # Also get InsightFace detection for face swapping compatibility
+        insightface_faces = get_face_analyser().get(frame)
+        
+        return {
+            'precise_mask': precise_mask,
+            'insightface_faces': insightface_faces,
+            'has_face': precise_mask.sum() > 0 and len(insightface_faces) > 0
+        }
+        
+    except Exception as e:
+        print(f"Precise face detection failed: {e}")
+        # Fallback to regular InsightFace
+        insightface_faces = get_face_analyser().get(frame)
+        return {
+            'precise_mask': None,
+            'insightface_faces': insightface_faces,
+            'has_face': len(insightface_faces) > 0
+        }
+
+
 def get_one_face(frame: Frame) -> Any:
+    """
+    Get one face with enhanced precision detection.
+    """
+    # Get precise detection info
+    face_info = get_precise_face_mask(frame)
+    
+    if face_info['has_face'] and face_info['insightface_faces']:
+        try:
+            # Select face (leftmost) for compatibility
+            selected_face = min(face_info['insightface_faces'], key=lambda x: x.bbox[0])
+            
+            # Add precise mask info to face object
+            if face_info['precise_mask'] is not None:
+                selected_face.precise_mask = face_info['precise_mask']
+                print(f"✅ Enhanced face detection: {face_info['precise_mask'].sum()} precise pixels")
+            
+            return selected_face
+        except (ValueError, IndexError):
+            return None
+    
+    # Fallback to original method
     face = get_face_analyser().get(frame)
     try:
         selected_face = min(face, key=lambda x: x.bbox[0])
@@ -27,8 +91,34 @@ def get_one_face(frame: Frame) -> Any:
     except ValueError:
         return None
         
+
 def get_many_faces(frame: Frame) -> Any:
+    """
+    Get many faces with enhanced precision detection.
+    """
+    # Get precise detection info
+    face_info = get_precise_face_mask(frame)
+    
+    if face_info['has_face'] and face_info['insightface_faces']:
+        faces = face_info['insightface_faces']
+        
+        # Add precise mask info to all face objects
+        if face_info['precise_mask'] is not None:
+            for face in faces:
+                face.precise_mask = face_info['precise_mask']
+                
+        print(f"✅ Enhanced multi-face detection: {len(faces)} faces with precise masks")
+        return faces
+    
+    # Fallback to original method
     try:
         return get_face_analyser().get(frame)
     except IndexError:
         return None
+
+
+def has_precise_face_mask(face_obj) -> bool:
+    """
+    Check if face object has precise mask attached.
+    """
+    return hasattr(face_obj, 'precise_mask') and face_obj.precise_mask is not None

roop/processors/frame/face_enhancer.py

@@ -37,7 +37,7 @@ def get_face_enhancer() -> Any:
 def pre_check() -> bool:
     download_directory_path = resolve_relative_path('../models')
     # conditional_download(download_directory_path, ['https://huggingface.co/henryruhs/roop/resolve/main/GFPGANv1.4.pth'])
-    conditional_download(download_directory_path, ['https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth'])
+    conditional_download(download_directory_path, ['https://huggingface.co/VanNguyen1214/detect_face/resolve/main/GFPGANv1.4.pth'])
     return True
 
 

roop/processors/frame/face_swapper.py

@@ -28,7 +28,7 @@ def get_face_swapper() -> Any:
 def pre_check() -> bool:
     download_directory_path = resolve_relative_path('../models')
     # conditional_download(download_directory_path, ['https://huggingface.co/henryruhs/roop/resolve/main/inswapper_128.onnx'])
-    conditional_download(download_directory_path, ['https://huggingface.co/thebiglaskowski/inswapper_128.onnx/resolve/main/inswapper_128.onnx'])
+    conditional_download(download_directory_path, ['https://huggingface.co/VanNguyen1214/detect_face/resolve/main/inswapper_128.onnx'])
     return True
 
 

segmentation.py

@@ -5,6 +5,16 @@ import torch.nn.functional as F
 import numpy as np
 import mediapipe as mp
 import cv2
+import os
+import warnings
+
+# Suppress MediaPipe warnings
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+warnings.filterwarnings('ignore')
+
+# Suppress MediaPipe logs
+import logging
+logging.getLogger('mediapipe').setLevel(logging.ERROR)
 
 # Load model
 processor = SegformerImageProcessor.from_pretrained("VanNguyen1214/get_face_and_hair")