Update run.py

run.py

@@ -2,87 +2,89 @@ import gradio as gr
 import cv2
 import numpy as np
 from insightface.app import FaceAnalysis
+import tempfile
+from moviepy.editor import VideoFileClip
 
-# Initialisation sécurisée
-try:
-    face_app = FaceAnalysis(name="buffalo_l")
-    face_app.prepare(ctx_id=0, det_size=(640, 640))
-except Exception as e:
-    print(f"ERREUR initialisation : {str(e)}")
-    face_app = None
+# Initialisation du modèle
+face_swapper = FaceAnalysis(name="buffalo_l")
+face_swapper.prepare(ctx_id=0, det_size=(640, 640))
 
-def safe_face_swap(source_img, target_img):
+def process_video(source_img, target_video):
     try:
-        if face_app is None:
-            raise ValueError("Le modèle de détection n'est pas chargé")
+        # Fichiers temporaires
+        temp_output = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
         
-        # Conversion robuste
-        source = np.array(source_img, dtype=np.uint8)
-        target = np.array(target_img, dtype=np.uint8)
+        # Traitement de la vidéo
+        source_face = face_swapper.get(np.array(source_img))[0]
         
-        # Vérification des dimensions
-        if source.ndim != 3 or target.ndim != 3:
-            raise ValueError("Format d'image invalide")
-            
-        # Détection sécurisée
-        source_faces = face_app.get(cv2.cvtColor(source, cv2.COLOR_RGB2BGR))
-        target_faces = face_app.get(cv2.cvtColor(target, cv2.COLOR_RGB2BGR))
+        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))
         
-        if not source_faces:
-            raise ValueError("Aucun visage détecté dans l'image source")
-        if not target_faces:
-            raise ValueError("Aucun visage détecté dans l'image cible")
+        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)
             
-        # Swap simplifié mais stable
-        src_face = source_faces[0].bbox.astype(int)
-        tgt_face = target_faces[0].bbox.astype(int)
+            out.write(frame)
+        
+        cap.release()
+        out.release()
         
-        result = target.copy()
-        result[tgt_face[1]:tgt_face[3], tgt_face[0]:tgt_face[2]] = \
-            cv2.resize(source[src_face[1]:src_face[3], src_face[0]:src_face[2]], 
-                     (tgt_face[2]-tgt_face[0], tgt_face[3]-tgt_face[1]))
+        return temp_output.name
         
-        return result
     except Exception as e:
-        print(f"ERREUR traitement : {str(e)}")
-        # Retourne l'image cible avec message d'erreur
-        if target_img is not None:
-            return target_img
+        print(f"ERREUR: {str(e)}")
         return None
 
-# Interface renforcée
-with gr.Blocks(title="FaceSwap Pro") as app:
-    gr.Markdown("""
-    ## 🔄 FaceSwap Professionnel
-    *Échange de visages stable et sécurisé*
-    """)
+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)
     
-    with gr.Row():
-        with gr.Column():
-            src = gr.Image(label="Source", type="numpy")
-            tgt = gr.Image(label="Cible", type="numpy")
-            btn = gr.Button("Exécuter", variant="primary")
-        result = gr.Image(label="Résultat", interactive=False)
+    # 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)
     
-    # Gestion des erreurs dans l'UI
-    error_box = gr.Textbox(visible=False, label="Erreur")
+    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)
     
-    def wrapped_face_swap(src_img, tgt_img):
-        try:
-            return safe_face_swap(src_img, tgt_img), ""
-        except Exception as e:
-            return None, f"Erreur : {str(e)}"
+    return output
+
+# Interface optimisée pour vidéo
+with gr.Blocks() as app:
+    gr.Markdown("## 🎬 VideoFaceSwap Pro")
+    
+    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")
     
     btn.click(
-        fn=wrapped_face_swap,
-        inputs=[src, tgt],
-        outputs=[result, error_box]
+        fn=process_video,
+        inputs=[src_img, tgt_video],
+        outputs=output_video
     )
 
 if __name__ == "__main__":
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True,
-        debug=True
-    )
+    app.launch(server_name="0.0.0.0", server_port=7860)