init commit

app.py

@@ -0,0 +1,10 @@
+import gradio as gr
+
+from app_img2img import create_demo as create_demo_face
+
+with gr.Blocks(css="style.css") as demo:
+    with gr.Tabs():
+        with gr.Tab(label="Face"):
+            create_demo_face()
+
+demo.launch()

app_img2img.py

@@ -0,0 +1,110 @@
+import spaces
+import gradio as gr
+import time
+import torch
+
+from PIL import Image
+from segment_utils import(
+    segment_image,
+    restore_result,
+)
+from diffusers import (
+    StableDiffusionXLImg2ImgPipeline
+)
+
+BASE_MODEL = "stabilityai/stable-diffusion-xl-base-1.0"
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+DEFAULT_EDIT_PROMPT = "a beautiful hollywood woman,photo,detailed,8k,high quality,highly detailed,high resolution"
+DEFAULT_NEGATIVE_PROMPT = "nude, nudity, nsfw, nipple, Bare-chested, palm hand, hands, fingers, deformed iris, deformed pupils, semi-realistic, cgi, 3d, render, sketch, cartoon, drawing, text, close up, cropped, out of frame, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, cloned face, disfigured"
+
+DEFAULT_CATEGORY = "face"
+
+basepipeline = StableDiffusionXLImg2ImgPipeline.from_pretrained(
+    BASE_MODEL,
+    torch_dtype=torch.float16,
+    variant="fp16",
+    use_safetensors=True,
+)
+
+basepipeline = basepipeline.to(DEVICE)
+
+
+@spaces.GPU(duration=15)
+def image_to_image(
+    input_image: Image,
+    edit_prompt: str,
+    seed: int,
+    num_steps: int,
+    guidance_scale: float,
+):
+    run_task_time = 0
+    time_cost_str = ''
+    run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str)
+    generator = torch.Generator(device=DEVICE).manual_seed(seed)
+    generated_image = basepipeline(
+        generator=generator,
+        prompt=edit_prompt,
+        negative_prompt=DEFAULT_NEGATIVE_PROMPT,
+        image=input_image,
+        guidance_scale=guidance_scale,
+        num_inference_steps = num_steps,
+    ).images[0]
+    
+    run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str)
+
+    return generated_image, time_cost_str
+
+def get_time_cost(run_task_time, time_cost_str):
+    now_time = int(time.time()*1000)
+    if run_task_time == 0:
+        time_cost_str = 'start'
+    else:
+        if time_cost_str != '': 
+            time_cost_str += f'-->'
+        time_cost_str += f'{now_time - run_task_time}'
+    run_task_time = now_time
+    return run_task_time, time_cost_str
+
+def create_demo() -> gr.Blocks:
+    with gr.Blocks() as demo:
+        croper = gr.State()
+        with gr.Row():
+            with gr.Column():
+                edit_prompt = gr.Textbox(lines=1, label="Edit Prompt", value=DEFAULT_EDIT_PROMPT)
+                generate_size = gr.Number(label="Generate Size", value=1024)
+                category = gr.Textbox(label="Category", value=DEFAULT_CATEGORY, visible=False)
+            with gr.Column():
+                num_steps = gr.Slider(minimum=1, maximum=100, value=30, step=1, label="Num Steps")
+                guidance_scale = gr.Slider(minimum=0, maximum=30, value=15, step=0.5, label="Guidance Scale")
+                mask_expansion = gr.Number(label="Mask Expansion", value=300, visible=False)
+            with gr.Column():
+                mask_dilation = gr.Slider(minimum=0, maximum=10, value=2, step=1, label="Mask Dilation")
+                seed = gr.Number(label="Seed", value=8)
+                g_btn = gr.Button("Edit Image")
+                
+        with gr.Row():
+            with gr.Column():
+                input_image = gr.Image(label="Input Image", type="pil")
+            with gr.Column():
+                restored_image = gr.Image(label="Restored Image", type="pil", interactive=False)
+            with gr.Column():
+                origin_area_image = gr.Image(label="Origin Area Image", type="pil", interactive=False)
+                generated_image = gr.Image(label="Generated Image", type="pil", interactive=False)
+                generated_cost = gr.Textbox(label="Time cost by step (ms):", visible=True, interactive=False)
+        
+        g_btn.click(
+            fn=segment_image,
+            inputs=[input_image, category, generate_size, mask_expansion, mask_dilation],
+            outputs=[origin_area_image, croper],
+        ).success(
+            fn=image_to_image,
+            inputs=[origin_area_image, edit_prompt,seed, num_steps, guidance_scale],
+            outputs=[generated_image, generated_cost],
+        ).success(
+            fn=restore_result,
+            inputs=[croper, category, generated_image],
+            outputs=[restored_image],
+        )
+
+    return demo

