Delete refacer.py

refacer.py

@@ -1,154 +0,0 @@
-import cv2
-import onnxruntime as rt
-import sys
-from insightface.app import FaceAnalysis
-sys.path.insert(1, './recognition')
-from scrfd import SCRFD
-from arcface_onnx import ArcFaceONNX
-import os
-from pathlib import Path
-from tqdm import tqdm
-from insightface.model_zoo.inswapper import INSwapper
-import psutil
-from enum import Enum
-from insightface.app.common import Face
-from insightface.utils.storage import ensure_available
-
-class RefacerMode(Enum):
-    CPU, CUDA, COREML, TENSORRT = range(1, 5)
-
-class Refacer:
-    def __init__(self, force_cpu=False, colab_performance=False):
-        self.first_face = False
-        self.force_cpu = force_cpu
-        self.colab_performance = colab_performance
-        self.__check_providers()
-        self.__init_apps()
-
-    def __check_providers(self):
-        if self.force_cpu:
-            self.providers = ['CPUExecutionProvider']
-        else:
-            self.providers = rt.get_available_providers()
-        rt.set_default_logger_severity(4)
-        self.sess_options = rt.SessionOptions()
-        self.sess_options.execution_mode = rt.ExecutionMode.ORT_SEQUENTIAL
-        self.sess_options.graph_optimization_level = rt.GraphOptimizationLevel.ORT_ENABLE_ALL
-
-        if len(self.providers) == 1 and 'CPUExecutionProvider' in self.providers:
-            self.mode = RefacerMode.CPU
-            self.use_num_cpus = psutil.cpu_count(logical=False)
-            print(f"CPU mode with providers {self.providers}")
-        elif self.colab_performance:
-            self.mode = RefacerMode.TENSORRT
-            print(f"TENSORRT mode with providers {self.providers}")
-        elif 'CUDAExecutionProvider' in self.providers:
-            self.mode = RefacerMode.CUDA
-            print(f"CUDA mode with providers {self.providers}")
-
-    def __init_apps(self):
-        assets_dir = ensure_available('models', 'buffalo_l', root='~/.insightface')
-
-        model_path = os.path.join(assets_dir, 'det_10g.onnx')
-        sess_face = rt.InferenceSession(model_path, self.sess_options, providers=self.providers)
-        self.face_detector = SCRFD(model_path, sess_face)
-        self.face_detector.prepare(0, input_size=(640, 640))
-
-        model_path = os.path.join(assets_dir, 'w600k_r50.onnx')
-        sess_rec = rt.InferenceSession(model_path, self.sess_options, providers=self.providers)
-        self.rec_app = ArcFaceONNX(model_path, sess_rec)
-        self.rec_app.prepare(0)
-
-        model_path = 'inswapper_128.onnx'
-        sess_swap = rt.InferenceSession(model_path, self.sess_options, providers=self.providers)
-        self.face_swapper = INSwapper(model_path, sess_swap)
-
-    def prepare_faces(self, faces):
-        self.replacement_faces = []
-        for face in faces:
-            if "origin" in face:
-                bboxes1, kpss1 = self.face_detector.autodetect(face['origin'], max_num=1)
-                if len(kpss1) < 1:
-                    raise Exception('No face detected on "Face to replace" image')
-                feat_original = self.rec_app.get(face['origin'], kpss1[0])
-            else:
-                feat_original = None
-                self.first_face = True
-                print('No origin image: First face change')
-            _faces = self.__get_faces(face['destination'], max_num=1)
-            if len(_faces) < 1:
-                raise Exception('No face detected on "Destination face" image')
-            self.replacement_faces.append((feat_original, _faces[0], face.get('threshold', 0)))
-
-    def __get_faces(self, frame, max_num=0):
-        bboxes, kpss = self.face_detector.detect(frame, max_num=max_num, metric='default')
-        if bboxes.shape[0] == 0:
-            return []
-        ret = []
-        for i in range(bboxes.shape[0]):
-            bbox = bboxes[i, 0:4]
-            det_score = bboxes[i, 4]
-            kps = None
-            if kpss is not None:
-                kps = kpss[i]
-            face = Face(bbox=bbox, kps=kps, det_score=det_score)
-            face.embedding = self.rec_app.get(frame, kps)
-            ret.append(face)
-        return ret
-
-    def process_first_face(self, frame):
-        faces = self.__get_faces(frame, max_num=1)
-        if len(faces) != 0:
-            frame = self.face_swapper.get(frame, faces[0], self.replacement_faces[0][1], paste_back=True)
-        return frame
-
-    def process_faces(self, frame):
-        faces = self.__get_faces(frame, max_num=0)
-        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)
-                    del faces[i]
-                    break
-        return frame
-
-    def reface_group(self, faces, frames, output):
-        for frame in frames:
-            if self.first_face:
-                output.write(self.process_first_face(frame))
-            else:
-                output.write(self.process_faces(frame))
-
-    def reface(self, video_path, faces):
-        print(f"Refacing video: {video_path}")
-        # Output video path is the same as input video, with "_refaced" suffix
-        output_video_path = f"{os.path.splitext(video_path)[0]}_refaced.mp4"
-        self.prepare_faces(faces)
-
-        cap = cv2.VideoCapture(video_path)
-        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        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))
-
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        output = cv2.VideoWriter(output_video_path, fourcc, fps, (frame_width, frame_height))
-
-        frames = []
-        with tqdm(total=total_frames, desc="Processing frames") as pbar:
-            while cap.isOpened():
-                ret, frame = cap.read()
-                if not ret:
-                    break
-                frames.append(frame)
-                pbar.update()
-
-        cap.release()
-
-        # Process and save refaced video
-        self.reface_group(faces, frames, output)
-        output.release()
-
-        print(f"Refaced video saved at {output_video_path}")
-        return output_video_path  # Return final path of video