refactor: 移除 PIL 依赖并重构推理逻辑为 NumPy

- 用 NumPy 替代 PIL 实现图像填充与裁剪操作，减少外部依赖
- 优化推理流程，将 Albumentations 和模型推理逻辑调整为以 NumPy 数组处理
- 使用 OpenCV 替代 PIL

app.py

@@ -1,4 +1,3 @@
-import io
 import json
 from contextlib import asynccontextmanager
 from pathlib import Path
@@ -7,7 +6,6 @@ import albumentations as A
 import cv2
 import numpy as np
 import torch
-from PIL import Image
 from anyio.to_thread import run_sync
 from fastapi import FastAPI, Request, UploadFile, File
 from fastapi.responses import Response
@@ -95,66 +93,64 @@ async def predict(request: Request, file: UploadFile = File(...)):
                 new_w = (orig_w // TRAIN_SIZE + (1 if orig_w % TRAIN_SIZE != 0 else 0)) * TRAIN_SIZE
                 new_h = (orig_h // TRAIN_SIZE + (1 if orig_h % TRAIN_SIZE != 0 else 0)) * TRAIN_SIZE
 
-                # 2. Padding 原圖
-                padded_img = Image.new("RGB", (new_w, new_h), (0, 0, 0))
-                padded_img.paste(original_image, (0, 0))
+                # 2. Padding 原圖 (使用 NumPy 創建黑色畫布)
+                padded_img = np.zeros((new_h, new_w, 3), dtype=np.uint8)
+                # 將原圖貼到左上角 (NumPy 切片賦值)
+                padded_img[:orig_h, :orig_w, :] = original_image
 
-                result_mask = Image.new("L", (new_w, new_h))
+                # 創建結果掩碼畫布 (單通道)
+                result_mask = np.zeros((new_h, new_w), dtype=np.uint8)
 
                 # 3. 循環切割
                 for y in range(0, new_h, TRAIN_SIZE):
                     for x in range(0, new_w, TRAIN_SIZE):
-                        box = (x, y, x + TRAIN_SIZE, y + TRAIN_SIZE)
-                        patch = padded_img.crop(box)
+                        # NumPy 切片代替 crop
+                        patch = padded_img[y:y + TRAIN_SIZE, x:x + TRAIN_SIZE]
 
-                        # --- 修改部分: Albumentations 處理 ---
-                        patch_np = np.array(patch)  # 轉換為 numpy
-                        transformed = preprocess_fn(image=patch_np)
-                        input_tensor = transformed["image"].unsqueeze(0).to(device)  # [1, C, H, W]
-                        # -----------------------------------
+                        # Albumentations 處理 (patch 已經是 numpy array)
+                        transformed = preprocess_fn(image=patch)
+                        input_tensor = transformed["image"].unsqueeze(0).to(device)
 
                         output = model(input_tensor)
 
                         pred_mask = (output > 0.5).float().squeeze().cpu().numpy()
                         pred_mask = (pred_mask * 255).astype(np.uint8)
 
-                        patch_mask_img = Image.fromarray(pred_mask)
-                        result_mask.paste(patch_mask_img, (x, y))
+                        # 將預測結果貼回大圖
+                        result_mask[y:y + TRAIN_SIZE, x:x + TRAIN_SIZE] = pred_mask
 
-                final_image = result_mask.crop((0, 0, orig_w, orig_h))
+                # 裁剪回原始尺寸
+                final_image = result_mask[:orig_h, :orig_w]
 
             # ==============================
             # 情況 B: 圖片小於等於 512
             # ==============================
             else:
-                pad_w = TRAIN_SIZE
-                pad_h = TRAIN_SIZE
+                # 創建黑色畫布
+                padded_img = np.zeros((TRAIN_SIZE, TRAIN_SIZE, 3), dtype=np.uint8)
+                padded_img[:orig_h, :orig_w, :] = original_image
 
-                padded_img = Image.new("RGB", (pad_w, pad_h), (0, 0, 0))
-                padded_img.paste(original_image, (0, 0))
-
-                # --- 修改部分: Albumentations 處理 ---
-                patch_np = np.array(padded_img)  # 轉換為 numpy
-                transformed = preprocess_fn(image=patch_np)
+                # Albumentations 處理
+                transformed = preprocess_fn(image=padded_img)
                 input_tensor = transformed["image"].unsqueeze(0).to(device)
-                # -----------------------------------
 
                 output = model(input_tensor)
 
                 pred_mask = (output > 0.5).float().squeeze().cpu().numpy()
                 pred_mask = (pred_mask * 255).astype(np.uint8)
 
-                final_image = Image.fromarray(pred_mask).crop((0, 0, orig_w, orig_h))
+                # 裁剪回原始尺寸
+                final_image = pred_mask[:orig_h, :orig_w]
 
         return final_image
 
     # 執行推理
     result_image = await run_sync(_inference_logic)
 
-    # 返回圖片流
-    img_byte_arr = io.BytesIO()
-    result_image.save(img_byte_arr, format='PNG')
-    return Response(content=img_byte_arr.getvalue(), media_type="image/png")
+    # 返回圖片流 (使用 cv2.imencode)
+    # result_image 是单通道灰度图，可以直接编码为 PNG
+    success, encoded_image = cv2.imencode(".png", result_image)
+    return Response(content=encoded_image.tobytes(), media_type="image/png")
 
 
 @app.get("/")