Adds reface ratio option

README.md

@@ -47,6 +47,7 @@ Evolved from the foundations of the [Refacer](https://github.com/xaviviro/reface
  * **Single Face** (Fast): all faces are replaced with a single face. Ideal for images, GIFs or videos with a single face
  * **Multiple Faces** (Fast): faces are replaced with the faces you provide based on their order from left to right
  * **Faces by Match** (Slower): faces are first detected and replaced with the faces you provide.
+* Reface ratio: full face to half face.
 * Improved GPU detection
 * Support for multi-page TIFF
 * Uses local Gradio cache with auto-cleanup on startup 

app.py

@@ -56,8 +56,9 @@ def run_image(*vars):
     image_path = vars[0]
     origins = vars[1:(num_faces+1)]
     destinations = vars[(num_faces+1):(num_faces*2)+1]
-    thresholds = vars[(num_faces*2)+1:-1]
+    thresholds = vars[(num_faces*2)+1:-2]
-    face_mode = vars[-1]
+    face_mode = vars[-2]
+    partial_reface_ratio = vars[-1]
 
     disable_similarity = (face_mode in ["Single Face", "Multiple Faces"])
     multiple_faces_mode = (face_mode == "Multiple Faces")
@@ -71,15 +72,16 @@ def run_image(*vars):
                 'threshold': thresholds[k] if not multiple_faces_mode else 0.0
             })
 
-    return refacer.reface_image(image_path, faces, disable_similarity=disable_similarity, multiple_faces_mode=multiple_faces_mode)
+    return refacer.reface_image(image_path, faces, disable_similarity=disable_similarity, multiple_faces_mode=multiple_faces_mode, partial_reface_ratio=partial_reface_ratio)
 
 def run(*vars):
     video_path = vars[0]
     origins = vars[1:(num_faces+1)]
     destinations = vars[(num_faces+1):(num_faces*2)+1]
-    thresholds = vars[(num_faces*2)+1:-2]
+    thresholds = vars[(num_faces*2)+1:-3]
-    preview = vars[-2]
+    preview = vars[-3]
-    face_mode = vars[-1]
+    face_mode = vars[-2]
+    partial_reface_ratio = vars[-1]
 
     disable_similarity = (face_mode in ["Single Face", "Multiple Faces"])
     multiple_faces_mode = (face_mode == "Multiple Faces")
@@ -93,7 +95,7 @@ def run(*vars):
                 'threshold': thresholds[k] if not multiple_faces_mode else 0.0
             })
 
-    mp4_path, gif_path = refacer.reface(video_path, faces, preview=preview, disable_similarity=disable_similarity, multiple_faces_mode=multiple_faces_mode)
+    mp4_path, gif_path = refacer.reface(video_path, faces, preview=preview, disable_similarity=disable_similarity, multiple_faces_mode=multiple_faces_mode, partial_reface_ratio=partial_reface_ratio)
     return mp4_path, gif_path if gif_path else None
 
 def load_first_frame(filepath):
@@ -106,36 +108,26 @@ def extract_faces_auto(filepath, refacer_instance, max_faces=5, isvideo=False):
     if filepath is None:
         return [None] * max_faces
 
-    # Check if video is too large
+    if isvideo and os.path.getsize(filepath) > 5 * 1024 * 1024:
-    if isvideo:
-        if os.path.getsize(filepath) > 5 * 1024 * 1024:  # larger than 5MB
         print("Video too large for auto-extract, skipping face extraction.")
         return [None] * max_faces
 
-    # Load first frame
     frame = load_first_frame(filepath)
     if frame is None:
         return [None] * max_faces
 
-    print("Loaded frame shape:", frame.shape)
-
-    # Handle weird TIFF/multipage dimensions
     while len(frame.shape) > 3:
-        frame = frame[0]  # Keep taking the first slice until (H, W, C)
+        frame = frame[0]
-
-    print("Fixed frame shape:", frame.shape)
 
     if frame.shape[-1] != 3:
         raise ValueError(f"Expected last dimension to be 3 (RGB), but got {frame.shape[-1]}")
 
-    # Create temp image inside ./tmp
     temp_image_path = os.path.join("./tmp", f"temp_face_extract_{int(time.time() * 1000)}.png")
     Image.fromarray(frame).save(temp_image_path)
 
     try:
         faces = refacer_instance.extract_faces_from_image(temp_image_path, max_faces=max_faces)
-        output_faces = faces + [None] * (max_faces - len(faces))
+        return faces + [None] * (max_faces - len(faces))
-        return output_faces
     finally:
         if os.path.exists(temp_image_path):
             try:
@@ -155,8 +147,14 @@ def toggle_tabs_and_faces(mode, face_tabs, origin_faces):
         origin_updates = [gr.update(visible=True) for _ in range(len(origin_faces))]
     return tab_updates + origin_updates
     
-# --- UI ---
+def handle_tif_preview(filepath):
+    if filepath is None:
+        return None
+    preview_path = os.path.join("./tmp", f"tif_preview_{int(time.time() * 1000)}.jpg")
+    Image.open(filepath).convert('RGB').save(preview_path)
+    return preview_path
 
+# --- UI ---
 theme = gr.themes.Base(primary_hue="blue", secondary_hue="cyan")
 
 with gr.Blocks(theme=theme, title="NeoRefacer - AI Refacer") as demo:
@@ -179,11 +177,8 @@ with gr.Blocks(theme=theme, title="NeoRefacer - AI Refacer") as demo:
             image_output = gr.Image(label="Refaced image", interactive=False, type="filepath")
 
         with gr.Row():
-            face_mode_image = gr.Radio(
+            face_mode_image = gr.Radio(["Single Face", "Multiple Faces", "Faces By Match"], value="Single Face", label="Replacement Mode")
-                choices=["Single Face", "Multiple Faces", "Faces By Match"],
+            partial_reface_ratio_image = gr.Slider(label="Reface Ratio (0 = Full Face, 0.5 = Half Face)", minimum=0.0, maximum=0.5, value=0.0, step=0.1)
-                value="Single Face",
-                label="Replacement Mode"
-            )
             image_btn = gr.Button("Reface Image", variant="primary")
 
         origin_image, destination_image, thresholds_image, face_tabs_image = [], [], [], []
@@ -199,29 +194,12 @@ with gr.Blocks(theme=theme, title="NeoRefacer - AI Refacer") as demo:
             thresholds_image.append(threshold)
             face_tabs_image.append(tab)
 
-        face_mode_image.change(
+        face_mode_image.change(fn=lambda mode: toggle_tabs_and_faces(mode, face_tabs_image, origin_image), inputs=[face_mode_image], outputs=face_tabs_image + origin_image)
-            fn=lambda mode: toggle_tabs_and_faces(mode, face_tabs_image, origin_image),
+        demo.load(fn=lambda: toggle_tabs_and_faces("Single Face", face_tabs_image, origin_image), inputs=None, outputs=face_tabs_image + origin_image)
-            inputs=[face_mode_image],
-            outputs=face_tabs_image + origin_image
-        )
 
-        demo.load(
+        image_btn.click(fn=run_image, inputs=[image_input] + origin_image + destination_image + thresholds_image + [face_mode_image, partial_reface_ratio_image], outputs=[image_output])
-            fn=lambda: toggle_tabs_and_faces("Single Face", face_tabs_image, origin_image),
+        image_input.change(fn=lambda filepath: extract_faces_auto(filepath, refacer, max_faces=num_faces), inputs=image_input, outputs=origin_image)
-            inputs=None,
+        image_input.change(fn=lambda _: 0.0, inputs=image_input, outputs=partial_reface_ratio_image)
-            outputs=face_tabs_image + origin_image
-        )
-
-        image_btn.click(
-            fn=run_image,
-            inputs=[image_input] + origin_image + destination_image + thresholds_image + [face_mode_image],
-            outputs=[image_output]
-        )
-
-        image_input.change(
-            fn=lambda filepath: extract_faces_auto(filepath, refacer, max_faces=num_faces),
-            inputs=image_input,
-            outputs=origin_image
-        )
 
     # --- GIF MODE ---
     with gr.Tab("GIF Mode"):
@@ -232,13 +210,9 @@ with gr.Blocks(theme=theme, title="NeoRefacer - AI Refacer") as demo:
             gif_file_output = gr.Image(label="Refaced GIF (GIF)", type="filepath")
 
         with gr.Row():
-            face_mode_gif = gr.Radio(
+            face_mode_gif = gr.Radio(["Single Face", "Multiple Faces", "Faces By Match"], value="Single Face", label="Replacement Mode")
-                choices=["Single Face", "Multiple Faces", "Faces By Match"],
+            partial_reface_ratio_gif = gr.Slider(label="Reface Ratio (0 = Full Face, 0.5 = Half Face)", minimum=0.0, maximum=0.5, value=0.0, step=0.1)
-                value="Single Face",
-                label="Replacement Mode"
-            )
             gif_btn = gr.Button("Reface GIF", variant="primary")
