Update app.py

app.py

@@ -1,154 +1,310 @@
+import os
+import cv2
 import gradio as gr
 import numpy as np
 import random
+import base64
+import requests
+import json
+import time
 
-# import spaces #[uncomment to use ZeroGPU]
-from diffusers import DiffusionPipeline
-import torch
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model_repo_id = "stabilityai/sdxl-turbo"  # Replace to the model you would like to use
-
-if torch.cuda.is_available():
-    torch_dtype = torch.float16
-else:
-    torch_dtype = torch.float32
-
-pipe = DiffusionPipeline.from_pretrained(model_repo_id, torch_dtype=torch_dtype)
-pipe = pipe.to(device)
-
-MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 1024
-
-
-# @spaces.GPU #[uncomment to use ZeroGPU]
-def infer(
-    prompt,
-    negative_prompt,
-    seed,
-    randomize_seed,
-    width,
-    height,
-    guidance_scale,
-    num_inference_steps,
-    progress=gr.Progress(track_tqdm=True),
-):
+
+def character_gen(prompt, person_img, seed, randomize_seed, height, width, faceFidelity, refFidelity):
+    post_start_time = time.time()
+    if person_img is None:
+        gr.Warning("Empty Person image")
+        return None, None, "Empty image"
+    if prompt is None:
+        gr.Warning("Empty prompt")
+        return None, None, "Empty prompt"
     if randomize_seed:
         seed = random.randint(0, MAX_SEED)
+    encoded_person_img = cv2.imencode('.jpg', cv2.cvtColor(person_img, cv2.COLOR_RGB2BGR))[1].tobytes()
+    encoded_person_img = base64.b64encode(encoded_person_img).decode('utf-8')
 
-    generator = torch.Generator().manual_seed(seed)
+    url = "http://" + os.environ['character_url'] + "Submit"
+    token = os.environ['token']
+    referer = os.environ['referer']
+    headers = {'Content-Type': 'application/json', 'token': token, 'referer': referer}
+    data = {
+        "humanImage": encoded_person_img,
+        "seed": seed,
+        "prompt": prompt,
+        "width": width,
+        "height": height,
+        "faceFidelity": faceFidelity,
+        "refFidelity": refFidelity
+    }
+    try:
+        response = requests.post(url, headers=headers, data=json.dumps(data), timeout=50)
+        # print("post response code", response.status_code)
+        if response.status_code == 200:
+            result = response.json()['result']
+            status = result['status']
+            if status == "success":
+                uuid = result['result']
+                # print(uuid)
+    except Exception as err:
+        print(f"Post Exception Error: {err}")
+        raise gr.Error("Too many users, please try again later")
+    post_end_time = time.time()
+    print(f"post time used: {post_end_time-post_start_time}")
 
-    image = pipe(
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        guidance_scale=guidance_scale,
-        num_inference_steps=num_inference_steps,
-        width=width,
-        height=height,
-        generator=generator,
-    ).images[0]
+    get_start_time =time.time()
+    time.sleep(9)
+    Max_Retry = 12
+    result_img = None
+    info = ""
+    err_log = ""
+    for i in range(Max_Retry):
+        try:
+            url = "http://" + os.environ['character_url'] + "Query?taskId=" + uuid
+            response = requests.get(url, headers=headers, timeout=20)
+            # print("get response code", response.status_code)
+            if response.status_code == 200:
+                result = response.json()['result']
+                status = result['status']
+                if status == "success":
+                    result = base64.b64decode(result['result'])
+                    result_np = np.frombuffer(result, np.uint8)
+                    result_img = cv2.imdecode(result_np, cv2.IMREAD_UNCHANGED)
+                    result_img = cv2.cvtColor(result_img, cv2.COLOR_RGB2BGR)
+                    info = "Success"
+                    break
+                elif status == "error":
+                    err_log = f"Status is Error"
+                    info = "Error"
+                    break
+            else:
+                # print(response.text)
+                err_log = "URL error, pleace contact the admin"
+                info = "URL error, pleace contact the admin"
+                break
+        except requests.exceptions.ReadTimeout:
+            err_log = "Http Timeout"
+            info = "Http Timeout, please try again later"
+        except Exception as err:
+            err_log = f"Get Exception Error: {err}"
+        time.sleep(1)
+    get_end_time = time.time()
+    print(f"get time used: {get_end_time-get_start_time}")
+    print(f"all time used: {get_end_time-get_start_time+post_end_time-post_start_time}")
+    if info == "":
+        err_log = f"No image after {Max_Retry} retries"
+        info = "Too many users, please try again later"
+    if info != "Success":
+        print(f"Error Log: {err_log}")
+        gr.Warning("Too many users, please try again later")
 
-    return image, seed
+    return result_img, seed, info
 
 
-examples = [
-    "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
-    "An astronaut riding a green horse",
-    "A delicious ceviche cheesecake slice",
-]
+MAX_SEED = 999999
+
+example_path = os.path.join(os.path.dirname(__file__), 'assets')
+
+garm_list_path = []
+
+human_list_path = []
 
-css = """
-#col-container {
+css="""
+#col-left {
     margin: 0 auto;
-    max-width: 640px;
+    max-width: 400px;
+}
+#col-right {
+    margin: 0 auto;
+    max-width: 600px;
+}
+#col-showcase {
+    margin: 0 auto;
+    max-width: 1100;
+}
+#button {
+    color: blue;
 }
 """
 
-with gr.Blocks(css=css) as demo:
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(" # Text-to-Image Gradio Template")
+assets_root_path = os.path.join(os.path.dirname(__file__), 'assets')
 
-        with gr.Row():
-            prompt = gr.Text(
-                label="Prompt",
-                show_label=False,
-                max_lines=1,
-                placeholder="Enter your prompt",
-                container=False,
-            )
+# example_list_path = [assets_root_path + '/' + x for x in os.listdir(os.path.join(assets_root_path)) if 'jpg' in x or 'png' in x ]
+
+example_list_path = [
+    assets_root_path + '/demo11.png',
+    assets_root_path + '/demo12.png',
+    assets_root_path + '/demo6.png',
+    assets_root_path + '/demo9.png',
+
+    
+    assets_root_path + '/demo5.jpg',
+    assets_root_path + '/demo2.png',
+    assets_root_path + '/demo4.jpg',
+    assets_root_path + '/demo1.jpg',
+    
+]
+
+prompt_exampler_lists = [
+    "A Young 20-year-old human drinking coffee, full body shot, high quality, sharp focus, luxury cafe decoration",
+    "A beautiful 20-year-old human playing with a grey puppy, full body shot, black sofa in the background, high quality, ultra high",
+    "A photo of a young human reading outdoors. She is sitting on a wooden bench, holding a book in both hands. The background is an autumn city street, with leaves showing rich yellow and orange colors, adding a warm tone to the picture. ",
+]
+
+
+def load_description(fp):
+    with open(fp, 'r', encoding='utf-8') as f:
+        content = f.read()
+    return content
 
-            run_button = gr.Button("Run", scale=0, variant="primary")
+def change_imgs(image1, image2):
+    return image1, image2
 
-        result = gr.Image(label="Result", show_label=False)
+with gr.Blocks(css=css) as Character:
+    gr.HTML(load_description("title.md"))
+    gr.HTML("""
+            <div style="display: flex; justify-content: center; align-items: center; text-align: center; font-size: 20px;">
+                <div>
+                </div>
+                <div>
+                </div>
+            </div>
+            """)
+    
+    with gr.Row():
+        
+        with gr.Column(elem_id="col-left"):
 
-        with gr.Accordion("Advanced Settings", open=False):
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=False,
+            gr.HTML("""
+            <div style="display: flex; justify-content: center; align-items: center; text-align: center; font-size: 20px;">
+                <div>
+                Step 1.  Upload a character image ⬇️
+                </div>
+            </div>
+            """)
+            
+            image = gr.Image(label="Image", type="numpy", width=400)
+
+            example = gr.Examples(
+                inputs= image,
+                examples_per_page= 9,
+                examples=example_list_path
             )
 
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=0,
+            gr.HTML("""
+            <div style="display: flex; justify-content: center; align-items: center; text-align: center; font-size: 20px;">
+                <div>
+                
+                </div>
+                <div>
+                Step 2.  Enter your prompt ⬇️
+                </div>
+                
+            </div>
+            """)
+            
+            prompt = gr.Textbox(
+                label="Prompt",
+                placeholder="Enter your prompt",
+                lines=2
             )
+                
+            gr.Examples(examples=prompt_exampler_lists, inputs= prompt, examples_per_page= 6 )
+            
 
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+        with gr.Column(elem_id="col-right"):
+            
+            gr.HTML("""
+            <div style="display: flex; justify-content: center; align-items: center; text-align: center; font-size: 20px;">
+                <div>
+                Step 3. Press “Run” to get results ⬇️
+                </div>
+            </div>
+            """)
+            
+            result = gr.Image(label="Result", show_label=False)
 
+         
             with gr.Row():
-                width = gr.Slider(
-                    label="Width",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
-                )
-
                 height = gr.Slider(
                     label="Height",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
+                    minimum=0,
+                    maximum=1344,
+                    step=64,
+                    value=1024,
+                )
+                width = gr.Slider(
+                    label="Width",
+                    minimum=0,
+                    maximum=1344,
+                    step=64,
+                    value=1024,
                 )
 
+                        
             with gr.Row():
-                guidance_scale = gr.Slider(
-                    label="Guidance scale",
+                face_scale = gr.Slider(
+                    label="Face_scale",
                     minimum=0.0,
-                    maximum=10.0,
-                    step=0.1,
-                    value=0.0,  # Replace with defaults that work for your model
+                    maximum=1.0,
+                    step=0.05,
+                    value=0.8,
+                )
+                ref_scale = gr.Slider(
+                    label="Ref_scale",
+                    minimum=0.0,
+                    maximum=1.0,
+                    step=0.05,
+                    value=0.8,
                 )
 
-                num_inference_steps = gr.Slider(
-                    label="Number of inference steps",
-                    minimum=1,
-                    maximum=50,
+                
+            with gr.Row():
+                seed = gr.Slider(
+                    label="Seed",
+                    minimum=0,
+                    maximum=MAX_SEED,
                     step=1,
-                    value=2,  # Replace with defaults that work for your model
+                    value=0,
                 )
-
-        gr.Examples(examples=examples, inputs=[prompt])
-    gr.on(
-        triggers=[run_button.click, prompt.submit],
-        fn=infer,
-        inputs=[
-            prompt,
-            negative_prompt,
-            seed,
-            randomize_seed,
-            width,
-            height,
-            guidance_scale,
-            num_inference_steps,
-        ],
-        outputs=[result, seed],
+                randomize_seed = gr.Checkbox(label="Random seed", value=True)
+            with gr.Row():
+                seed_used = gr.Number(label="Seed used")
+                result_info = gr.Text(label="Response")
+                
+            with gr.Row():
+                button = gr.Button("Run", elem_id="button")
+            
+    
+    button.click(
+        fn = character_gen,
+        inputs = [ prompt, image, seed, randomize_seed, height, width, face_scale, ref_scale  ],
+        outputs = [result, seed_used]
     )
 
-if __name__ == "__main__":
-    demo.launch()
+
+    
+    with gr.Column(elem_id = "col-showcase"):
+        gr.HTML("""
+        <div style="display: flex; justify-content: center; align-items: center; text-align: center; font-size: 20px;">
+            <div> </div>
+            <br>
+            <div>
+                Character examples in pairs of character images and prompt
+            </div>
+        </div>
+        """)
+        
+        show_case = gr.Examples(
+            examples=[
+                ["assets/demo9.png", "A photo of a young human reading outdoors. He is sitting on a wooden bench, holding a book in both hands, reading attentively. The background is an autumn city street, with leaves showing rich yellow and orange colors, adding a warm tone to the picture. The streets are lined with classical-style buildings, black street lamps and road signs are clearly visible, and some pedestrians and vehicles can be seen in the distance, giving people a peaceful living atmosphere. The sun shines in from the left, illuminating the entire scene, making both the characters and the background appear very clear and bright. The whole image has soft colors, moderate saturation, uniform lighting, and accurate white balance, creating a harmonious and natural visual effect.", "assets/results/res_demo9.png"],
+                ["assets/demo12.png", "A Young human drinking coffee, full body shot, high quality, sharp focus, luxury cafe decoration", "assets/results/res_demo12.png"],
+                ["assets/demo1.jpg", "Indoor photo showing a woman sitting on a chair, her legs crossed, her left hand resting naturally on her thigh, her right hand slightly raised, fingers touching the side of her cheek. The chair she sits on is in classic style, covered in beige fabric, with a wooden frame decorated with gold rivets on the back and armrests. The chair is placed on a light wooden floor, and the light coming in from the window on the right illuminates the entire scene, making the environment warm and bright. The curtains can be seen in the background, the color is light gray, similar to the color of the wall, and the overall tone is soft. There is a green plant planted in a woven basket on the left, adding a natural atmosphere. The sunlight outside the window shines in through the white gauze curtain, forming a soft light and shadow effect, enhancing the three-dimensional sense of the picture. The person becomes the visual focus, while the surrounding furniture and decorations set off an elegant and peaceful atmosphere. In terms of color, it is mainly warm, with beige, light gray and brown as the main colors, and the overall color saturation is moderate, with sufficient brightness but not overexposed. The exposure level is just right, so that the details are clearly visible, and there are no obvious dark or bright areas. This photo has a typical realistic style of indoor life.", "assets/results/res_demo1.png"],
+                ["assets/demo4.jpg", "A young beautiful woman, full_body,  stands in front of the Paris Tower, XS, masterpiece, best quality,high resolution,unity 8k wallpaper, perfect lighting,extremely detailed CG,finely detail,extremely detailed,soft lighting and shadow,soft yet striking lighting, skin pores, detailed skin texture , Detailed face, depth of field.", "assets/results/res_demo4.png"],
+                ["assets/demo5.jpg", "A woman sits on a black leather sofa, holding a gray poodle in her arms. The woman gently hugs the dog with her left hand and puts her right hand on her knees, with a calm and natural expression. The poodle is medium-sized, with dark gray fur, curly and fluffy, and looks very soft. The dog's mouth is slightly open, with its tongue sticking out, looking very cute and relaxed. The background is a pure white wall with no other decorations, which makes the subject stand out more. The overall color tone is fresh and bright, and the light is even and soft, highlighting the details and texture of the person and the pet.", "assets/results/res_demo5.png"],
+            ],
+            inputs=[image, prompt, result],
+            label=None
+        )
+
+
+
+Character.queue().launch(debug=True)