Upload 8 files

app.py

@@ -0,0 +1,79 @@
+"""
+Image Enhancer Main App
+-----------------------
+Aplikasi utama Gradio untuk menjalankan UI image enhancer berbasis tab.
+Untuk versi ini, hanya ada 1 tab "Enhance" yang memanggil demo dari modul app_enhance.
+
+Created by _drat | 2025
+"""
+
+import gradio as gr
+
+from app_enhance import create_demo as create_demo_enhance  # Import fungsi untuk membangun demo UI 'Enhance'
+# from app_upscale import create_demo as create_demo_upscale  # Import fungsi untuk membangun demo UI 'Upscale'
+from themes import IndonesiaTheme  # Impor tema custom
+
+import warnings
+warnings.filterwarnings("ignore")
+
+# CSS untuk styling antarmuka
+css = """
+#col-left, #col-mid {
+    margin: 0 auto;
+    max-width: 400px;
+    padding: 10px;
+    border-radius: 15px;
+    background-color: #f9f9f9;
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+}
+#col-right {
+    margin: 0 auto;
+    max-width: 400px;
+    padding: 10px;
+    border-radius: 15px;
+    background: linear-gradient(180deg, #B6BBC4, #EEEEEE);
+    color: white;
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+}
+#col-bott {
+    margin: 0 auto;
+    padding: 10px;
+    border-radius: 15px;
+    background-color: #f9f9f9;
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+}
+#banner {
+    width: 100%;
+    text-align: center;
+    margin-bottom: 20px;
+}
+#run-button {
+    background-color: #ff4b5c;
+    color: white;
+    font-weight: bold;
+    padding: 30px;
+    border-radius: 10px;
+    cursor: pointer;
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+}
+#footer {
+    text-align: center;
+    margin-top: 20px;
+    color: silver;
+}
+#markdown-silver {
+    color: silver; /* Mengatur warna font Markdown menjadi silver */
+}
+"""
+
+
+# Inisialisasi Gradio Blocks dengan custom CSS (style.css)
+with gr.Blocks(css=css, theme=IndonesiaTheme()) as demo:
+    with gr.Tabs():
+        with gr.Tab(label="✨ Enhance"):
+            create_demo_enhance()   # Panggil UI Enhance dari app_enhance.py (atau sesuai modul Anda)
+        # with gr.Tab(label="🚀 Upscale"):
+        #     create_demo_upscale()   # Panggil UI Upscale dari app_upscale.py (atau sesuai modul Anda)
+
+# Jalankan aplikasi Gradio (local/web)
+demo.queue(api_open=False).launch(show_api=False)

app_enhance.py