-
             preview_checkbox_gif = gr.Checkbox(label="Preview Generation (skip 90% of frames)", value=False)
 
         origin_gif, destination_gif, thresholds_gif, face_tabs_gif = [], [], [], []
@@ -254,34 +228,15 @@ with gr.Blocks(theme=theme, title="NeoRefacer - AI Refacer") as demo:
             thresholds_gif.append(threshold)
             face_tabs_gif.append(tab)
 
-        face_mode_gif.change(
+        face_mode_gif.change(fn=lambda mode: toggle_tabs_and_faces(mode, face_tabs_gif, origin_gif), inputs=[face_mode_gif], outputs=face_tabs_gif + origin_gif)
-            fn=lambda mode: toggle_tabs_and_faces(mode, face_tabs_gif, origin_gif),
+        demo.load(fn=lambda: toggle_tabs_and_faces("Single Face", face_tabs_gif, origin_gif), inputs=None, outputs=face_tabs_gif + origin_gif)
-            inputs=[face_mode_gif],
-            outputs=face_tabs_gif + origin_gif
-        )
 
-        demo.load(
+        gif_btn.click(fn=run, inputs=[gif_input] + origin_gif + destination_gif + thresholds_gif + [preview_checkbox_gif, face_mode_gif, partial_reface_ratio_gif], outputs=[gif_output, gif_file_output])
-            fn=lambda: toggle_tabs_and_faces("Single Face", face_tabs_gif, origin_gif),
-            inputs=None,
-            outputs=face_tabs_gif + origin_gif
-        )
 
-        gif_btn.click(
+        gif_input.change(fn=lambda filepath: extract_faces_auto(filepath, refacer, max_faces=num_faces), inputs=gif_input, outputs=origin_gif)
-            fn=lambda *args: run(*args),
+        gif_input.change(fn=lambda file: file, inputs=gif_input, outputs=[gif_preview])
-            inputs=[gif_input] + origin_gif + destination_gif + thresholds_gif + [preview_checkbox_gif, face_mode_gif],
+        gif_input.change(fn=lambda _: 0.0, inputs=gif_input, outputs=partial_reface_ratio_gif)
-            outputs=[gif_output, gif_file_output]
-        )
 
-        gif_input.change(
-            fn=lambda filepath: extract_faces_auto(filepath, refacer, max_faces=num_faces),
-            inputs=gif_input,
-            outputs=origin_gif
-        )
-        gif_input.change(
-            fn=lambda file: file,
-            inputs=gif_input,
-            outputs=[gif_preview]
-        )
         
     # --- TIF MODE ---
     with gr.Tab("TIFF Mode"):
@@ -297,6 +252,7 @@ with gr.Blocks(theme=theme, title="NeoRefacer - AI Refacer") as demo:
                 value="Single Face",
                 label="Replacement Mode"
             )
+            partial_reface_ratio_tif = gr.Slider(label="Reface Ratio (0 = Full Face, 0.5 = Half Face)", minimum=0.0, maximum=0.5, value=0.0, step=0.1)
             tif_btn = gr.Button("Reface TIF", variant="primary")
 
         origin_tif, destination_tif, thresholds_tif, face_tabs_tif = [], [], [], []
@@ -343,7 +299,7 @@ with gr.Blocks(theme=theme, title="NeoRefacer - AI Refacer") as demo:
 
         tif_btn.click(
             fn=lambda tif_path, *args: process_tif(tif_path, *args),
-            inputs=[tif_input] + origin_tif + destination_tif + thresholds_tif + [face_mode_tif],
+            inputs=[tif_input] + origin_tif + destination_tif + thresholds_tif + [face_mode_tif, partial_reface_ratio_tif],
             outputs=[tif_preview, tif_output_preview, tif_output_file]
         )
 
@@ -354,15 +310,13 @@ with gr.Blocks(theme=theme, title="NeoRefacer - AI Refacer") as demo:
         )
 
         tif_input.change(
-            fn=lambda filepath: (
+            fn=handle_tif_preview,
-                Image.open(filepath).convert('RGB').save(
-                    (preview_path := os.path.join("./tmp", f"tif_preview_{int(time.time() * 1000)}.jpg"))
-                ) or preview_path
-            ),
             inputs=tif_input,
             outputs=tif_preview
         )
         
+        tif_input.change(fn=lambda _: 0.0, inputs=tif_input, outputs=partial_reface_ratio_tif)
+
 
     # --- VIDEO MODE ---
     with gr.Tab("Video Mode"):
