Update app.py

app.py

@@ -2,111 +2,114 @@ import gradio as gr
 import torch
 import cv2
 import numpy as np
-from PIL import Image
 import base64
+from PIL import Image
 import io
 from realesrgan import RealESRGANer
 from basicsr.archs.rrdbnet_arch import RRDBNet
 
 # === KONFIGURASI MODEL ===
-# Kita menggunakan RealESRGAN_x4plus (bagus untuk general image/realistis)
-# Jika kamu lebih fokus ke anime, bisa ganti ke RealESRGAN_x4plus_anime_6B
 MODEL_NAME = 'RealESRGAN_x4plus'
 MODEL_PATH = 'https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth'
 
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-print(f"Menggunakan device: {device}")
+print(f"Device: {device}")
 
-# Inisialisasi arsitektur model
+# Inisialisasi Model
 model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
-
-# Inisialisasi RealESRGANer
 upsampler = RealESRGANer(
     scale=4,
     model_path=MODEL_PATH,
     model=model,
-    tile=0, # Atur > 0 jika kehabisan memori (misal: 400), 0 berarti tidak di-tile (lebih cepat tapi butuh VRAM besar)
+    tile=400, # Wajib pakai tile (misal 400) agar tidak OOM (Out Of Memory) di CPU/GPU kecil
     tile_pad=10,
     pre_pad=0,
-    half=True if torch.cuda.is_available() else False, # Gunakan presisi half jika pakai GPU agar lebih cepat
+    half=True if torch.cuda.is_available() else False,
     device=device
 )
 
-# === FUNGSI UTAMA ===
-def decode_base64_to_cv2(base64_string):
-    """Mengubah base64 dari web menjadi format gambar OpenCV (numpy array)"""
-    # Pisahkan header "data:image/png;base64," jika ada
-    if "," in base64_string:
-        base64_string = base64_string.split(",")[1]
-    
-    img_data = base64.b64decode(base64_string)
-    nparr = np.frombuffer(img_data, np.uint8)
-    img_cv2 = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-    return img_cv2
+def decode_base64_to_image(base64_string):
+    """Decode base64 string to OpenCV Image (numpy array)"""
+    try:
+        # Bersihkan string dari prefix data URI jika ada
+        if "base64," in base64_string:
+            base64_string = base64_string.split("base64,")[1]
+            
+        img_data = base64.b64decode(base64_string)
+        nparr = np.frombuffer(img_data, np.uint8)
+        img_cv2 = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        
+        if img_cv2 is None:
+            raise ValueError("CV2 failed to decode image. Data might be corrupted.")
+            
+        return img_cv2
+    except Exception as e:
+        print(f"Error decoding base64: {e}")
+        return None
 
-def encode_cv2_to_base64(img_cv2, ext=".png"):
-    """Mengubah format gambar OpenCV kembali ke base64 untuk dikirim ke web"""
-    _, buffer = cv2.imencode(ext, img_cv2)
-    b64_str = base64.b64encode(buffer).decode("utf-8")
-    return f"data:image/png;base64,{b64_str}"
+def encode_image_to_base64(img_cv2):
+    """Encode OpenCV Image to base64 string"""
+    try:
+        # Gunakan ekstensi .jpg atau .png, .jpg biasanya lebih ringan untuk dikirim balik
+        success, buffer = cv2.imencode(".png", img_cv2)
+        if not success:
+             raise ValueError("CV2 failed to encode image.")
+             
+        b64_str = base64.b64encode(buffer).decode("utf-8")
+        return f"data:image/png;base64,{b64_str}"
+    except Exception as e:
+         print(f"Error encoding image: {e}")
+         return None
+
+def process_upscale(base64_input, target_res):
+    print(f"Menerima request upscale untuk resolusi: {target_res}")
+    
+    img = decode_base64_to_image(base64_input)
+    if img is None:
+        return "ERROR: Gagal membaca input gambar."
 
-def upscale_image(base64_image, target_res):
-    """
-    Fungsi utama yang akan dipanggil oleh API.
-    target_res: '2k' atau '4k'
-    """
     try:
-        # 1. Decode gambar
-        img = decode_base64_to_cv2(base64_image)
-        
-        # 2. Lakukan Upscale (default model ini menaikkan 4x lipat)
-        print("Memulai proses upscaling...")
+        # Upscale x4
         output_img, _ = upsampler.enhance(img, outscale=4)
         
-        # 3. Resize cerdas (Opsional)
-        # RealESRGAN otomatis x4. Jika hasilnya kebesaran, kita resize manual ke target yang diinginkan.
         h, w = output_img.shape[:2]
-        
         target_w, target_h = w, h
+        
+        # Resize sesuai target
         if target_res.lower() == '2k':
-            # Asumsi 2K lebar maksimal ~2560px
             max_size = 2560
             if max(w, h) > max_size:
-                scale_ratio = max_size / max(w, h)
-                target_w = int(w * scale_ratio)
-                target_h = int(h * scale_ratio)
+                scale = max_size / max(w, h)
+                target_w, target_h = int(w * scale), int(h * scale)
                 output_img = cv2.resize(output_img, (target_w, target_h), interpolation=cv2.INTER_AREA)
         elif target_res.lower() == '4k':
-            # Asumsi 4K lebar maksimal ~3840px
             max_size = 3840
             if max(w, h) > max_size:
-                scale_ratio = max_size / max(w, h)
-                target_w = int(w * scale_ratio)
-                target_h = int(h * scale_ratio)
+                scale = max_size / max(w, h)
+                target_w, target_h = int(w * scale), int(h * scale)
                 output_img = cv2.resize(output_img, (target_w, target_h), interpolation=cv2.INTER_AREA)
 
-        print(f"Upscale selesai. Resolusi akhir: {target_w}x{target_h}")
-        
-        # 4. Encode kembali ke base64
-        result_base64 = encode_cv2_to_base64(output_img)
-        return result_base64
+        print(f"Upscale berhasil. Resolusi output: {target_w}x{target_h}")
+        result_b64 = encode_image_to_base64(output_img)
         
+        if result_b64 is None:
+             return "ERROR: Gagal meng-encode gambar hasil."
+             
+        return result_b64
+
     except Exception as e:
-        print(f"Error saat upscaling: {e}")
-        return str(e)
+        import traceback
+        traceback.print_exc()
+        return f"ERROR: Proses upscale gagal. {str(e)}"
 
-# === ANTARMUKA API GRADIO ===
-# Kita definisikan interface tanpa UI web yang rumit karena kita hanya butuh API-nya
+# === GRADIO INTERFACE ===
 with gr.Blocks() as demo:
-    with gr.Row():
-        input_b64 = gr.Textbox(label="Input Base64 Image")
-        input_res = gr.Textbox(label="Target Resolution (2k/4k)", value="2k")
-    
-    output_b64 = gr.Textbox(label="Output Base64 Image")
+    input_text = gr.Textbox(label="Base64 Input")
+    res_text = gr.Textbox(label="Resolution", value="2k")
+    output_text = gr.Textbox(label="Base64 Output")
     
     btn = gr.Button("Upscale")
-    btn.click(fn=upscale_image, inputs=[input_b64, input_res], outputs=output_b64, api_name="predict")
+    btn.click(fn=process_upscale, inputs=[input_text, res_text], outputs=output_text, api_name="predict")
 
-# Jalankan server
 if __name__ == "__main__":
     demo.queue().launch()