@@ -0,0 +1,221 @@
+"""
+Image Enhancer App
+------------------
+Aplikasi berbasis Gradio untuk meningkatkan kualitas gambar dengan berbagai teknik pemrosesan citra
+seperti perbaikan resolusi, penajaman, dan penghilangan noise. 
+Dapat digunakan secara lokal maupun sebagai web-app AI image enhancement.
+
+Created by _drat | 2025
+"""
+
+# Import library standar dan eksternal yang dibutuhkan
+import os
+import subprocess
+import spaces  # Library dari HuggingFace untuk GPU management & dekorator
+import torch   # Library untuk deep learning, cek GPU
+import cv2     # OpenCV untuk pengolahan gambar
+import uuid    # Untuk generate nama file unik
+import gradio as gr # Untuk membuat UI web berbasis Python
+import numpy as np  # Operasi numerik, termasuk array
+
+from PIL import Image   # Untuk memproses dan menyimpan gambar
+# Import arsitektur model dan utilitas untuk enhancement & upscaling
+from basicsr.archs.srvgg_arch import SRVGGNetCompact
+from gfpgan.utils import GFPGANer
+from realesrgan.utils import RealESRGANer
+
+import warnings
+warnings.filterwarnings("ignore")
+
+# Fungsi untuk menjalankan command shell (misal: wget file model)
+def runcmd(cmd, verbose = False):
+    process = subprocess.Popen(
+        cmd,
+        stdout = subprocess.PIPE,
+        stderr = subprocess.PIPE,
+        text = True,
+        shell = True
+    )
+    std_out, std_err = process.communicate()
+    if verbose:
+        print(std_out.strip(), std_err)
+    pass
+
+# Pastikan model AI (GFPGAN dan RealESRGAN) sudah terdownload. Jika belum, otomatis download.
+if not os.path.exists('GFPGANv1.4.pth'):
+    runcmd("wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth -P .")
+if not os.path.exists('realesr-general-x4v3.pth'):
+    runcmd("wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-x4v3.pth -P .")
+
+# Inisialisasi model Real-ESRGAN untuk upscaling gambar
+model = SRVGGNetCompact(num_in_ch=3, num_out_ch=3, num_feat=64, num_conv=32, upscale=4, act_type='prelu')
+model_path = 'realesr-general-x4v3.pth'
+half = True if torch.cuda.is_available() else False  # Pakai mode half-precision jika ada GPU (lebih cepat)
+upsampler = RealESRGANer(
+    scale=4, model_path=model_path, model=model, 
+    tile=0, tile_pad=10, pre_pad=0, half=half
+)
+
+# Fungsi utama untuk enhance gambar (dipanggil saat tombol di UI ditekan)
+@spaces.GPU(duration=15)
+def enhance_image(
+    input_image: Image,      # Gambar input dari user (PIL Image)
+    scale: int,              # Skala upscaling (misal: 2x, 4x)
+    enhance_mode: str,       # Mode enhance: face saja, image saja, atau keduanya
+):
+    only_face = enhance_mode == "Only Face Enhance"
+    
+    # Pilih mode enhancer: hanya wajah, hanya gambar, atau kombinasi
+    if enhance_mode == "Only Face Enhance":
+        face_enhancer = GFPGANer(
+            model_path='GFPGANv1.4.pth', upscale=scale, 
+            arch='clean', channel_multiplier=2
+        )
+    elif enhance_mode == "Only Image Enhance":
+        face_enhancer = None  # Tidak enhance wajah, hanya upscaling gambar saja
+    else:
+        face_enhancer = GFPGANer(
+            model_path='GFPGANv1.4.pth', upscale=scale, 
+            arch='clean', channel_multiplier=2, bg_upsampler=upsampler
+        )
+    
+    # Konversi gambar input ke format BGR (OpenCV)
+    img = cv2.cvtColor(np.array(input_image), cv2.COLOR_RGB2BGR)
+    h, w = img.shape[0:2]
+
+    # Optional: perbesar gambar jika terlalu kecil (kurang dari 300px)
+    if h < 300:
+        img = cv2.resize(img, (w * 2, h * 2), interpolation=cv2.INTER_LANCZOS4)
+    
+    # Proses enhance gambar (tergantung mode)
+    if face_enhancer is not None:
+        # Enhance wajah (GFPGAN), output gambar hasil enhancement
+        _, _, output = face_enhancer.enhance(
+            img, has_aligned=False, only_center_face=only_face, paste_back=True
+        )
+    else:
+        # Hanya upscaling image (tanpa enhance wajah)
+        output, _ = upsampler.enhance(img, outscale=scale)
+
+    # --- Optional resize (tidak digunakan)
+    # if scale != 2:
+    #     interpolation = cv2.INTER_AREA if scale < 2 else cv2.INTER_LANCZOS4
+    #     h, w = img.shape[0:2]
+    #     output = cv2.resize(output, (int(w * scale / 2), int(h * scale / 2)), interpolation=interpolation)
+    
+    # Batasi hasil enhance agar tidak lebih dari 3480px (biar aman dan efisien)
+    h, w = output.shape[0:2]
+    max_size = 3480
+    if h > max_size:
+        w = int(w * max_size / h)
+        h = max_size
+    if w > max_size:
+        h = int(h * max_size / w)
+        w = max_size
+    
+    # Resize hasil akhir
+    output = cv2.resize(output, (w, h), interpolation=cv2.INTER_LANCZOS4)
+
+    # Konversi kembali ke RGB & PIL Image (untuk output Gradio)
+    enhanced_image = Image.fromarray(cv2.cvtColor(output, cv2.COLOR_BGR2RGB))
+    
+    # Simpan gambar hasil enhance ke folder output dengan nama unik
+    tmpPrefix = "/tmp/gradio/"
+    extension = 'png'
+    # targetDir = f"{tmpPrefix}output/"
+    targetDir = "output/"
+    if not os.path.exists(targetDir):
+        os.makedirs(targetDir)
+
+    enhanced_path = f"{targetDir}{uuid.uuid4()}.{extension}"
+    enhanced_image.save(enhanced_path, quality=100)
+        
+    return enhanced_image, enhanced_path  # Return: image untuk preview dan path file untuk download
+
+
+#
+# DEMO DI SINI
+#
+
+def create_demo() -> gr.Blocks:
+    with gr.Blocks() as demo:
+        # Feature Image dengan border subtle & shadow
+        gr.HTML(
+            """
+            <div style='display:flex; justify-content:center;'>
+                <img src='https://i.ibb.co/jkkT7MZQ/feature-image-enhancer.jpg' 
+                     alt='Feature Image' 
+                     style='height:200px; width:auto; border-radius:24px; box-shadow:0 4px 18px #ffa07430; border:2.5px solid #ffe0b3;' 
+                     id='feature-image'/>
+            </div>
+            """
+        )
+        # Judul & Tagline dengan emoji & gradient text
+        gr.Markdown("""
+            <div style="text-align:center; margin-top: -10px; margin-bottom: 14px;">
+                <span style="font-size:2.1rem; font-family:'Quicksand',sans-serif; font-weight:800; background: linear-gradient(90deg,#d84040,#ff914d 60%); -webkit-background-clip: text; color:transparent; display:inline-block;">
+                    <span style="vertical-align:middle;">📸</span> Image Enhancer <b>Pro</b> <span style="font-size:1.1em;vertical-align:middle;">✨</span>
+                </span><br>
+                <span style="font-size:1.12rem; color:#d84040; font-family:'Inter',sans-serif;">
+                    <span style="vertical-align:middle;">🤖</span> Foto blur? Jadikan jernih & tajam pakai AI! 
+                </span>
+            </div>
+        """)
+
+        # Input dan Output dalam card, dengan icon pada title
+        with gr.Row():
+            with gr.Column(scale=1):
+                with gr.Group(elem_id="input-card"):
+                    gr.Markdown("<div class='card-title'><span style='font-size:1.3em;vertical-align:middle;'>🖼️</span> <b>Gambar Asli</b></div>")
+                    input_image = gr.Image(label="", type="pil", elem_id="input-image", show_label=False)
+                    gr.Markdown("<div class='hint'><span style='font-size:1.1em;'>⬆️</span> Upload foto format <b>JPG/PNG</b>, max 5MB</div>")
+            with gr.Column(scale=1):
+                with gr.Group(elem_id="output-card"):
+                    gr.Markdown("<div class='card-title'><span style='font-size:1.3em;vertical-align:middle;'>🌈</span> <b>Hasil AI Enhance</b></div>")
+                    output_image = gr.Image(label="", type="pil", interactive=False, elem_id="output-image", show_label=False)
+                    enhance_image_path = gr.File(label="⬇️ Download (.png)", interactive=False, elem_id="download-btn")
+                    gr.Markdown("""
+                        <div class='hint' style="color:#ff914d;"><span style='font-size:1.2em;'>💡</span> Klik untuk download hasilnya!</div>
+                    """)
+
+        # Kontrol dengan ikon pada label
+        with gr.Group(elem_id="control-card"):
+            with gr.Row():
+                scale = gr.Slider(
+                    minimum=1,
+                    maximum=4,
+                    value=2,
+                    step=1,
+                    label="🔎 Upscale x",
+                    elem_id="scale-slider"
+                )
+                enhance_mode = gr.Dropdown(
+                    label="🛠️ Mode Enhance",
+                    choices=[
+                        "Only Face Enhance",
+                        "Only Image Enhance",
+                        "Face Enhance + Image Enhance",
+                    ],
+                    value="Face Enhance + Image Enhance",
+                    elem_id="mode-dropdown"
+                )
+                g_btn = gr.Button("🚀 Enhance Sekarang!", elem_id="enhance-btn", size="lg")
+
+        g_btn.click(
+            fn=enhance_image,
+            inputs=[input_image, scale, enhance_mode],
+            outputs=[output_image, enhance_image_path],
+        )
+        # Footer dengan ikon & sentuhan branding
+        # Tambahkan footer di bagian bawah
+        gr.HTML("""
+            <footer id="footer">
+                Transfer Energi Semesta Digital © 2024 | 🇮🇩 Untuk Indonesia Jaya!
+            </footer>
+            """)
+
+    return demo
+
+
+
+

app_upscale.py

@@ -0,0 +1,148 @@
+"""
+Image Upscaler App
+------------------
+Aplikasi AI berbasis Gradio yang memanfaatkan Stable Diffusion Upscaler untuk meningkatkan resolusi gambar.
+Tersedia juga fitur segmentasi & restorasi area tertentu pada gambar (misal: wajah).
+Aplikasi mendukung input prompt teks untuk conditioning hasil upscaling.
+
+Created by _drat | 2025
+"""
+
+# Import library eksternal yang diperlukan
+import requests
+from PIL import Image
+from io import BytesIO
+from diffusers import StableDiffusionUpscalePipeline # Pipeline Stable Diffusion untuk upscaling gambar
+import torch
+import gradio as gr
+import time
+import spaces
+
+# Import fungsi segmentasi dan restorasi (definisi di segment_utils.py)
+from segment_utils import(
+    segment_image,   # Untuk segmentasi area penting pada gambar (misal: wajah)
+    restore_result,  # Untuk menggabungkan hasil upscaling dengan gambar asli
+)
+
+# Setup device: gunakan CUDA (GPU) jika tersedia, jika tidak fallback ke CPU
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f'{device} is available')  # Debug: print device yang digunakan
+
+# Load model Stable Diffusion Upscaler dari HuggingFace
+model_id = "stabilityai/stable-diffusion-x4-upscaler"
+upscale_pipe = StableDiffusionUpscalePipeline.from_pretrained(model_id, torch_dtype=torch.float16)
+upscale_pipe = upscale_pipe.to(device)
+
+# Default prompt dan kategori (untuk input Gradio)
+DEFAULT_SRC_PROMPT = "a person with pefect face"
+DEFAULT_CATEGORY = "face"
+
+# Fungsi utama untuk membuat UI aplikasi Gradio
+def create_demo() -> gr.Blocks:
+
+    # --- [ Function Definitions Tetap Seperti Asli Anda ] ---
+    @spaces.GPU(duration=30)
+    def upscale_image(
+        input_image: Image,
+        prompt: str,
+        num_inference_steps: int = 10,
+    ):
+        time_cost_str = ''
+        run_task_time = 0
+        run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str)
+        upscaled_image = upscale_pipe(
+            prompt=prompt, 
+            image=input_image,
+            num_inference_steps=num_inference_steps,
+        ).images[0]
+        run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str)
+        return upscaled_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
+
+    # --- [ UI Section ] ---
+    with gr.Blocks(css="creative_enhance.css") as demo:
+        gr.HTML("""
+        <div style='display:flex; justify-content:center;'>
+            <img src='https://i.ibb.co/pvWSfsMJ/feature-image-upscaler.jpg' alt='Feature Image' style='height:200px; width:auto; border-radius:24px; box-shadow:0 4px 18px #ffa07430; border:2.5px solid #ffe0b3;' id='feature-image'/>
+            </div>
+        <div style='text-align:center;margin-top:6px;'>
+            <span style='font-size:2.0rem;font-weight:800;color:#d84040;letter-spacing:0.04em;font-family:Quicksand,sans-serif;'>
+                🔬 <b>AI Image Upscaler</b> <span style='font-size:1.2em;vertical-align:middle;'>🚀</span>
+            </span>
+            <br>
+            <span style='font-size:1.1rem;color:#ff914d;font-family:Inter,sans-serif;'>Perbesar gambar <b>HD</b> otomatis, detail makin nyata!</span>
+        </div>
+        """)
+
+        # Input prompt & parameter di satu card
+        with gr.Row():
+            with gr.Group(elem_id="control-card"):
+                with gr.Row():
+                    input_image_prompt = gr.Textbox(
+                        lines=1, label="🎯 Prompt AI (opsional)",
+                        value=DEFAULT_SRC_PROMPT, elem_id="input-image-prompt"
+                    )
+                    num_inference_steps = gr.Number(
+                        label="⚙️ Steps (Quality)", value=5, elem_id="num-inference"
+                    )
+                    generate_size = gr.Number(
+                        label="📐 Size (px)", value=512, elem_id="generate-size"
+                    )
+                g_btn = gr.Button("🪄 Upscale Sekarang", elem_id="upscale-btn")
+
+        # Input & Output Gambar
+        with gr.Row():
+            with gr.Column(scale=1):
+                with gr.Group(elem_id="input-card"):
+                    gr.Markdown("<div class='card-title'><span style='font-size:1.2em;'>🖼️</span> Gambar Asli</div>")
+                    input_image = gr.Image(label="", type="pil", elem_id="input-image", show_label=False)
+                    gr.Markdown("<div class='hint'><span style='font-size:1.1em;'>⬆️</span> JPG/PNG max 5MB</div>")
+            with gr.Column(scale=1):
+                with gr.Group(elem_id="output-card"):
+                    gr.Markdown("<div class='card-title'><span style='font-size:1.2em;'>💡</span> Upscale Preview</div>")
+                    restored_image = gr.Image(label="Hasil Akhir", format="png", type="pil", interactive=False)
+                    origin_area_image = gr.Image(label="", format="png", type="pil", interactive=False, visible=False)
+                    upscaled_image = gr.Image(label="Upscaled", format="png", type="pil", interactive=False)
+                    download_path = gr.File(label="⬇️ Download Image", interactive=False, elem_id="download-btn")
+                    gr.Markdown("<div class='hint'><span style='font-size:1.1em;'>💾</span> Download hasil upscale PNG</div>")
+                    generated_cost = gr.Textbox(label="⏱️ Time (ms)", visible=True, interactive=False)
+
+        # Hidden inputs untuk workflow
+        category = gr.Textbox(label="Category", value=DEFAULT_CATEGORY, visible=False)
+        mask_expansion = gr.Number(label="Mask Expansion", value=20, visible=False)
+        mask_dilation = gr.Slider(minimum=0, maximum=10, value=2, step=1, label="Mask Dilation", visible=False)
+        croper = gr.State()
+
+        # Workflow chaining
+        g_btn.click(
+            fn=segment_image,
+            inputs=[input_image, category, generate_size, mask_expansion, mask_dilation],
+            outputs=[origin_area_image, croper],
+        ).success(
+            fn=upscale_image,
+            inputs=[origin_area_image, input_image_prompt, num_inference_steps],
+            outputs=[upscaled_image, generated_cost],
+        ).success(
+            fn=restore_result,
+            inputs=[croper, category, upscaled_image],
+            outputs=[restored_image, download_path],
+        )
+
+        gr.Markdown("""
+        <div style='text-align:center;color:#aaa;font-size:0.98rem;margin-top:14px;'>
+            &copy; 2025 <b>AI Image Upscaler</b> • Powered by <b>_drat</b> 🚀
+        </div>
+        """)
+
+    return demo
+

