Update app.py

app.py

@@ -17,6 +17,8 @@ import queue
 from tqdm import tqdm
 import concurrent.futures
 from moviepy.editor import VideoFileClip
+from PIL import Image
+import io
 
 from face_swapper import Inswapper, paste_to_whole
 from face_analyser import detect_conditions, get_analysed_data, swap_options_list
@@ -183,27 +185,19 @@ def process(
 
     start_time = time.time()
     total_exec_time = lambda start_time: divmod(time.time() - start_time, 60)
-    get_finsh_text = lambda start_time: f"✔️ Completed in {int(total_exec_time(start_time)[0])} min {int(total_exec_time(start_time)[1])} sec."
 
     ## ------------------------------ PREPARE INPUTS & LOAD MODELS ------------------------------
 
-    
-
-    yield "### \n 💊 Loading face analyser model...", *ui_before()
     load_face_analyser_model()
-
-    yield "### \n 👑 Loading face swapper model...", *ui_before()
     load_face_swapper_model()
 
     if face_enhancer_name != "NONE":
         if face_enhancer_name not in cv2_interpolations:
-            yield f"### \n 🔮 Loading {face_enhancer_name} model...", *ui_before()
         FACE_ENHANCER = load_face_enhancer_model(name=face_enhancer_name, device=device)
     else:
         FACE_ENHANCER = None
 
     if enable_face_parser:
-        yield "### \n 🧲 Loading face parsing model...", *ui_before()
         load_face_parser_model()
 
     includes = mask_regions_to_list(mask_includes)
@@ -220,8 +214,6 @@ def process(
     def swap_process(image_sequence):
         ## ------------------------------ CONTENT CHECK ------------------------------
 
-    
-        yield "### \n 📡 Analysing face data...", *ui_before()
         if condition != "Specific Face":
             source_data = source_path, age
         else:
@@ -236,12 +228,9 @@ def process(
         )
 
         ## ------------------------------ SWAP FUNC ------------------------------
-
-        yield "### \n ⚙️ Generating faces...", *ui_before()
         preds = []
         matrs = []
         count = 0
-        global PREVIEW
         for batch_pred, batch_matr in FACE_SWAPPER.batch_forward(whole_frame_list, analysed_targets, analysed_sources):
             preds.extend(batch_pred)
             matrs.extend(batch_matr)
@@ -250,14 +239,11 @@ def process(
 
             if USE_CUDA:
                 image_grid = create_image_grid(batch_pred, size=128)
-                PREVIEW = image_grid[:, :, ::-1]
-                yield f"### \n ⚙️ Generating face Batch {count}", *ui_before()
 
         ## ------------------------------ FACE ENHANCEMENT ------------------------------
 
         generated_len = len(preds)
         if face_enhancer_name != "NONE":
-            yield f"### \n 📐 Upscaling faces with {face_enhancer_name}...", *ui_before()
             for idx, pred in tqdm(enumerate(preds), total=generated_len, desc=f"Upscaling with {face_enhancer_name}"):
                 enhancer_model, enhancer_model_runner = FACE_ENHANCER
                 pred = enhancer_model_runner(pred, enhancer_model)
@@ -267,7 +253,6 @@ def process(
         ## ------------------------------ FACE PARSING ------------------------------
 
         if enable_face_parser:
-            yield "### \n 🖇️ Face-parsing mask...", *ui_before()
             masks = []
             count = 0
             for batch_mask in get_parsed_mask(FACE_PARSER, preds, classes=includes, device=device, batch_size=BATCH_SIZE, softness=int(mask_soft_iterations)):
@@ -277,8 +262,6 @@ def process(
 
                 if len(batch_mask) > 1:
                     image_grid = create_image_grid(batch_mask, size=128)
-                    PREVIEW = image_grid[:, :, ::-1]
-                    yield f"### \n ✏️ Face parsing Batch {count}", *ui_before()
             masks = np.concatenate(masks, axis=0) if len(masks) >= 1 else masks
         else:
             masks = [None] * generated_len
@@ -294,7 +277,6 @@ def process(
 
         ## ------------------------------ PASTE-BACK ------------------------------
 
-        yield "### \n 🛠️ Pasting back...", *ui_before()
         def post_process(frame_idx, frame_img, split_preds, split_matrs, split_masks, enable_laplacian_blend, crop_mask, blur_amount, erode_amount):
             whole_img_path = frame_img
             whole_img = cv2.imread(whole_img_path)
@@ -326,8 +308,17 @@ def process(
             blur_amount,
             erode_amount
         )
-
-
+    ## ------------------------------ Gardio API ------------------------------
+        iface = gr.Interface(
+            fn=process_api,
+            inputs=[
+                gr.Textbox(label="Source Image (base64)"),
+                gr.Textbox(label="Target Image (base64)")
+            ],
+            outputs=gr.Textbox(label="Result Image (base64)"),
+            title="Face Swap API",
+            description="Submit two base64 encoded images to swap faces."
+        )
     ## ------------------------------ IMAGE ------------------------------
 
     if input_type == "Image":
@@ -400,12 +391,9 @@ def process(
         for info_update in swap_process(file_paths):
             yield info_update
 
-        PREVIEW = cv2.imread(file_paths[-1])[:, :, ::-1]
         WORKSPACE = temp_path
         OUTPUT_FILE = file_paths[-1]
 
-        yield get_finsh_text(start_time), *ui_after()
-
     ## ------------------------------ STREAM ------------------------------
 
     elif input_type == "Stream":
@@ -414,83 +402,7 @@ def process(
 
 ## ------------------------------ GRADIO FUNC ------------------------------
 
-
-def update_radio(value):
-    if value == "Image":
-        return (
-            gr.update(visible=True),
-            gr.update(visible=False),
-            gr.update(visible=False),
-        )
-    elif value == "Video":
-        return (
-            gr.update(visible=False),
-            gr.update(visible=True),
-            gr.update(visible=False),
-        )
-    elif value == "Directory":
-        return (
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=True),
-        )
-    elif value == "Stream":
-        return (
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=True),
-        )
-
-
-def swap_option_changed(value):
-    if value.startswith("Age"):
-        return (
-            gr.update(visible=True),
-            gr.update(visible=False),
-            gr.update(visible=True),
-        )
-    elif value == "Specific Face":
-        return (
-            gr.update(visible=False),
-            gr.update(visible=True),
-            gr.update(visible=False),
-        )
-    return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
-
-
-def video_changed(video_path):
-    sliders_update = gr.Slider.update
-    button_update = gr.Button.update
-    number_update = gr.Number.update
-
-    if video_path is None:
-        return (
-            sliders_update(minimum=0, maximum=0, value=0),
-            sliders_update(minimum=1, maximum=1, value=1),
-            number_update(value=1),
-        )
-    try:
-        clip = VideoFileClip(video_path)
-        fps = clip.fps
-        total_frames = clip.reader.nframes
-        clip.close()
-        return (
-            sliders_update(minimum=0, maximum=total_frames, value=0, interactive=True),
-            sliders_update(
-                minimum=0, maximum=total_frames, value=total_frames, interactive=True
-            ),
-            number_update(value=fps),
-        )
-    except:
-        return (
-            sliders_update(value=0),
-            sliders_update(value=0),
-            number_update(value=1),
-        )
-
-
 def analyse_settings_changed(detect_condition, detection_size, detection_threshold):
-    yield "### \n 💡 Applying new values..."
     global FACE_ANALYSER
     global DETECT_CONDITION
     DETECT_CONDITION = detect_condition
@@ -500,8 +412,56 @@ def analyse_settings_changed(detect_condition, detection_size, detection_thresho
         det_size=(int(detection_size), int(detection_size)),
         det_thresh=float(detection_threshold),
     )
-    yield f"### \n ✔️ Applied detect condition:{detect_condition}, detection size: {detection_size}, detection threshold: {detection_threshold}"
 
+def decode_base64_image(base64_string):
+    img_data = base64.b64decode(base64_string)
+    img = Image.open(io.BytesIO(img_data))
+    return cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+
+def process_api(source_base64, target_base64):
+    source_image = decode_base64_image(source_base64)
+    target_image = decode_base64_image(target_base64)
+    
+    temp_source_path = "temp_source.jpg"
+    temp_target_path = "temp_target.jpg"
+    cv2.imwrite(temp_source_path, source_image)
+    cv2.imwrite(temp_target_path, target_image)
+    
+    result = process(
+        input_type="Image",
+        image_path=temp_target_path,
+        video_path=None,
+        directory_path=None,
+        source_path=temp_source_path,
+        output_path="output",
+        output_name="result",
+        keep_output_sequence=False,
+        condition="First found face",
+        age=None,
+        distance=None,
+        face_enhancer_name="NONE",
+        enable_face_parser=False,
+        mask_includes=MASK_INCLUDE,
+        mask_soft_kernel=MASK_SOFT_KERNEL,
+        mask_soft_iterations=MASK_SOFT_ITERATIONS,
+        blur_amount=MASK_BLUR_AMOUNT,
+        erode_amount=MASK_ERODE_AMOUNT,
+        face_scale=1.0,
+        enable_laplacian_blend=True,
+        crop_top,
+        crop_bott,
+        crop_left,
+        crop_right,
+    )
+    
+    os.remove(temp_source_path)
+    os.remove(temp_target_path)
+    
+    result_image = cv2.imread("output/result.png")
+    _, buffer = cv2.imencode('.jpg', result_image)
+    result_base64 = base64.b64encode(buffer).decode('utf-8')
+    
+    return result_base64
 
 def stop_running():
     global STREAMER
@@ -526,381 +486,15 @@ def slider_changed(show_frame, video_path, frame_index):
 
 
 def trim_and_reload(video_path, output_path, output_name, start_frame, stop_frame):
-    yield video_path, f"### \n 🛠️ Trimming video frame {start_frame} to {stop_frame}..."
     try:
         output_path = os.path.join(output_path, output_name)
         trimmed_video = trim_video(video_path, output_path, start_frame, stop_frame)
-        yield trimmed_video, "### \n ✔️ Video trimmed and reloaded."
     except Exception as e:
         print(e)
-        yield video_path, "### \n ❌ Video trimming failed. See console for more info."
-
-
-## ------------------------------ GRADIO GUI ------------------------------
-
-css = """
-footer{display:none !important}
-"""
-
-with gr.Blocks(css=css) as interface:
-    gr.Markdown("# 🧸 Deepfake Faceswap")
-    gr.Markdown("### 📥 insightface inswapper bypass NSFW.")
-    with gr.Row():
-        with gr.Row():
-            with gr.Column(scale=0.4):
-                with gr.Tab("⚖️ Swap Condition"):
-                    swap_option = gr.Dropdown(
-                        swap_options_list,
-                        info="Choose which face or faces in the target image to swap.",
-                        multiselect=False,
-                        show_label=False,
-                        value=swap_options_list[0],
-                        interactive=True,
-                    )
-                    age = gr.Number(
-                        value=25, label="Value", interactive=True, visible=False
-                    )
-
-                with gr.Tab("🎛️ Detection Settings"):
-                    detect_condition_dropdown = gr.Dropdown(
-                        detect_conditions,
-                        label="Condition",
-                        value=DETECT_CONDITION,
-                        interactive=True,
-                        info="This condition is only used when multiple faces are detected on source or specific image.",
-                    )
-                    detection_size = gr.Number(
-                        label="Detection Size", value=DETECT_SIZE, interactive=True
-                    )
-                    detection_threshold = gr.Number(
-                        label="Detection Threshold",
-                        value=DETECT_THRESH,
-                        interactive=True,
-                    )
-                    apply_detection_settings = gr.Button("Apply settings")
-
-                with gr.Tab("♻️ Output Settings"):
-                    output_directory = gr.Text(
-                        label="Output Directory",
-                        value=DEF_OUTPUT_PATH,
-                        interactive=True,
-                    )
-                    output_name = gr.Text(
-                        label="Output Name", value="Result", interactive=True
-                    )
-                    keep_output_sequence = gr.Checkbox(
-                        label="Keep output sequence", value=False, interactive=True
-                    )
-
-                with gr.Tab("💎 Other Settings"):
-                    face_scale = gr.Slider(
-                        label="Face Scale",
-                        minimum=0,
-                        maximum=2,
-                        value=1,
-                        interactive=True,
-                    )
-
-                    face_enhancer_name = gr.Dropdown(
-                        FACE_ENHANCER_LIST, label="Face Enhancer", value="NONE", multiselect=False, interactive=True
-                    )
-
-                    with gr.Accordion("Advanced Mask", open=False):
-                        enable_face_parser_mask = gr.Checkbox(
-                            label="Enable Face Parsing",
-                            value=False,
-                            interactive=True,
-                        )
-
-                        mask_include = gr.Dropdown(
-                            mask_regions.keys(),
-                            value=MASK_INCLUDE,
-                            multiselect=True,
-                            label="Include",
-                            interactive=True,
-                        )
-                        mask_soft_kernel = gr.Number(
-                            label="Soft Erode Kernel",
-                            value=MASK_SOFT_KERNEL,
-                            minimum=3,
-                            interactive=True,
-                            visible = False
-                        )
-                        mask_soft_iterations = gr.Number(
-                            label="Soft Erode Iterations",
-                            value=MASK_SOFT_ITERATIONS,
-                            minimum=0,
-                            interactive=True,
-
-                        )
-
-
-                    with gr.Accordion("Crop Mask", open=False):
-                        crop_top = gr.Slider(label="Top", minimum=0, maximum=511, value=0, step=1, interactive=True)
-                        crop_bott = gr.Slider(label="Bottom", minimum=0, maximum=511, value=511, step=1, interactive=True)
-                        crop_left = gr.Slider(label="Left", minimum=0, maximum=511, value=0, step=1, interactive=True)
-                        crop_right = gr.Slider(label="Right", minimum=0, maximum=511, value=511, step=1, interactive=True)
-
-
-                    erode_amount = gr.Slider(
-                            label="Mask Erode",
-                            minimum=0,
-                            maximum=1,
-                            value=MASK_ERODE_AMOUNT,
-                            step=0.05,
-                            interactive=True,
-                        )
-
-                    blur_amount = gr.Slider(
-                            label="Mask Blur",
-                            minimum=0,
-                            maximum=1,
-                            value=MASK_BLUR_AMOUNT,
-                            step=0.05,
-                            interactive=True,
-                        )
-
-                    enable_laplacian_blend = gr.Checkbox(
-                        label="Laplacian Blending",
-                        value=True,
-                        interactive=True,
-                    )
-
-
-                source_image_input = gr.Image(
-                    label="Source face", type="filepath", interactive=True
-                )
-
-                with gr.Box(visible=False) as specific_face:
-                    for i in range(NUM_OF_SRC_SPECIFIC):
-                        idx = i + 1
-                        code = "\n"
-                        code += f"with gr.Tab(label='({idx})'):"
-                        code += "\n\twith gr.Row():"
-                        code += f"\n\t\tsrc{idx} = gr.Image(interactive=True, type='numpy', label='Source Face {idx}')"
-                        code += f"\n\t\ttrg{idx} = gr.Image(interactive=True, type='numpy', label='Specific Face {idx}')"
-                        exec(code)
-
-                    distance_slider = gr.Slider(
-                        minimum=0,
-                        maximum=2,
-                        value=0.6,
-                        interactive=True,
-                        label="Distance",
-                        info="Lower distance is more similar and higher distance is less similar to the target face.",
-                    )
-
-                with gr.Group():
-                    input_type = gr.Radio(
-                        ["Image", "Video"],
-                        label="Target Type",
-                        value="Image",
-                    )
-
-                    with gr.Box(visible=True) as input_image_group:
-                        image_input = gr.Image(
-                            label="Target Image", interactive=True, type="filepath"
-                        )
-
-                    with gr.Box(visible=False) as input_video_group:
-                        vid_widget = gr.Video if USE_COLAB else gr.Text
-                        video_input = gr.Video(
-                            label="Target Video", interactive=True
-                        )
-                        with gr.Accordion("🎨 Trim video", open=False):
-                            with gr.Column():
-                                with gr.Row():
-                                    set_slider_range_btn = gr.Button(
-                                        "Set frame range", interactive=True
-                                    )
-                                    show_trim_preview_btn = gr.Checkbox(
-                                        label="Show frame when slider change",
-                                        value=True,
-                                        interactive=True,
-                                    )
-
-                                video_fps = gr.Number(
-                                    value=30,
-                                    interactive=False,
-                                    label="Fps",
-                                    visible=False,
-                                )
-                                start_frame = gr.Slider(
-                                    minimum=0,
-                                    maximum=1,
-                                    value=0,
-                                    step=1,
-                                    interactive=True,
-                                    label="Start Frame",
-                                    info="",
-                                )
-                                end_frame = gr.Slider(
-                                    minimum=0,
-                                    maximum=1,
-                                    value=1,
-                                    step=1,
-                                    interactive=True,
-                                    label="End Frame",
-                                    info="",
-                                )
-                            trim_and_reload_btn = gr.Button(
-                                "Trim and Reload", interactive=True
-                            )
-
-                    with gr.Box(visible=False) as input_directory_group:
-                        direc_input = gr.Text(label="Path", interactive=True)
-
-            with gr.Column(scale=0.6):
-                info = gr.Markdown(value="...")
-
-                with gr.Row():
-                    swap_button = gr.Button("🎯 Swap", variant="primary")
-                    cancel_button = gr.Button("❌ Cancel")
-
-                preview_image = gr.Image(label="Output", interactive=False)
-                preview_video = gr.Video(
-                    label="Output", interactive=False, visible=False
-                )
-
-                with gr.Row():
-                    output_directory_button = gr.Button(
-                        "💌", interactive=False, visible=False
-                    )
-                    output_video_button = gr.Button(
-                        "📽️", interactive=False, visible=False
-                    )
-
-                with gr.Box():
-                    with gr.Row():
-                        gr.Markdown(
-                            "### [🎭 Sponsor]"
-                        )
-                        gr.Markdown(
-                            "### [🖥️ Source code](https://huggingface.co/spaces/victorisgeek/SwapFace2Pon)"
-                        )
-                        gr.Markdown(
-                            "### [ 🧩 Playground](https://huggingface.co/spaces/victorisgeek/SwapFace2Pon)"
-                        )
-                        gr.Markdown(
-                            "### [📸 Run in Colab](https://colab.research.google.com/github/victorgeel/FaceSwapNoNfsw/blob/main/SwapFace.ipynb)"
-                        )
-                        gr.Markdown(
-                            "### [🤗 Modified Version](https://github.com/victorgeel/FaceSwapNoNfsw)"
-                        )
-
-    ## ------------------------------ GRADIO EVENTS ------------------------------
-
-    set_slider_range_event = set_slider_range_btn.click(
-        video_changed,
-        inputs=[video_input],
-        outputs=[start_frame, end_frame, video_fps],
-    )
 
-    trim_and_reload_event = trim_and_reload_btn.click(
-        fn=trim_and_reload,
-        inputs=[video_input, output_directory, output_name, start_frame, end_frame],
-        outputs=[video_input, info],
-    )
-
-    start_frame_event = start_frame.release(
-        fn=slider_changed,
-        inputs=[show_trim_preview_btn, video_input, start_frame],
-        outputs=[preview_image, preview_video],
-        show_progress=True,
-    )
-
-    end_frame_event = end_frame.release(
-        fn=slider_changed,
-        inputs=[show_trim_preview_btn, video_input, end_frame],
-        outputs=[preview_image, preview_video],
-        show_progress=True,
-    )
-
-    input_type.change(
-        update_radio,
-        inputs=[input_type],
-        outputs=[input_image_group, input_video_group, input_directory_group],
-    )
-    swap_option.change(
-        swap_option_changed,
-        inputs=[swap_option],
-        outputs=[age, specific_face, source_image_input],
-    )
-
-    apply_detection_settings.click(
-        analyse_settings_changed,
-        inputs=[detect_condition_dropdown, detection_size, detection_threshold],
-        outputs=[info],
-    )
-
-    src_specific_inputs = []
-    gen_variable_txt = ",".join(
-        [f"src{i+1}" for i in range(NUM_OF_SRC_SPECIFIC)]
-        + [f"trg{i+1}" for i in range(NUM_OF_SRC_SPECIFIC)]
-    )
-    exec(f"src_specific_inputs = ({gen_variable_txt})")
-    swap_inputs = [
-        input_type,
-        image_input,
-        video_input,
-        direc_input,
-        source_image_input,
-        output_directory,
-        output_name,
-        keep_output_sequence,
-        swap_option,
-        age,
-        distance_slider,
-        face_enhancer_name,
-        enable_face_parser_mask,
-        mask_include,
-        mask_soft_kernel,
-        mask_soft_iterations,
-        blur_amount,
-        erode_amount,
-        face_scale,
-        enable_laplacian_blend,
-        crop_top,
-        crop_bott,
-        crop_left,
-        crop_right,
-        *src_specific_inputs,
-    ]
-
-    swap_outputs = [
-        info,
-        preview_image,
-        output_directory_button,
-        output_video_button,
-        preview_video,
-    ]
-
-    swap_event = swap_button.click(
-        fn=process, inputs=swap_inputs, outputs=swap_outputs, show_progress=True
-    )
-
-    cancel_button.click(
-        fn=stop_running,
-        inputs=None,
-        outputs=[info],
-        cancels=[
-            swap_event,
-            trim_and_reload_event,
-            set_slider_range_event,
-            start_frame_event,
-            end_frame_event,
-        ],
-        show_progress=True,
-    )
-    output_directory_button.click(
-        lambda: open_directory(path=WORKSPACE), inputs=None, outputs=None
-    )
-    output_video_button.click(
-        lambda: open_directory(path=OUTPUT_FILE), inputs=None, outputs=None
-    )
 
 if __name__ == "__main__":
     if USE_COLAB:
         print("Running in colab mode")
 
-    interface.queue(concurrency_count=2, max_size=20).launch(share=USE_COLAB)
+        iface.queue(concurrency_count=2, max_size=20).launch(share=USE_COLAB)