@@ -376,6 +330,7 @@ with gr.Blocks(theme=theme, title="NeoRefacer - AI Refacer") as demo:
                 value="Single Face",
                 label="Replacement Mode"
             )
+            partial_reface_ratio_video = gr.Slider(label="Reface Ratio (0 = Full Face, 0.5 = Half Face)", minimum=0.0, maximum=0.5, value=0.0, step=0.1)
             video_btn = gr.Button("Reface Video", variant="primary")
 
         preview_checkbox_video = gr.Checkbox(label="Preview Generation (skip 90% of frames)", value=False)
@@ -411,9 +366,11 @@ with gr.Blocks(theme=theme, title="NeoRefacer - AI Refacer") as demo:
             outputs=origin_video
         )
         
+        video_input.change(fn=lambda _: 0.0, inputs=video_input, outputs=partial_reface_ratio_video)
+
         video_btn.click(
             fn=lambda *args: run(*args),
-            inputs=[video_input] + origin_video + destination_video + thresholds_video + [preview_checkbox_video, face_mode_video],
+            inputs=[video_input] + origin_video + destination_video + thresholds_video + [preview_checkbox_video, face_mode_video, partial_reface_ratio_video],
             outputs=[video_output, gr.File(visible=False)]
         )
 

refacer.py

@@ -56,6 +56,46 @@ class Refacer:
         self.total_mem = psutil.virtual_memory().total
         self.__init_apps()
         