croper.py

@@ -0,0 +1,135 @@
+"""
+Croper Utility
+--------------
+Kelas utilitas untuk melakukan crop area tertentu (berbasis mask) pada gambar, lalu menyiapkan square crop image dan square mask.
+Juga menyediakan fungsi untuk mengembalikan (restore) hasil modifikasi ke gambar asli.
+
+Created by _drat | 2025
+"""
+
+import PIL
+import numpy as np
+from PIL import Image
+
+class Croper:
+    def __init__(
+        self,
+        input_image: PIL.Image,      # Gambar input (format PIL Image)
+        target_mask: np.ndarray,     # Mask biner area target (array numpy)
+        mask_size: int = 256,        # Ukuran akhir mask & image yang dihasilkan (default 256x256)
+        mask_expansion: int = 20,    # Ekspansi area mask (agar crop lebih lebar)
+    ):
+        self.input_image = input_image
+        self.target_mask = target_mask
+        self.mask_size = mask_size
+        self.mask_expansion = mask_expansion
+    
+    # Fungsi utama untuk crop area sesuai mask dan membentuk square crop & mask
+    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
+
+        # Cari koordinat bounding box area mask (area bertanda True/1)
+        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
+
+        # Ambil sisi terpanjang untuk square crop
+        max_side_length = max(mask_height, mask_width)
+
+        # Ekspansi area mask agar crop tidak terlalu sempit
+        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)
+
+        # Crop mask dari area yang sudah diekspansi
+        crop_mask = target_mask[start_y:end_y, start_x:end_x]
+
+        # Hitung posisi crop mask pada square mask
+        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
+
+        # Buat square mask dengan area crop mask di tengah
+        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 asli sesuai area ekspansi
+        crop_image = input_image.crop((start_x, start_y, end_x, end_y))
+        # Buat square image, lalu paste crop image di tengah
+        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))
+
+        # Simpan koordinat/ukuran untuk keperluan restore nanti
+        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
+
+        # Resize hasil square mask & image ke mask_size (misal: 256x256) untuk kebutuhan pipeline AI
+        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  # Kembalikan mask hasil resize
+    
+    # Fungsi untuk restore hasil generate ke gambar asli dengan bantuan mask transparan
+    def restore_result(self, generated_image):
+        square_length = self.square_length
+        # Resize hasil generate ke ukuran square original
+        generated_image = generated_image.resize((square_length, square_length))
+        square_mask_image = self.square_mask_image
+        # Crop area yang sudah di-generate sesuai posisi awal
+        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))
+
+        # Tempel hasil generate ke gambar asli dengan mask transparan
+        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
+    
+    # Versi restore tanpa mask (area hasil tempelkan langsung tanpa transparansi)
+    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

