Update app.py

app.py

@@ -1,16 +1,14 @@
 """
 Nesting Otomatis + Visualisasi Layout untuk Percetakan Banner
 ================================================================
-Menggunakan rectpack untuk menghitung penempatan terbaik banner-banner
-pada satu roll/lembar bahan cetak (dengan rotasi otomatis jika hemat bahan),
-dan Pillow untuk menghasilkan gambar pratinjau layout.
+Fokus: MEMINIMALISIR WASTE (space kosong) secara maksimal.
 
 Fitur:
-- Inner/Outer visualization (banner asli vs area margin)
-- Iterasi multi-lebar roll: coba semua ukuran roll, pilih yang paling hemat
+- Inner/Outer visualization
+- Multi-roll otomatis (jika 1 roll tidak cukup, buat roll kedua, dst.)
+- Iterasi multi-lebar roll: pilih kombinasi yang TOTAL WASTE paling sedikit
 - 5 Mode Pencarian: Cepat / Standar / Dalaman / Pro / Menyeluruh
-- Iterasi maksimal: grid search + pre-sort + Monte Carlo + Local Swap
-- Setara kemampuan operator profesional
+- Waste visualization: area kosong ditampilkan dengan grid abu-abu
 - Deploy di Hugging Face Spaces (Gradio SDK)
 """
 