+    def _partial_face_blend(self, original_frame, swapped_frame, face):
+        h_frame, w_frame = original_frame.shape[:2]
+    
+        x1, y1, x2, y2 = map(int, face.bbox)
+        x1 = max(0, min(x1, w_frame-1))
+        y1 = max(0, min(y1, h_frame-1))
+        x2 = max(0, min(x2, w_frame))
+        y2 = max(0, min(y2, h_frame))
+    
+        if x2 <= x1 or y2 <= y1:
+            print(f"Invalid bbox: {x1},{y1},{x2},{y2}")
+            return swapped_frame
+    
+        w = x2 - x1
+        h = y2 - y1
+        cutoff = int(h * (1.0 - self.blend_height_ratio))
+    
+        swap_crop = swapped_frame[y1:y2, x1:x2].copy()
+        orig_crop = original_frame[y1:y2, x1:x2].copy()
+    
+        mask = np.ones((h, w, 3), dtype=np.float32)
+        transition = 40
+    
+        if cutoff < h:
+            blend_start = max(cutoff - transition // 2, 0)
+            blend_end = min(cutoff + transition // 2, h)
+    
+            if blend_end > blend_start:
+                alpha = np.linspace(1.0, 0.0, blend_end - blend_start)[:, np.newaxis, np.newaxis]
+                mask[blend_start:blend_end, :, :] = alpha
+            mask[blend_end:, :, :] = 0.0
+    
+        blended_crop = (swap_crop.astype(np.float32) * mask + orig_crop.astype(np.float32) * (1.0 - mask)).astype(np.uint8)
+    
+        blended_frame = swapped_frame.copy()
+        blended_frame[y1:y2, x1:x2] = blended_crop
+    
+        return blended_frame
+    
+
     def __download_with_progress(self, url, output_path):
         response = requests.get(url, stream=True)
         total_size = int(response.headers.get('content-length', 0))
@@ -185,7 +225,12 @@ class Refacer:
     
         if self.disable_similarity:
             for face in faces:
-                frame = self.face_swapper.get(frame, face, self.replacement_faces[0][1], paste_back=True)
+                swapped = self.face_swapper.get(frame, face, self.replacement_faces[0][1], paste_back=True)
+                if hasattr(self, 'partial_reface_ratio') and self.partial_reface_ratio > 0.0:
+                    self.blend_height_ratio = self.partial_reface_ratio
+                    frame = self._partial_face_blend(frame, swapped, face)
+                else:
+                    frame = swapped
         return frame
 
     def process_faces(self, frame):
@@ -193,22 +238,37 @@ class Refacer:
         if not faces:
             return frame
  
-        faces = sorted(faces, key=lambda face: face.bbox[0])  # Sort left to right
+        faces = sorted(faces, key=lambda face: face.bbox[0])
  
         if self.multiple_faces_mode:
             for idx, face in enumerate(faces):
                 if idx >= len(self.replacement_faces):
                     break
-                frame = self.face_swapper.get(frame, face, self.replacement_faces[idx][1], paste_back=True)
+                swapped = self.face_swapper.get(frame, face, self.replacement_faces[idx][1], paste_back=True)
+                if hasattr(self, 'partial_reface_ratio') and self.partial_reface_ratio > 0.0:
+                    self.blend_height_ratio = self.partial_reface_ratio
+                    frame = self._partial_face_blend(frame, swapped, face)
+                else:
+                    frame = swapped
         elif self.disable_similarity:
             for face in faces:
-                frame = self.face_swapper.get(frame, face, self.replacement_faces[0][1], paste_back=True)
+                swapped = self.face_swapper.get(frame, face, self.replacement_faces[0][1], paste_back=True)
+                if hasattr(self, 'partial_reface_ratio') and self.partial_reface_ratio > 0.0:
+                    self.blend_height_ratio = self.partial_reface_ratio
+                    frame = self._partial_face_blend(frame, swapped, face)
+                else:
+                    frame = swapped
         else:
             for rep_face in self.replacement_faces:
                 for i in range(len(faces) - 1, -1, -1):
                     sim = self.rec_app.compute_sim(rep_face[0], faces[i].embedding)
                     if sim >= rep_face[2]:
-                        frame = self.face_swapper.get(frame, faces[i], rep_face[1], paste_back=True)
+                        swapped = self.face_swapper.get(frame, faces[i], rep_face[1], paste_back=True)
+                        if hasattr(self, 'partial_reface_ratio') and self.partial_reface_ratio > 0.0:
+                            self.blend_height_ratio = self.partial_reface_ratio
+                            frame = self._partial_face_blend(frame, swapped, faces[i])
+                        else:
+                            frame = swapped
                         del faces[i]
                         break
         return frame
@@ -229,7 +289,7 @@ class Refacer:
         if audio_stream is not None:
             self.video_has_audio = True
 
-    def reface(self, video_path, faces, preview=False, disable_similarity=False, multiple_faces_mode=False):
+    def reface(self, video_path, faces, preview=False, disable_similarity=False, multiple_faces_mode=False, partial_reface_ratio=0.0):
         original_name = osp.splitext(osp.basename(video_path))[0]
         timestamp = str(int(time.time()))
         filename = f"{original_name}_preview.mp4" if preview else f"{original_name}_{timestamp}.mp4"
@@ -245,6 +305,7 @@ class Refacer:
     
         self.prepare_faces(faces, disable_similarity=disable_similarity, multiple_faces_mode=multiple_faces_mode)
         self.first_face = False if multiple_faces_mode else (faces[0].get("origin") is None or disable_similarity)
+        self.partial_reface_ratio = partial_reface_ratio
     
         cap = cv2.VideoCapture(video_path, cv2.CAP_FFMPEG)
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
@@ -291,6 +352,10 @@ class Refacer:
     
         return converted_path, None
     
+   
+  
+
+
     def __generate_gif(self, video_path, gif_output_path):
         os.makedirs(os.path.dirname(gif_output_path), exist_ok=True)
         print(f"Generating GIF at {gif_output_path}")
@@ -314,9 +379,10 @@ class Refacer:
         print(f"Refaced video saved at: {os.path.abspath(new_path)}")
         return new_path
 
-    def reface_image(self, image_path, faces, disable_similarity=False, multiple_faces_mode=False):
+    def reface_image(self, image_path, faces, disable_similarity=False, multiple_faces_mode=False, partial_reface_ratio=0.0):
          self.prepare_faces(faces, disable_similarity=disable_similarity, multiple_faces_mode=multiple_faces_mode)
          self.first_face = False if multiple_faces_mode else (faces[0].get("origin") is None or disable_similarity)
+         self.partial_reface_ratio = partial_reface_ratio
  
          ext = osp.splitext(image_path)[1].lower()
          os.makedirs("output", exist_ok=True)
@@ -327,16 +393,14 @@ class Refacer:
              pil_img = Image.open(image_path)
              frames = []
  
-            # First, count pages
              page_count = 0
              try:
                  while True:
                      pil_img.seek(page_count)
                      page_count += 1
              except EOFError:
-                pass  # End of pages
+                 pass
  
-            # Re-open to start real processing
              pil_img = Image.open(image_path)
  
              with tqdm(total=page_count, desc="Processing TIFF pages") as pbar:
@@ -370,6 +434,7 @@ class Refacer:
              print(f"Saved refaced image to {output_path}")
              return output_path
 
+
     def extract_faces_from_image(self, image_path, max_faces=5):
         frame = cv2.imread(image_path)
         if frame is None: