Update app.py

app.py

@@ -120,7 +120,7 @@ def load_img(nparr, gray: bool = False):
     return np_img, alpha_channel
     
 model = None
-def model_process(image, mask):
+def model_process_1(image, mask):
     global model
     
     # input = request.files
@@ -218,6 +218,98 @@ def model_process(image, mask):
     return ext
     '''
     
+def model_process(input) #image, mask):
+    global model
+    # input = request.files
+    # RGB
+    origin_image_bytes = input["image"].read()
+    print(f'origin_image_bytes = ', type(origin_image_bytes), len(origin_image_bytes))
+
+    image, alpha_channel = load_img(origin_image_bytes)
+    original_shape = image.shape
+    interpolation = cv2.INTER_CUBIC
+
+    form = request.form
+    print(f'size_limit_1_ =  ', form["sizeLimit"], type(input["image"]))
+    size_limit: Union[int, str] = form.get("sizeLimit", "1080")
+    print(f'size_limit_2_ =  {size_limit}')
+    if size_limit == "Original":
+        size_limit = max(image.shape)
+    else:
+        size_limit = int(size_limit)
+    print(f'size_limit_3_ =  {size_limit}')
+
+    config = Config(
+        ldm_steps=form["ldmSteps"],
+        ldm_sampler=form["ldmSampler"],
+        hd_strategy=form["hdStrategy"],
+        zits_wireframe=form["zitsWireframe"],
+        hd_strategy_crop_margin=form["hdStrategyCropMargin"],
+        hd_strategy_crop_trigger_size=form["hdStrategyCropTrigerSize"],
+        hd_strategy_resize_limit=form["hdStrategyResizeLimit"],
+        prompt=form["prompt"],
+        use_croper=form["useCroper"],
+        croper_x=form["croperX"],
+        croper_y=form["croperY"],
+        croper_height=form["croperHeight"],
+        croper_width=form["croperWidth"],
+        sd_mask_blur=form["sdMaskBlur"],
+        sd_strength=form["sdStrength"],
+        sd_steps=form["sdSteps"],
+        sd_guidance_scale=form["sdGuidanceScale"],
+        sd_sampler=form["sdSampler"],
+        sd_seed=form["sdSeed"],
+        cv2_flag=form["cv2Flag"],
+        cv2_radius=form['cv2Radius']
+    )
+
+    print(f'config/alpha_channel/size_limit = {config} / {alpha_channel} / {size_limit}')
+    if config.sd_seed == -1:
+        config.sd_seed = random.randint(1, 999999999)
+
+    logger.info(f"Origin image shape: {original_shape}")
+    print(f"Origin image shape: {original_shape} / {image[250][250]}")
+    image = resize_max_size(image, size_limit=size_limit, interpolation=interpolation)
+    logger.info(f"Resized image shape: {image.shape} / {type(image)}")
+    print(f"Resized image shape: {image.shape} / {image[250][250]}")
+
+    mask, _ = load_img(input["mask"].read(), gray=True)
+    mask = resize_max_size(mask, size_limit=size_limit, interpolation=interpolation)
+    print(f"mask image shape: {mask.shape} / {type(mask)} / {mask[250][250]}")
+
+    start = time.time()
+    res_np_img = model(image, mask, config)
+    logger.info(f"process time: {(time.time() - start) * 1000}ms")
+    print(f"process time: {(time.time() - start) * 1000}ms, {res_np_img.shape} / {res_np_img[250][250]}")
+
+    torch.cuda.empty_cache()
+
+    if alpha_channel is not None:
+        print(f"liuyz_here_1_: {alpha_channel}")
+        if alpha_channel.shape[:2] != res_np_img.shape[:2]:
+            alpha_channel = cv2.resize(
+                alpha_channel, dsize=(res_np_img.shape[1], res_np_img.shape[0])
+            )
+        res_np_img = np.concatenate(
+            (res_np_img, alpha_channel[:, :, np.newaxis]), axis=-1
+        )
+
+    image = Image.fromarray(res_np_img)
+    image.save(f'./result_image.png')
+    return image
+    '''
+    ext = get_image_ext(origin_image_bytes)
+
+    response = make_response(
+        send_file(
+            io.BytesIO(numpy_to_bytes(res_np_img, ext)),
+            mimetype=f"image/{ext}",
+        )
+    )
+    response.headers["X-Seed"] = str(config.sd_seed)
+    return response
+    '''
+    
 model = ModelManager(
         name='lama',
         device=device,
@@ -258,7 +350,7 @@ def predict(dict):
     # mask = dict["mask"] # .convert("RGB") #.resize((512, 512))
     '''
    
-    output = model_process(dict["image"], dict["mask"])
+    output = model_process(dict) # dict["image"], dict["mask"])
     # output = mask #output.images[0]
     # output = pipe(prompt = prompt, image=init_image, mask_image=mask,guidance_scale=7.5)