enhance_utils.py

@@ -0,0 +1,95 @@
+"""
+Enhance Utils
+-------------
+Utility functions untuk meningkatkan kualitas gambar dengan menggunakan model AI:
+- Real-ESRGAN untuk upscaling gambar umum
+- GFPGAN untuk enhancement wajah (face restoration)
+
+Created by _drat | 2025
+"""
+
+import os
+import torch
+import cv2
+import numpy as np
+import subprocess
+
+from PIL import Image
+from gfpgan.utils import GFPGANer
+from basicsr.archs.srvgg_arch import SRVGGNetCompact
+from realesrgan.utils import RealESRGANer
+
+# Fungsi untuk menjalankan perintah shell (misal: pip, wget)
+def runcmd(cmd, verbose = False, *args, **kwargs):
+    process = subprocess.Popen(
+        cmd,
+        stdout = subprocess.PIPE,
+        stderr = subprocess.PIPE,
+        text = True,
+        shell = True
+    )
+    std_out, std_err = process.communicate()
+    if verbose:
+        print(std_out.strip(), std_err)
+    pass
+
+# Debug: Menampilkan daftar library yang terinstall di environment
+runcmd("pip freeze")
+
+# Download model GFPGAN jika belum ada di direktori saat ini
+if not os.path.exists('GFPGANv1.4.pth'):
+    runcmd("wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth -P .")
+
+# Download model RealESRGAN jika belum ada di direktori saat ini
+if not os.path.exists('realesr-general-x4v3.pth'):
+    runcmd("wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-x4v3.pth -P .")
+
+# Inisialisasi model Real-ESRGAN (untuk upscaling gambar umum)
+model = SRVGGNetCompact(num_in_ch=3, num_out_ch=3, num_feat=64, num_conv=32, upscale=4, act_type='prelu')
+model_path = 'realesr-general-x4v3.pth'
+half = True if torch.cuda.is_available() else False  # Pakai half precision jika tersedia GPU
+upsampler = RealESRGANer(
+    scale=4,
+    model_path=model_path,
+    model=model,
+    tile=0,
+    tile_pad=10,
+    pre_pad=0,
+    half=half
+)
+
+# Inisialisasi enhancer wajah (GFPGAN)
+face_enhancer = GFPGANer(
+    model_path='GFPGANv1.4.pth',
+    upscale=1,                 # Default tidak melakukan upscaling (hanya enhance wajah)
+    arch='clean',
+    channel_multiplier=2
+)
+
+# Fungsi utama enhancement gambar
+def enhance_image(
+    pil_image: Image,     # Input gambar dalam format PIL
+    enhance_face: bool = False, # Apakah perlu enhance wajah?
+):
+    # Konversi PIL image ke array BGR (OpenCV)
+    img = cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR)
+
+    h, w = img.shape[0:2]
+    # Optional: jika gambar kecil, perbesar dulu agar hasil enhancement lebih maksimal
+    if h < 300:
+        img = cv2.resize(img, (w * 2, h * 2), interpolation=cv2.INTER_LANCZOS4)
+    
+    # Enhance menggunakan GFPGAN (wajah) atau Real-ESRGAN (umum)
+    if enhance_face:
+        # Hanya enhance bagian wajah utama di tengah gambar
+        _, _, output = face_enhancer.enhance(
+            img, has_aligned=False, only_center_face=True, paste_back=True
+        )
+    else:
+        # Upscale seluruh gambar dengan Real-ESRGAN (outscale=2x)
+        output, _ = upsampler.enhance(img, outscale=2)
+    
+    # Konversi hasil output ke format PIL RGB untuk siap digunakan di aplikasi
+    pil_output = Image.fromarray(cv2.cvtColor(output, cv2.COLOR_BGR2RGB))
+
+    return pil_output