checkpoints/selfie_multiclass_256x256.tflite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c6748b1253a99067ef71f7e26ca71096cd449baefa8f101900ea23016507e0e0
+size 16371837

croper.py

@@ -0,0 +1,108 @@
+import PIL
+import numpy as np
+
+from PIL import Image
+
+class Croper:
+    def __init__(
+        self,
+        input_image: PIL.Image,
+        target_mask: np.ndarray,
+        mask_size: int = 256,
+        mask_expansion: int = 20,
+    ):
+        self.input_image = input_image
+        self.target_mask = target_mask
+        self.mask_size = mask_size
+        self.mask_expansion = mask_expansion
+    
+    def corp_mask_image(self):
+        target_mask = self.target_mask
+        input_image = self.input_image
+        mask_expansion = self.mask_expansion
+        original_width, original_height = input_image.size
+        mask_indices = np.where(target_mask)
+        start_y = np.min(mask_indices[0])
+        end_y = np.max(mask_indices[0])
+        start_x = np.min(mask_indices[1])
+        end_x = np.max(mask_indices[1])
+        mask_height = end_y - start_y
+        mask_width = end_x - start_x
+        # choose the max side length
+        max_side_length = max(mask_height, mask_width)
+        # expand the mask area
+        height_diff = (max_side_length - mask_height) // 2
+        width_diff = (max_side_length - mask_width) // 2
+        start_y = start_y - mask_expansion - height_diff
+        if start_y < 0:
+            start_y = 0
+        end_y = end_y + mask_expansion + height_diff
+        if end_y > original_height:
+            end_y = original_height
+        start_x = start_x - mask_expansion - width_diff
+        if start_x < 0:
+            start_x = 0
+        end_x = end_x + mask_expansion + width_diff
+        if end_x > original_width:
+            end_x = original_width
+        expanded_height = end_y - start_y
+        expanded_width = end_x - start_x
+        expanded_max_side_length = max(expanded_height, expanded_width)
+        # calculate the crop area
+        crop_mask = target_mask[start_y:end_y, start_x:end_x]
+        crop_mask_start_y = (expanded_max_side_length - expanded_height) // 2
+        crop_mask_end_y = crop_mask_start_y + expanded_height
+        crop_mask_start_x = (expanded_max_side_length - expanded_width) // 2
+        crop_mask_end_x = crop_mask_start_x + expanded_width
+        # create a square mask
+        square_mask = np.zeros((expanded_max_side_length, expanded_max_side_length), dtype=target_mask.dtype)
+        square_mask[crop_mask_start_y:crop_mask_end_y, crop_mask_start_x:crop_mask_end_x] = crop_mask
+        square_mask_image = Image.fromarray((square_mask * 255).astype(np.uint8))
+
+        crop_image = input_image.crop((start_x, start_y, end_x, end_y))
+        square_image = Image.new("RGB", (expanded_max_side_length, expanded_max_side_length))
+        square_image.paste(crop_image, (crop_mask_start_x, crop_mask_start_y))
+
+        self.origin_start_x = start_x
+        self.origin_start_y = start_y
+        self.origin_end_x = end_x
+        self.origin_end_y = end_y
+
+        self.square_start_x = crop_mask_start_x
+        self.square_start_y = crop_mask_start_y
+        self.square_end_x = crop_mask_end_x
+        self.square_end_y = crop_mask_end_y
+
+        self.square_length = expanded_max_side_length
+        self.square_mask_image = square_mask_image
+        self.square_image = square_image
+        self.corp_mask = crop_mask
+
+        mask_size = self.mask_size
+        self.resized_square_mask_image = square_mask_image.resize((mask_size, mask_size))
+        self.resized_square_image = square_image.resize((mask_size, mask_size))
+
+        return self.resized_square_mask_image
+    
+    def restore_result(self, generated_image):
+        square_length = self.square_length
+        generated_image = generated_image.resize((square_length, square_length))
+        square_mask_image = self.square_mask_image
+        cropped_generated_image = generated_image.crop((self.square_start_x, self.square_start_y, self.square_end_x, self.square_end_y))
+        cropped_square_mask_image = square_mask_image.crop((self.square_start_x, self.square_start_y, self.square_end_x, self.square_end_y))
+
+        restored_image = self.input_image.copy()
+        restored_image.paste(cropped_generated_image, (self.origin_start_x, self.origin_start_y), cropped_square_mask_image)
+        
+        return restored_image
+    
+    def restore_result_v2(self, generated_image):
+        square_length = self.square_length
+        generated_image = generated_image.resize((square_length, square_length))
+        cropped_generated_image = generated_image.crop((self.square_start_x, self.square_start_y, self.square_end_x, self.square_end_y))
+
+        restored_image = self.input_image.copy()
+        restored_image.paste(cropped_generated_image, (self.origin_start_x, self.origin_start_y))
+        
+        return restored_image
+        

