Update run.py

run.py

@@ -3,86 +3,101 @@ import cv2
 import numpy as np
 from insightface.app import FaceAnalysis
 import tempfile
-from moviepy.editor import VideoFileClip
+import os
 
 # Initialisation du modèle
 face_swapper = FaceAnalysis(name="buffalo_l")
 face_swapper.prepare(ctx_id=0, det_size=(640, 640))
 
-def process_video(source_img, target_video):
+def swap_face(source_face, target_face, frame, blend_factor=0.7):
+    """Échange le visage avec possibilité de régler l'intensité du mélange"""
+    src_emb = source_face.normed_embedding
+    tgt_bbox = target_face.bbox.astype(int)
+
+    # Obtenir le visage source (de la cible pour garder la taille)
+    h, w = frame.shape[:2]
+    src_face_img = source_face.img
+    resized_face = cv2.resize(src_face_img, (tgt_bbox[2]-tgt_bbox[0], tgt_bbox[3]-tgt_bbox[1]))
+
+    # Créer un masque doux
+    mask = np.zeros_like(resized_face)
+    center = (mask.shape[1]//2, mask.shape[0]//2)
+    radius = int(min(mask.shape) * 0.45)
+    cv2.circle(mask, center, radius, (255,255,255), -1)
+    mask = cv2.GaussianBlur(mask, (15,15), 5)
+
+    # Positionner le visage
+    center = ((tgt_bbox[0]+tgt_bbox[2])//2, (tgt_bbox[1]+tgt_bbox[3])//2)
+
+    # Appliquer seamlessClone
+    result = cv2.seamlessClone(
+        resized_face, frame, mask, center, cv2.NORMAL_CLONE
+    )
+
+    # Mélanger avec l'original selon blend_factor
+    blended = cv2.addWeighted(frame, 1-blend_factor, result, blend_factor, 0)
+    
+    return blended
+
+
+def process_video(source_img, target_video, face_index_source=0, face_index_target=0, blend_factor=0.8):
     try:
-        # Fichiers temporaires
         temp_output = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
         
-        # Traitement de la vidéo
-        source_face = face_swapper.get(np.array(source_img))[0]
-        
+        # Charger le visage source
+        source_faces = face_swapper.get(np.array(source_img))
+        if not source_faces:
+            raise ValueError("Aucun visage trouvé sur l'image source.")
+        source_face = source_faces[face_index_source]
+
         cap = cv2.VideoCapture(target_video)
         fps = cap.get(cv2.CAP_PROP_FPS)
         frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
         frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        
-        out = cv2.VideoWriter(temp_output.name, 
-                             cv2.VideoWriter_fourcc(*'mp4v'), 
-                             fps, 
-                             (frame_width, frame_height))
-        
+
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(temp_output.name, fourcc, fps, (frame_width, frame_height))
+
         while cap.isOpened():
             ret, frame = cap.read()
             if not ret:
                 break
-                
+
             target_faces = face_swapper.get(frame)
-            if target_faces:
-                frame = swap_face(source_face, target_faces[0], frame)
-            
+            if target_faces and len(target_faces) > face_index_target:
+                frame = swap_face(source_face, target_faces[face_index_target], frame, blend_factor)
+
             out.write(frame)
-        
+
         cap.release()
         out.release()
-        
+
         return temp_output.name
-        
+
     except Exception as e:
         print(f"ERREUR: {str(e)}")
         return None
 
-def swap_face(source_face, target_face, frame):
-    # Algorithme professionnel d'échange
-    src_bbox = source_face.bbox.astype(int)
-    tgt_bbox = target_face.bbox.astype(int)
-    
-    # Extraction et ajustement du visage source
-    src_face = cv2.resize(source_face.img[tgt_bbox[1]:tgt_bbox[3], tgt_bbox[0]:tgt_bbox[2]], 
-                         (tgt_bbox[2]-tgt_bbox[0], tgt_bbox[3]-tgt_bbox[1]))
-    
-    # Fusion réaliste
-    mask = np.zeros_like(src_face)
-    cv2.circle(mask, 
-              (mask.shape[1]//2, mask.shape[0]//2), 
-              min(mask.shape)//2, 
-              (255,255,255), -1)
-    
-    center = ((tgt_bbox[0]+tgt_bbox[2])//2, (tgt_bbox[1]+tgt_bbox[3])//2)
-    output = cv2.seamlessClone(
-        src_face, frame, mask, center, cv2.NORMAL_CLONE)
-    
-    return output
 
-# Interface optimisée pour vidéo
+# Interface Gradio
 with gr.Blocks() as app:
-    gr.Markdown("## 🎬 VideoFaceSwap Pro")
-    
+    gr.Markdown("## 🎬 VideoFaceSwap Pro - Échangez des visages en vidéo avec précision")
+
     with gr.Row():
-        src_img = gr.Image(label="Visage source", type="numpy")
-        tgt_video = gr.Video(label="Vidéo cible")
-        
-    btn = gr.Button("Traiter la vidéo", variant="primary")
-    output_video = gr.Video(label="Résultat")
-    
+        src_img = gr.Image(label="Visage Source", type="numpy")
+        tgt_video = gr.Video(label="Vidéo Cible")
+
+    with gr.Row():
+        face_index_source = gr.Slider(0, 5, value=0, step=1, label="Index Visage Source")
+        face_index_target = gr.Slider(0, 5, value=0, step=1, label="Index Visage à Remplacer")
+        blend_factor = gr.Slider(0.0, 1.0, value=0.8, label="Intensité du mélange")
+
+    btn = gr.Button("🔁 Traiter la Vidéo", variant="primary")
+    output_video = gr.Video(label="Vidéo Résultat")
+
     btn.click(
         fn=process_video,
-        inputs=[src_img, tgt_video],
+        inputs=[src_img, tgt_video, face_index_source, face_index_target, blend_factor],
         outputs=output_video
     )