requirements.txt

@@ -0,0 +1,12 @@
+torch
+torchvision
+diffusers
+transformers
+accelerate
+mediapipe
+gradio
+spaces
+gfpgan
+git+https://github.com/XPixelGroup/BasicSR@master
+facexlib
+realesrgan

segment_utils.py

@@ -0,0 +1,123 @@
+"""
+Segment Utils
+-------------
+Utilitas segmentasi gambar berbasis MediaPipe dan mask biner untuk aplikasi image enhancer/upscaler:
+- Segmentasi area: wajah, rambut, pakaian, dll.
+- Membuat dan mengelola mask hasil segmentasi serta integrasi dengan class Croper
+- Mendukung proses restore hasil generate ke gambar asli
+
+Created by _drat | 2025
+"""
+
+import numpy as np
+import mediapipe as mp
+import uuid
+import os
+
+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
+
+# Inisialisasi model segmentasi MediaPipe (load tflite model untuk multiclass selfie segmentation)
+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)
+
+# Fungsi untuk mengembalikan hasil generate ke gambar asli, dengan mask transparan hasil segmentasi
+def restore_result(croper, category, generated_image):
+    square_length = croper.square_length
+    generated_image = generated_image.resize((square_length, square_length))
+
+    # Crop area hasil generate, lalu buat mask hasil restore
+    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)
+
+    # Tempel hasil generate ke gambar asli dengan mask transparan
+    restored_image = croper.input_image.copy()
+    restored_image.paste(cropped_generated_image, (croper.origin_start_x, croper.origin_start_y), cropped_square_mask_image)
+
+    extension = 'png'
+    tmpPrefix = "/tmp/gradio/"
+    # targetDir = f"{tmpPrefix}output/"
+    targetDir = "output/"
+    if not os.path.exists(targetDir):
+        os.makedirs(targetDir)
+
+    path = f"{targetDir}{uuid.uuid4()}.{extension}"
+    restored_image.save(path, quality=100)
+
+    return restored_image, path
+
+# Fungsi utama segmentasi gambar sesuai kategori
+def segment_image(input_image, category, input_size, mask_expansion, mask_dilation):
+    mask_size = int(input_size)
+    mask_expansion = int(mask_expansion)
+
+    # Konversi input image ke format yang sesuai untuk MediaPipe
+    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()
+
+    # Pilih fungsi pembentukan mask sesuai kategori segmentasi
+    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)
+    
+    # Buat objek Croper dengan mask hasil segmentasi, untuk crop & resize
+    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  # Kembalikan area hasil crop + objek croper
+
+# Fungsi pembuat mask khusus area wajah (+opsi dilasi mask)
+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
+
+# Fungsi pembuat mask khusus area baju (dan kulit tubuh)
+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
+
+# Fungsi pembuat mask khusus area rambut
+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
+
+# Fungsi untuk membuat mask kombinasi hasil generate dan area awal (untuk proses restore)
+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)
+    
+    # Gabungkan mask hasil segmentasi dan mask area awal croper
+    combined_mask = np.logical_or(target_mask, croper.corp_mask)
+    mask_image = Image.fromarray((combined_mask * 255).astype(np.uint8))
+    return mask_image