requirements.txt

@@ -0,0 +1,8 @@
+gradio
+torch
+torchvision
+diffusers
+transformers
+accelerate
+mediapipe
+spaces

segment_utils.py

@@ -0,0 +1,88 @@
+import numpy as np
+import mediapipe as mp
+
+from PIL import Image
+from mediapipe.tasks import python
+from mediapipe.tasks.python import vision
+from scipy.ndimage import binary_dilation
+from croper import Croper
+
+segment_model = "checkpoints/selfie_multiclass_256x256.tflite"
+base_options = python.BaseOptions(model_asset_path=segment_model)
+options = vision.ImageSegmenterOptions(base_options=base_options,output_category_mask=True)
+segmenter = vision.ImageSegmenter.create_from_options(options)
+
+def restore_result(croper, category, generated_image):
+    square_length = croper.square_length
+    generated_image = generated_image.resize((square_length, square_length))
+
+    cropped_generated_image = generated_image.crop((croper.square_start_x, croper.square_start_y, croper.square_end_x, croper.square_end_y))
+    cropped_square_mask_image = get_restore_mask_image(croper, category, cropped_generated_image)
+
+    restored_image = croper.input_image.copy()
+    restored_image.paste(cropped_generated_image, (croper.origin_start_x, croper.origin_start_y), cropped_square_mask_image)
+
+    return restored_image
+
+def segment_image(input_image, category, generate_size, mask_expansion, mask_dilation):
+    mask_size = int(generate_size)
+    mask_expansion = int(mask_expansion)
+
+    image = mp.Image(image_format=mp.ImageFormat.SRGB, data=np.asarray(input_image))
+    segmentation_result = segmenter.segment(image)
+    category_mask = segmentation_result.category_mask
+    category_mask_np = category_mask.numpy_view()
+
+    if category == "hair":
+        target_mask = get_hair_mask(category_mask_np, mask_dilation)
+    elif category == "clothes":
+        target_mask = get_clothes_mask(category_mask_np, mask_dilation)
+    elif category == "face":
+        target_mask = get_face_mask(category_mask_np, mask_dilation)
+    else:
+        target_mask = get_face_mask(category_mask_np, mask_dilation)
+    
+    croper = Croper(input_image, target_mask, mask_size, mask_expansion)
+    croper.corp_mask_image()
+    origin_area_image = croper.resized_square_image
+
+    return origin_area_image, croper
+
+def get_face_mask(category_mask_np, dilation=1):
+    face_skin_mask = category_mask_np == 3
+    if dilation > 0:
+        face_skin_mask = binary_dilation(face_skin_mask, iterations=dilation)
+
+    return face_skin_mask
+
+def get_clothes_mask(category_mask_np, dilation=1):
+    body_skin_mask = category_mask_np == 2
+    clothes_mask = category_mask_np == 4
+    combined_mask = np.logical_or(body_skin_mask, clothes_mask)
+    combined_mask = binary_dilation(combined_mask, iterations=4)
+    if dilation > 0:
+        combined_mask = binary_dilation(combined_mask, iterations=dilation)
+    return combined_mask
+
+def get_hair_mask(category_mask_np, dilation=1):
+    hair_mask = category_mask_np == 1
+    if dilation > 0:
+        hair_mask = binary_dilation(hair_mask, iterations=dilation)
+    return hair_mask
+
+def get_restore_mask_image(croper, category, generated_image):
+    image = mp.Image(image_format=mp.ImageFormat.SRGB, data=np.asarray(generated_image))
+    segmentation_result = segmenter.segment(image)
+    category_mask = segmentation_result.category_mask
+    category_mask_np = category_mask.numpy_view()
+
+    if category == "hair":
+        target_mask = get_hair_mask(category_mask_np, 0)
+    elif category == "clothes":
+        target_mask = get_clothes_mask(category_mask_np, 0)
+    elif category == "face":
+        target_mask = get_face_mask(category_mask_np, 0)
+    
+    combined_mask = np.logical_or(target_mask, croper.corp_mask)
+    mask_image = Image.fromarray((combined_mask * 255).astype(np.uint8))
+    return mask_image