@@ -44,13 +42,11 @@ from rectpack.guillotine import (
 # --------------------------------------------------------------------------
 
 def generate_color(seed_text: str):
-    """Menghasilkan warna acak tapi konsisten berdasarkan label item."""
     random.seed(seed_text)
     return tuple(random.randint(90, 220) for _ in range(3))
 
 
 def load_font(size: int = 14):
-    """Coba pakai font DejaVu (biasanya tersedia di Linux/HF Spaces)."""
     candidates = [
         "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
         "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
@@ -64,21 +60,14 @@ def load_font(size: int = 14):
 
 
 def lighten_color(c, factor=0.55):
-    """Buat warna lebih terang untuk area margin (outer)."""
     return tuple(min(255, int(v + (255 - v) * factor)) for v in c)
 
 
 def get_sort_name(sort_algo):
-    """Konversi constant sort ke string readable."""
     mapping = {
-        SORT_AREA: "AREA",
-        SORT_PERI: "PERI",
-        SORT_LSIDE: "LSIDE",
-        SORT_SSIDE: "SSIDE",
-        SORT_RATIO: "RATIO",
-        SORT_DIFF: "DIFF",
-        SORT_NONE: "NONE",
-        None: "Default",
+        SORT_AREA: "AREA", SORT_PERI: "PERI", SORT_LSIDE: "LSIDE",
+        SORT_SSIDE: "SSIDE", SORT_RATIO: "RATIO", SORT_DIFF: "DIFF",
+        SORT_NONE: "NONE", None: "Default",
     }
     return mapping.get(sort_algo, str(sort_algo))
 
@@ -88,10 +77,6 @@ def get_sort_name(sort_algo):
 # --------------------------------------------------------------------------
 
 def prepare_rects(df: pd.DataFrame, margin: float):
-    """
-    Konversi DataFrame ke daftar rectangle untuk rectpack.
-    Return: (rects, original_dims, total_rects, max_height)
-    """
     rects = []
     original_dims = {}
 
@@ -120,15 +105,13 @@ def prepare_rects(df: pd.DataFrame, margin: float):
 
 
 # --------------------------------------------------------------------------
-# 3. CORE: PACKING ENGINE
+# 3. CORE: PACKING ENGINE (single & multi bin)
 # --------------------------------------------------------------------------
 
 def run_packer(rects, roll_width, max_height, allow_rotation,
                pack_algo=None, sort_algo=None, reverse=False):
     """
-    Jalankan rectpack dengan konfigurasi tertentu.
-    Jika reverse=True, urutan rects dibalik sebelum packing.
-    Return: (placed_rects, used_height, not_placed) atau None jika gagal.
+    Jalankan rectpack. Return: (placed, used_height, not_placed) atau None.
     """
     input_rects = list(reversed(rects)) if reverse else rects[:]
 
@@ -154,84 +137,166 @@ def run_packer(rects, roll_width, max_height, allow_rotation,
     return placed, used_height, not_placed
 
 
-# --------------------------------------------------------------------------
-# 4. VISUALISASI (Pillow) — INNER + OUTER
-# --------------------------------------------------------------------------
-
-def render_layout(placed, used_height, original_dims, roll_width, margin,
-                  px_per_unit=4.0):
+def pack_multi_roll(rects, roll_width, max_height, allow_rotation,
+                    pack_algo=None, sort_algo=None, reverse=False):
     """
-    Gambar hasil packing ke PIL Image.
-    Return: (img, used_area, true_used_area, efficiency, true_efficiency, rotated_count)
+    Packing dengan multi-roll support.
+    Jika ada item yang tidak muat di roll 1, buat roll 2, dst.
+    Return: list of (placed, used_height) per roll, plus not_placed_final.
     """
-    img_w = max(1, int(round(roll_width * px_per_unit)))
-    img_h = max(1, int(round(used_height * px_per_unit)))
-
-    img = Image.new("RGB", (img_w, img_h), "white")
-    draw = ImageDraw.Draw(img)
-    font = load_font(14)
-    font_small = load_font(11)
-
-    for r in placed:
-        base_label = r.rid.rsplit("#", 1)[0]
-        color = generate_color(base_label)
-        outer_color = lighten_color(color, 0.55)
-        inner_color = color
+    remaining = list(reversed(rects)) if reverse else rects[:]
+    rolls = []
+    total_not_placed = 0
+    safety_limit = 50  # max rolls
 
-        orig_w, orig_h = original_dims[r.rid]
-        is_rotated = round(r.width - margin, 3) != round(orig_w, 3)
+    for _ in range(safety_limit):
+        if not remaining:
+            break
 
-        # Koordinat OUTER (termasuk margin)
-        x0 = r.x * px_per_unit
-        y0 = (used_height - r.y - r.height) * px_per_unit
-        x1 = (r.x + r.width) * px_per_unit
-        y1 = (used_height - r.y) * px_per_unit
+        kwargs = {"rotation": allow_rotation}
+        if pack_algo is not None:
+            kwargs["pack_algo"] = pack_algo
+        if sort_algo is not None:
+            kwargs["sort_algo"] = sort_algo
 
-        # Koordinat INNER (banner asli)
-        m = margin * px_per_unit
-        ix0, iy0 = x0 + m / 2, y0 + m / 2
-        ix1, iy1 = x1 - m / 2, y1 - m / 2
+        packer = newPacker(**kwargs)
+        for w, h, rid in remaining:
+            packer.add_rect(w, h, rid=rid)
+        packer.add_bin(roll_width, max_height)
+        packer.pack()
 
-        # Gambar OUTER (area margin) — warna pastel
-        draw.rectangle([x0, y0, x1, y1], fill=outer_color, outline="black", width=2)
+        if len(packer) == 0 or len(packer[0]) == 0:
+            total_not_placed = len(remaining)
+            break
 
-        # Gambar INNER (banner asli) — warna asli
-        if ix1 > ix0 and iy1 > iy0:
-            draw.rectangle([ix0, iy0, ix1, iy1], fill=inner_color, outline="black", width=1)
+        placed = packer[0]
+        used_height = max(r.y + r.height for r in placed)
+        rolls.append((placed, used_height))
 
-        # Label
-        label_text = base_label
-        size_text = f"{orig_w:g} x {orig_h:g}" + (" (diputar)" if is_rotated else "")
+        # Item yang belum terpakai
+        placed_ids = {r.rid for r in placed}
+        remaining = [r for r in remaining if r[2] not in placed_ids]
+        total_not_placed = len(remaining)
 
-        bbox_label = draw.textbbox((0, 0), label_text, font=font)
-        bbox_size = draw.textbbox((0, 0), size_text, font=font_small)
-        total_th = (bbox_label[3] - bbox_label[1]) + (bbox_size[3] - bbox_size[1]) + 4
+    return rolls, total_not_placed
 
-        cx, cy = (x0 + x1) / 2, (y0 + y1) / 2
-        ty = cy - total_th / 2
 
-        if (x1 - x0) > 20 and (y1 - y0) > 20:
-            draw.text((cx, ty), label_text, fill="black", font=font, anchor="ma")
-            draw.text((cx, ty + (bbox_label[3] - bbox_label[1]) + 4), size_text,
-                       fill="black", font=font_small, anchor="ma")
+# --------------------------------------------------------------------------
+# 4. VISUALISASI — MULTI ROLL + WASTE GRID
+# --------------------------------------------------------------------------
 
-    # Bingkai roll
-    draw.rectangle([0, 0, img_w - 1, img_h - 1], outline="red", width=3)
+def draw_waste_grid(draw, x0, y0, x1, y1, step=20):
+    """Gambar grid abu-abu di area kosong untuk menandai waste."""
+    for x in range(int(x0), int(x1), step):
+        draw.line([(x, y0), (x, y1)], fill="#e0e0e0", width=1)
+    for y in range(int(y0), int(y1), step):
+        draw.line([(x0, y), (x1, y)], fill="#e0e0e0", width=1)
 
-    # Statistik
-    used_area = sum(r.width * r.height for r in placed)
-    roll_area = roll_width * used_height
-    efficiency = (used_area / roll_area * 100) if roll_area > 0 else 0
 
-    true_used_area = sum(original_dims[r.rid][0] * original_dims[r.rid][1] for r in placed)
-    true_efficiency = (true_used_area / roll_area * 100) if roll_area > 0 else 0
+def render_multi_roll(rolls, original_dims, roll_width, margin, px_per_unit=4.0):
+    """
+    Render multiple rolls secara vertikal (stacked).
+    Return: (img, total_true_area, total_roll_area, total_rotated)
+    """
+    if not rolls:
+        return None, 0, 0, 0
 
-    rotated_count = sum(
-        1 for r in placed
-        if round(r.width - margin, 3) != round(original_dims[r.rid][0], 3)
-    )
+    img_w = max(1, int(round(roll_width * px_per_unit)))
+    gap_between_rolls = 40  # pixel gap antar roll
+    total_img_h = sum(int(round(h * px_per_unit)) for _, h in rolls)
+    total_img_h += gap_between_rolls * (len(rolls) - 1) + 60  # extra for labels
 
-    return img, used_area, true_used_area, efficiency, true_efficiency, rotated_count
+    img = Image.new("RGB", (img_w, total_img_h), "white")
+    draw = ImageDraw.Draw(img)
+    font = load_font(14)
+    font_small = load_font(11)
+    font_title = load_font(16)
+
+    y_offset = 0
+    total_true_area = 0
+    total_roll_area = 0
+    total_rotated = 0
+
+    for roll_idx, (placed, used_height) in enumerate(rolls):
+        roll_h_px = int(round(used_height * px_per_unit))
+
+        # Label roll
+        roll_label = f"ROLL {roll_idx + 1}  |  {roll_width:g} x {used_height:.1f} cm"
+        draw.text((img_w / 2, y_offset + 5), roll_label,
+                  fill="#cc0000", font=font_title, anchor="ma")
+
+        roll_y0 = y_offset + 25
+        roll_y1 = roll_y0 + roll_h_px
+
+        # Bingkai roll
+        draw.rectangle([0, roll_y0, img_w - 1, roll_y1], outline="red", width=3)
+
+        # Gambar setiap item
+        for r in placed:
+            base_label = r.rid.rsplit("#", 1)[0]
+            color = generate_color(base_label)
+            outer_color = lighten_color(color, 0.55)
+            inner_color = color
+
+            orig_w, orig_h = original_dims[r.rid]
+            is_rotated = round(r.width - margin, 3) != round(orig_w, 3)
+
+            x0 = r.x * px_per_unit
+            y0 = roll_y0 + (used_height - r.y - r.height) * px_per_unit
+            x1 = (r.x + r.width) * px_per_unit
+            y1 = roll_y0 + (used_height - r.y) * px_per_unit
+
+            m = margin * px_per_unit
+            ix0, iy0 = x0 + m / 2, y0 + m / 2
+            ix1, iy1 = x1 - m / 2, y1 - m / 2
+
+            # Outer
+            draw.rectangle([x0, y0, x1, y1], fill=outer_color, outline="black", width=2)
+            # Inner
+            if ix1 > ix0 and iy1 > iy0:
+                draw.rectangle([ix0, iy0, ix1, iy1], fill=inner_color, outline="black", width=1)
+
+            # Label
+            label_text = base_label
+            size_text = f"{orig_w:g} x {orig_h:g}" + (" (diputar)" if is_rotated else "")
+            bbox_label = draw.textbbox((0, 0), label_text, font=font)
+            bbox_size = draw.textbbox((0, 0), size_text, font=font_small)
+            total_th = (bbox_label[3] - bbox_label[1]) + (bbox_size[3] - bbox_size[1]) + 4
+
+            cx, cy = (x0 + x1) / 2, (y0 + y1) / 2
+            ty = cy - total_th / 2
+
+            if (x1 - x0) > 20 and (y1 - y0) > 20:
+                draw.text((cx, ty), label_text, fill="black", font=font, anchor="ma")
+                draw.text((cx, ty + (bbox_label[3] - bbox_label[1]) + 4), size_text,
+                           fill="black", font=font_small, anchor="ma")
+
+            total_true_area += orig_w * orig_h
+            if is_rotated:
+                total_rotated += 1
+
+        # Gambar waste grid di area kosong
+        placed_pixels = []
+        for r in placed:
+            x0 = r.x * px_per_unit
+            y0 = roll_y0 + (used_height - r.y - r.height) * px_per_unit
+            x1 = (r.x + r.width) * px_per_unit
+            y1 = roll_y0 + (used_height - r.y) * px_per_unit
+            placed_pixels.append((x0, y0, x1, y1))
+
+        # Scan area kosong secara kasar (sederhana: per baris)
+        # Untuk efisiensi, kita gambar grid di seluruh roll lalu overlay placed areas
+        # (Pillow tidak mendukung mask kompleks, jadi kita gambar grid di luar placed)
+        # Simplifikasi: gambar grid tipis di seluruh roll, item menutupinya
+        for x in range(0, img_w, 20):
+            draw.line([(x, roll_y0), (x, roll_y1)], fill="#f5f5f5", width=1)
+        for y in range(int(roll_y0), int(roll_y1), 20):
+            draw.line([(0, y), (img_w - 1, y)], fill="#f5f5f5", width=1)
+
+        total_roll_area += roll_width * used_height
+        y_offset = roll_y1 + gap_between_rolls
+
+    return img, total_true_area, total_roll_area, total_rotated
 
 
 # --------------------------------------------------------------------------
@@ -239,10 +304,6 @@ def render_layout(placed, used_height, original_dims, roll_width, margin,
 # --------------------------------------------------------------------------
 
 def get_pre_sort_strategies(rects):
-    """
-    Berbagai strategi pengurutan input manual sebelum masuk rectpack.
-    Return: list of (name, sorted_rects)
-    """
     strategies = []
 
     def area(r): return r[0] * r[1]
@@ -269,7 +330,6 @@ def get_pre_sort_strategies(rects):
     ]
     strategies.extend(base)
 
-    # Group by label (keep same-label items together)
     label_groups = {}
     for r in rects:
         label = r[2].rsplit("#", 1)[0]
@@ -279,7 +339,6 @@ def get_pre_sort_strategies(rects):
         grouped.extend(label_groups[label])
     strategies.append(("group_label", grouped))
 
-    # Interleave large-small (skyline strategy)
     by_area = sorted(rects, key=area, reverse=True)
     interleaved = []
     i, j = 0, len(by_area) - 1
@@ -302,36 +361,38 @@ def search_single_width(rects, original_dims, total_rects, max_height,
                         roll_width, margin, allow_rotation,
                         search_mode, px_per_unit):
     """
-    Iterasi berbagai kombinasi untuk SATU lebar roll tertentu.
-    Return: (img, stats_text, used_height, true_eff) atau (None, error_msg, None, None)
+    Cari layout paling hemat waste untuk SATU lebar roll.
+    Return: (img, stats_text, total_waste, num_rolls) atau (None, error, None, None)
     """
     best_result = None
     best_key = None
     best_config = None
-    best_rects_order = None
+    best_rolls = None
     tried = 0
     failed = 0
 
-    def evaluate(result, config_name, rects_order):
-        nonlocal best_result, best_key, best_config, best_rects_order
-        if result is None:
+    def evaluate(rolls, not_placed, config_name):
+        nonlocal best_result, best_key, best_config, best_rolls
+        if not rolls:
             return
-        placed, used_height, not_placed = result
-        if not_placed > 0:
-            return
-        true_area = sum(original_dims[r.rid][0] * original_dims[r.rid][1] for r in placed)
-        roll_area = roll_width * used_height
-        true_eff = (true_area / roll_area * 100) if roll_area > 0 else 0
-        key = (used_height, -true_eff)
+
+        total_true = sum(
+            original_dims[r.rid][0] * original_dims[r.rid][1]
+            for placed, _ in rolls for r in placed
+        )
+        total_roll = sum(roll_width * h for _, h in rolls)
+        total_waste = total_roll - total_true
+        num_rolls = len(rolls)
+        max_h = max(h for _, h in rolls)
+
+        # Kriteria: waste paling sedikit, lalu roll paling sedikit, lalu tinggi paling rendah
+        key = (total_waste, num_rolls, max_h, not_placed)
         if best_key is None or key < best_key:
             best_key = key
-            best_result = result
+            best_result = (rolls, not_placed)
             best_config = config_name
-            best_rects_order = rects_order[:]
+            best_rolls = rolls
 
-    # ============================================================
-    # PHASE 1: GRID SEARCH
-    # ============================================================
     ALL_PACK_ALGOS = [
         None, MaxRectsBssf, MaxRectsBaf, MaxRectsBl, MaxRectsBlsf,
         SkylineBl, SkylineBlWm, SkylineMwf, SkylineMwfl,
@@ -347,6 +408,7 @@ def search_single_width(rects, original_dims, total_rects, max_height,
     ALL_SORT_ALGOS = [None, SORT_AREA, SORT_PERI, SORT_LSIDE, SORT_SSIDE,
                       SORT_RATIO, SORT_DIFF, SORT_NONE]
 
+    # PHASE 1: GRID SEARCH
     if search_mode in ("standard", "deep", "pro", "exhaustive"):
         if search_mode == "standard":
             pack_algos = [
@@ -365,22 +427,20 @@ def search_single_width(rects, original_dims, total_rects, max_height,
             for sort_algo in sort_algos:
                 for reverse in [False, True]:
                     tried += 1
-                    result = run_packer(
+                    rolls, not_placed = pack_multi_roll(
                         rects, roll_width, max_height, allow_rotation,
                         pack_algo, sort_algo, reverse
                     )
-                    if result is None:
+                    if not rolls:
                         failed += 1
                         continue
                     algo_name = pack_algo.__name__ if pack_algo else "Default"
                     sort_name = get_sort_name(sort_algo)
                     rev = " (rev)" if reverse else ""
                     config = f"[Grid] {algo_name} + SORT_{sort_name}{rev}"
-                    evaluate(result, config, rects)
+                    evaluate(rolls, not_placed, config)
 
-    # ============================================================
     # PHASE 2: PRE-SORT MANUAL
-    # ============================================================
     if search_mode in ("pro", "exhaustive"):
         pre_sorts = get_pre_sort_strategies(rects)
         top_packs = [
@@ -392,53 +452,53 @@ def search_single_width(rects, original_dims, total_rects, max_height,
             for pack_algo in top_packs:
                 for reverse in [False, True]:
                     tried += 1
-                    result = run_packer(
+                    rolls, not_placed = pack_multi_roll(
                         sorted_rects, roll_width, max_height, allow_rotation,
                         pack_algo, SORT_NONE, reverse
                     )
-                    if result is None:
+                    if not rolls:
                         failed += 1
                         continue
                     algo_name = pack_algo.__name__ if pack_algo else "Default"
                     rev = " (rev)" if reverse else ""
                     config = f"[PreSort:{sort_name}] {algo_name}{rev}"
-                    evaluate(result, config, sorted_rects)
+                    evaluate(rolls, not_placed, config)
 
-    # ============================================================
-    # PHASE 3: MONTE CARLO RANDOM SHUFFLE
-    # ============================================================
+    # PHASE 3: MONTE CARLO
     if search_mode in ("pro", "exhaustive"):
         mc_count = 500 if search_mode == "pro" else 2000
-        mc_configs = [
-            (None, None),
-            (MaxRectsBssf, SORT_AREA),
-            (GuillotineBssfSas, SORT_AREA),
-        ]
+        mc_configs = [(None, None), (MaxRectsBssf, SORT_AREA), (GuillotineBssfSas, SORT_AREA)]
 
         for seed in range(mc_count):
             random.seed(seed)
             shuffled = random.sample(rects, len(rects))
             for pack_algo, sort_algo in mc_configs:
                 tried += 1
-                result = run_packer(
+                rolls, not_placed = pack_multi_roll(
                     shuffled, roll_width, max_height, allow_rotation,
                     pack_algo, sort_algo, False
                 )
-                if result is None:
+                if not rolls:
                     failed += 1
                     continue
                 algo_name = pack_algo.__name__ if pack_algo else "Default"
                 config = f"[MC:{seed}] {algo_name}"
-                evaluate(result, config, shuffled)
-
-    # ============================================================
-    # PHASE 4: LOCAL SWAP OPTIMIZATION
-    # ============================================================
-    if search_mode == "exhaustive" and best_rects_order is not None:
-        base_order = best_rects_order[:]
-        n = len(base_order)
+                evaluate(rolls, not_placed, config)
+
+    # PHASE 4: LOCAL SWAP (dari best order)
+    if search_mode == "exhaustive" and best_rolls is not None:
+        # Reconstruct best order
+        best_order = []
+        placed_ids = set()
+        for placed, _ in best_rolls:
+            for r in placed:
+                placed_ids.add(r.rid)
+        for r in rects:
+            if r[2] in placed_ids:
+                best_order.append(r)
+
+        n = len(best_order)
         swap_iters = min(300, n * (n - 1) // 2)
-
         seen_swaps = set()
         attempts = 0
         while len(seen_swaps) < swap_iters and attempts < swap_iters * 3:
@@ -451,45 +511,51 @@ def search_single_width(rects, original_dims, total_rects, max_height,
                 continue
             seen_swaps.add(pair)
 
-            swapped = base_order[:]
+            swapped = best_order[:]
             swapped[i], swapped[j] = swapped[j], swapped[i]
-
             tried += 1
-            result = run_packer(
+            rolls, not_placed = pack_multi_roll(
                 swapped, roll_width, max_height, allow_rotation,
                 None, SORT_NONE, False
             )
-            if result is None:
+            if not rolls:
                 failed += 1
                 continue
             config = f"[Swap:{i}-{j}] Default"
-            evaluate(result, config, swapped)
+            evaluate(rolls, not_placed, config)
 
-    # --- Finalisasi ---
+    # Finalisasi
     if best_result is None:
-        return None, (
-            f"⚠️ Lebar {roll_width:g} cm: tidak ada kombinasi yang muat. "
-            "Banner terlalu besar untuk lebar ini."
-        ), None, None
+        return None, f"⚠️ Lebar {roll_width:g} cm: tidak ada kombinasi yang muat.", None, None
 
-    placed, used_height, not_placed = best_result
-    img, used_area, true_used_area, eff, true_eff, rot_count = render_layout(
-        placed, used_height, original_dims, roll_width, margin, px_per_unit
+    rolls, not_placed = best_result
+    img, total_true_area, total_roll_area, total_rotated = render_multi_roll(
+        rolls, original_dims, roll_width, margin, px_per_unit
     )
 
+    total_waste = total_roll_area - total_true_area
+    waste_pct = (total_waste / total_roll_area * 100) if total_roll_area > 0 else 0
+    num_rolls = len(rolls)
+    total_height = sum(h for _, h in rolls)
+
     stats_lines = [
         f"🏆 Algoritma terpilih         : {best_config}",
         f"🔍 Mode pencarian             : {search_mode.upper()}",
         f"🔍 Total iterasi dicoba       : {tried} (gagal: {failed})",
-        f"✅ Item berhasil ditempatkan  : {len(placed)} / {total_rects}",
-        f"🔄 Item yang diputar 90°      : {rot_count}",
-        f"📏 Ukuran layout terpakai     : {roll_width:g} x {used_height:.1f}",
-        f"📐 Total luas item (asli)     : {true_used_area:.1f} unit²",
-        f"📊 Efisiensi bahan (asli)     : {true_eff:.1f}%",
-        f"📊 Efisiensi bahan (dgn margin): {eff:.1f}%",
+        f"📏 Lebar roll                 : {roll_width:g} cm",
+        f"📦 Jumlah roll yang dibutuhkan : {num_rolls}",
+        f"📏 Total panjang roll         : {total_height:.1f} cm",
+        f"✅ Item berhasil ditempatkan  : {sum(len(p) for p, _ in rolls)} / {total_rects}",
+        f"🔄 Item yang diputar 90°      : {total_rotated}",
+        f"📐 Total luas item (asli)     : {total_true_area:.1f} cm²",
+        f"📐 Total luas roll terpakai   : {total_roll_area:.1f} cm²",
+        f"♻️ TOTAL WASTE                : {total_waste:.1f} cm²",
+        f"📊 Persentase waste           : {waste_pct:.2f}%",
     ]
+    if not_placed > 0:
+        stats_lines.insert(6, f"⚠️ Item TIDAK muat             : {not_placed}")
 
-    return img, "\n".join(stats_lines), used_height, true_eff
+    return img, "\n".join(stats_lines), total_waste, num_rolls
 
 
 # --------------------------------------------------------------------------
@@ -503,12 +569,11 @@ def process(roll_widths_text, margin, allow_rotation, search_mode, table_data):
     df = pd.DataFrame(table_data, columns=["Label", "Width", "Height", "Qty"])
     df = df.dropna(subset=["Width", "Height", "Qty"], how="any")
 
-    # Parse daftar lebar roll
     try:
         widths = [float(w.strip()) for w in roll_widths_text.split(",") if w.strip()]
         widths = [w for w in widths if w > 0]
     except ValueError:
-        return None, "⚠️ Format daftar lebar roll tidak valid. Gunakan angka dipisah koma, misal: 150, 200, 250"
+        return None, "⚠️ Format daftar lebar roll tidak valid. Gunakan angka dipisah koma."
 
     if not widths:
         return None, "⚠️ Masukkan minimal satu lebar roll yang valid."
@@ -518,12 +583,11 @@ def process(roll_widths_text, margin, allow_rotation, search_mode, table_data):
     except (TypeError, ValueError):
         margin = 0.0
 
-    # Persiapkan rects sekali untuk semua lebar
     rects, original_dims, total_rects, max_height = prepare_rects(df, margin)
     if rects is None:
-        return None, "⚠️ Tidak ada data banner yang valid untuk di-nesting."
+        return None, "⚠️ Tidak ada data banner yang valid."
 
-    # --- Iterasi semua lebar roll, cari yang paling hemat ---
+    # Iterasi semua lebar roll, cari yang TOTAL WASTE paling sedikit
     best_overall = None
     best_key = None
     best_width = None
@@ -531,73 +595,89 @@ def process(roll_widths_text, margin, allow_rotation, search_mode, table_data):
 
     for width in widths:
         if search_mode == "quick":
-            # Mode cepat: 1 kombinasi default per lebar
+            # Mode cepat: 1 kombinasi default, single roll
             result = run_packer(rects, width, max_height, bool(allow_rotation))
             if result is None:
-                width_results.append((width, None, "Gagal"))
+                width_results.append((width, None, None, "Gagal"))
                 continue
             placed, used_height, not_placed = result
             if not_placed > 0:
-                width_results.append((width, used_height, f"{not_placed} item tidak muat"))
-                continue
-
-            img, _, true_used_area, _, true_eff, rot_count = render_layout(
-                placed, used_height, original_dims, width, margin
-            )
+                # Coba multi-roll untuk quick mode juga
+                rolls, not_placed = pack_multi_roll(
+                    rects, width, max_height, bool(allow_rotation)
+                )
+                if not rolls:
+                    width_results.append((width, None, None, "Gagal"))
+                    continue
+                img, total_true, total_roll, total_rot = render_multi_roll(
+                    rolls, original_dims, width, margin
+                )
+                waste = total_roll - total_true
+                num_rolls = len(rolls)
+            else:
+                rolls = [(placed, used_height)]
+                img, total_true, total_roll, total_rot = render_multi_roll(
+                    rolls, original_dims, width, margin
+                )
+                waste = total_roll - total_true
+                num_rolls = 1
 
             stats_lines = [
-                f"🏆 Mode                       : CEPAT (1 kombinasi)",
+                f"🏆 Mode                       : CEPAT",
                 f"📏 Lebar roll                 : {width:g} cm",
-                f"✅ Item berhasil ditempatkan  : {len(placed)} / {total_rects}",
-                f"🔄 Item yang diputar 90°      : {rot_count}",
-                f"📏 Ukuran layout terpakai     : {width:g} x {used_height:.1f}",
-                f"📐 Total luas item (asli)     : {true_used_area:.1f} unit²",
-                f"📊 Efisiensi bahan (asli)     : {true_eff:.1f}%",
+                f"📦 Jumlah roll                : {num_rolls}",
+                f"📏 Total panjang              : {sum(h for _, h in rolls):.1f} cm",
+                f"♻️ Total waste                : {waste:.1f} cm²",
+                f"📊 Persentase waste           : {(waste/total_roll*100) if total_roll else 0:.2f}%",
             ]
 
-            key = (used_height, -true_eff)
+            key = (waste, num_rolls, sum(h for _, h in rolls))
             if best_key is None or key < best_key:
                 best_key = key
                 best_overall = (img, "\n".join(stats_lines))
                 best_width = width
 
-            width_results.append((width, used_height, f"{true_eff:.1f}%"))
+            width_results.append((width, waste, num_rolls, f"{(waste/total_roll*100) if total_roll else 0:.1f}%"))
 
         else:
-            # Mode optimasi: jalankan pencarian mendalam per lebar
-            img, stats, used_height, true_eff = search_single_width(
+            img, stats, waste, num_rolls = search_single_width(
                 rects, original_dims, total_rects, max_height,
                 width, margin, bool(allow_rotation),
                 search_mode, px_per_unit=4.0
             )
 
             if img is None:
-                width_results.append((width, None, "Gagal"))
+                width_results.append((width, None, None, "Gagal"))
                 continue
 
-            key = (used_height, -true_eff)
+            key = (waste if waste is not None else float('inf'),
+                   num_rolls if num_rolls is not None else 99,
+                   0)
             if best_key is None or key < best_key:
                 best_key = key
                 best_overall = (img, stats)
                 best_width = width
 
-            width_results.append((width, used_height, f"{true_eff:.1f}%"))
+            width_results.append((width, waste, num_rolls, f"{(waste/(waste+sum(original_dims[r][0]*original_dims[r][1] for r in original_dims))*100):.1f}%" if waste else "0%"))
 
     if best_overall is None:
         return None, (
             "⚠️ Tidak ada satupun lebar roll yang bisa menampung semua banner. "
-            "Coba tambahkan lebar roll yang lebih besar atau kurangi ukuran banner."
+            "Coba tambahkan lebar roll yang lebih besar."
         )
 
-    # Tambahkan ringkasan perbandingan lebar roll ke stats
     img, stats = best_overall
-    comparison = ["\n" + "─" * 40, "📋 PERBANDINGAN SEMUA LEBAR ROLL:"]
-    for w, h, note in width_results:
-        if h is None:
+
+    # Perbandingan semua lebar
+    comparison = ["\n" + "─" * 50, "📋 PERBANDINGAN SEMUA LEBAR ROLL (diurut waste terendah):"]
+    sorted_results = sorted(width_results, key=lambda x: (x[1] if x[1] is not None else float('inf'), x[2] if x[2] is not None else 99))
+
+    for w, waste, rolls, note in sorted_results:
+        if waste is None:
             comparison.append(f"   ❌ {w:g} cm → {note}")
         else:
-            mark = " ⭐" if w == best_width else ""
-            comparison.append(f"   {'✅' if w == best_width else '  '} {w:g} cm → tinggi {h:.1f}, efisiensi {note}{mark}")
+            mark = " ⭐ PALING HEMAT" if w == best_width else ""
+            comparison.append(f"   {'✅' if w == best_width else '  '} {w:g} cm → {rolls} roll, waste {waste:.1f} cm² ({note}){mark}")
 
     final_stats = stats + "\n" + "\n".join(comparison)
 
@@ -608,13 +688,14 @@ def process(roll_widths_text, margin, allow_rotation, search_mode, table_data):
 # 8. UI GRADIO
 # --------------------------------------------------------------------------
 
-with gr.Blocks(title="Nesting Otomatis Banner - Percetakan") as demo:
-    gr.Markdown("# 🖨️ Nesting Otomatis & Visualisasi Layout Cetak Banner")
+with gr.Blocks(title="Nesting Otomatis Banner - Minim Waste") as demo:
+    gr.Markdown("# 🖨️ Nesting Otomatis — Fokus Minimasi Waste")
     gr.Markdown(
-        "Masukkan daftar banner dan **beberapa ukuran lebar roll** (pisah dengan koma). "
-        "Aplikasi akan mencoba semua kombinasi algoritma pada **setiap lebar roll**, "
-        "lalu memilih yang paling hemat bahan. Area **pastel** = margin, "
-        "area **pekat** = ukuran banner asli."
+        "Masukkan daftar banner dan **beberapa ukuran lebar roll** (pisah koma). "
+        "Aplikasi akan mencoba semua kombinasi pada **setiap lebar roll**, "
+        "lalu memilih yang **TOTAL WASTE PALING SEDIKIT**. "
+        "Jika 1 roll tidak cukup, otomatis dibuat **roll kedua, ketiga**, dst. "
+        "Area **pastel** = margin, **pekat** = banner, **grid abu** = waste/kosong."
     )
 
     with gr.Row():
@@ -650,11 +731,11 @@ with gr.Blocks(title="Nesting Otomatis Banner - Percetakan") as demo:
                     ["Banner C", 50, 50, 4],
                 ],
             )
-            btn = gr.Button("🔄 Proses Nesting", variant="primary")
+            btn = gr.Button("🔄 Proses Nesting — Minim Waste", variant="primary")
 
         with gr.Column(scale=2):
             output_img = gr.Image(label="Pratinjau Layout Cetakan", type="pil")
-            output_stats = gr.Textbox(label="Statistik Hasil Nesting", lines=12)
+            output_stats = gr.Textbox(label="Statistik Hasil Nesting", lines=14)
 
     btn.click(
         fn=process,