themes.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from typing import Iterable
+from gradio.themes.base import Base
+from gradio.themes.utils import colors, fonts, sizes
+
+class IndonesiaTheme(Base):
+    def __init__(
+        self,
+        *,
+        primary_hue: colors.Color | str = colors.red,
+        secondary_hue: colors.Color | str = colors.orange,
+        neutral_hue: colors.Color | str = colors.gray,
+        spacing_size: sizes.Size | str = sizes.spacing_md,
+        radius_size: sizes.Size | str = sizes.radius_md,
+        text_size: sizes.Size | str = sizes.text_lg,
+        font: fonts.Font
+        | str
+        | Iterable[fonts.Font | str] = (
+            fonts.GoogleFont("Quicksand"),
+            "ui-sans-serif",
+            "sans-serif",
+        ),
+        font_mono: fonts.Font
+        | str
+        | Iterable[fonts.Font | str] = (
+            fonts.GoogleFont("IBM Plex Mono"),
+            "ui-monospace",
+            "monospace",
+        ),
+    ):
+        super().__init__(
+            primary_hue=primary_hue,
+            secondary_hue=secondary_hue,
+            neutral_hue=neutral_hue,
+            spacing_size=spacing_size,
+            radius_size=radius_size,
+            text_size=text_size,
+            font=font,
+            font_mono=font_mono,
+        )
+        super().set(
+            # Ganti background dengan gradasi putih ke coklat muda (contoh: #fff ke #fbeee0)
+            body_background_fill="linear-gradient(to bottom, #fff 65%, #fbeee0 100%)",
+            body_background_fill_dark="linear-gradient(to bottom, #c8b7a6 70%, #7c6957 100%)",  # gradasi coklat untuk dark mode
+            button_primary_background_fill="linear-gradient(90deg, #d84a4a, #b33030)",
+            button_primary_background_fill_hover="linear-gradient(90deg, #e85b5b, #cc4b4b)",
+            button_primary_text_color="white",
+            button_primary_background_fill_dark="linear-gradient(90deg, #b33030, #8f1f1f)",
+            slider_color="*secondary_300",
+            slider_color_dark="*secondary_600",
+            block_title_text_weight="600",
+            block_border_width="2px",
+            block_shadow="*shadow_drop_lg",
+        )