""" Nesting Otomatis Banner v2 — Super Optimized (Fixed) ===================================================== Perbaikan: original_dims dipass ke pack_multi_width_multi_roll """ import math import os import random import concurrent.futures import gradio as gr import pandas as pd from PIL import Image, ImageDraw, ImageFont from rectpack import newPacker from rectpack import ( SORT_AREA, SORT_PERI, SORT_DIFF, SORT_SSIDE, SORT_LSIDE, SORT_RATIO, SORT_NONE ) from rectpack.maxrects import MaxRectsBl, MaxRectsBssf, MaxRectsBaf, MaxRectsBlsf from rectpack.skyline import ( SkylineBl, SkylineBlWm, SkylineMwf, SkylineMwfl, SkylineMwfWm, SkylineMwflWm ) from rectpack.guillotine import ( GuillotineBssfSas, GuillotineBssfLas, GuillotineBssfSlas, GuillotineBssfLlas, GuillotineBssfMaxas, GuillotineBssfMinas, GuillotineBafSas, GuillotineBafLas, GuillotineBafSlas, GuillotineBafLlas, GuillotineBafMaxas, GuillotineBafMinas, GuillotineBlsfSas, GuillotineBlsfLas, GuillotineBlsfSlas, GuillotineBlsfLlas, GuillotineBlsfMaxas, GuillotineBlsfMinas, ) # -------------------------------------------------------------------------- # 1. FUNGSI BANTU # -------------------------------------------------------------------------- def generate_color(seed_text: str): random.seed(seed_text) return tuple(random.randint(90, 220) for _ in range(3)) def load_font(size: int = 14): candidates = [ "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", ] for path in candidates: try: return ImageFont.truetype(path, size) except Exception: continue return ImageFont.load_default() def lighten_color(c, factor=0.55): return tuple(min(255, int(v + (255 - v) * factor)) for v in c) def get_sort_name(sort_algo): mapping = { 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)) def add_banner_to_list(label, width, height, item_margin, current_data): if not label or not str(label).strip(): label = f"Banner" try: w = float(width) h = float(height) m = float(item_margin) if item_margin is not None else 0.0 if m < 0: m = 0.0 except (TypeError, ValueError): return current_data # Abaikan jika nilai tidak valid new_row = [str(label).strip(), w, h, m] # Tangkap apakah current_data berupa DataFrame pandas atau List of Lists if isinstance(current_data, pd.DataFrame): new_row_df = pd.DataFrame([new_row], columns=current_data.columns) return pd.concat([current_data, new_row_df], ignore_index=True) elif isinstance(current_data, list): return current_data + [new_row] else: return [new_row] # -------------------------------------------------------------------------- # 2. PERSIAPAN DATA # -------------------------------------------------------------------------- def prepare_rects(df: pd.DataFrame, allow_rotation: bool = True): """ Setiap baris di tabel = satu banner (tanpa Qty). Margin/jarak antar item kini dibaca PER BARIS dari kolom "Margin", sehingga tiap desain banner bisa punya jarak potong yang berbeda-beda. Untuk mencetak banner yang sama lebih dari satu kali, tambahkan baris terpisah lewat form input (bisa dengan label & margin yang sama). """ rects, original_dims, item_margins = [], {}, {} for idx, row in df.iterrows(): label = str(row["Label"]).strip() or f"Item{idx}" try: w, h = float(row["Width"]), float(row["Height"]) m = float(row["Margin"]) if pd.notna(row.get("Margin")) else 0.0 except (TypeError, ValueError): continue if w <= 0 or h <= 0: continue if m < 0: m = 0.0 rid = f"{label}#{idx}" rects.append((w + m * 2, h + m * 2, rid)) original_dims[rid] = (w, h) item_margins[rid] = m if not rects: return None, None, None, 0, 0 max_margin = max(item_margins.values()) if item_margins else 0.0 # PERBAIKAN BUG: dulu tinggi bin (max_height) dihitung hanya dari sisi # "Height" tanpa rotasi (sum(h ...)). Kalau rotasi diizinkan, item dengan # rasio aspek ekstrem (mis. 605 x 60 cm) bisa ditempatkan berdiri, dan # footprint tingginya justru jadi 610 cm — jauh lebih besar dari 65 cm # yang tadinya diasumsikan. Bin yang terlalu pendek membuat rectpack # gagal menempatkan item ini walau seharusnya muat. Sekarang tiap item # disumbang oleh SISI TERPANJANG-nya (w atau h, mana yang lebih besar) # saat rotasi diizinkan, sebagai estimasi konservatif yang aman untuk # segala kemungkinan orientasi hasil packing. if allow_rotation: per_item_h = [max(w, h) for w, h, _ in rects] else: per_item_h = [h for _, h, _ in rects] max_height = sum(per_item_h) + max_margin * (len(rects) + 2) + 50 return rects, original_dims, item_margins, len(rects), max_height # -------------------------------------------------------------------------- # 3. CORE: PACKING ENGINE # -------------------------------------------------------------------------- def pack_multi_roll(rects, roll_width, max_height, allow_rotation, pack_algo=None, sort_algo=None, reverse=False): remaining = list(reversed(rects)) if reverse else rects[:] rolls, safety = [], 50 for _ in range(safety): if not remaining: break kwargs = {"rotation": allow_rotation} if pack_algo: kwargs["pack_algo"] = pack_algo if sort_algo: kwargs["sort_algo"] = sort_algo 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() if len(packer) == 0 or len(packer[0]) == 0: return rolls, len(remaining) placed = packer[0] used_height = max(r.y + r.height for r in placed) rolls.append((placed, used_height, roll_width)) placed_ids = {r.rid for r in placed} remaining = [r for r in remaining if r[2] not in placed_ids] return rolls, len(remaining) # -------------------------------------------------------------------------- # 4. GUILLOTINE CUT VALIDATION # -------------------------------------------------------------------------- def is_guillotine_cuttable(rolls): violations = 0 for placed, used_height, roll_width in rolls: items = [] for r in placed: items.append({ 'x': r.x, 'y': r.y, 'w': r.width, 'h': r.height, 'rid': r.rid }) for a in items: has_free_top = a['y'] + a['h'] >= used_height - 0.01 has_free_bottom = a['y'] <= 0.01 has_free_left = a['x'] <= 0.01 has_free_right = a['x'] + a['w'] >= roll_width - 0.01 if has_free_top or has_free_bottom or has_free_left or has_free_right: continue can_slide_up = all( not (b['x'] < a['x'] + a['w'] and b['x'] + b['w'] > a['x'] and b['y'] > a['y'] + a['h']) for b in items if b['rid'] != a['rid'] ) if can_slide_up: continue can_slide_down = all( not (b['x'] < a['x'] + a['w'] and b['x'] + b['w'] > a['x'] and b['y'] + b['h'] < a['y']) for b in items if b['rid'] != a['rid'] ) if can_slide_down: continue can_slide_left = all( not (b['y'] < a['y'] + a['h'] and b['y'] + b['h'] > a['y'] and b['x'] + b['w'] < a['x']) for b in items if b['rid'] != a['rid'] ) if can_slide_left: continue can_slide_right = all( not (b['y'] < a['y'] + a['h'] and b['y'] + b['h'] > a['y'] and b['x'] > a['x'] + a['w']) for b in items if b['rid'] != a['rid'] ) if can_slide_right: continue violations += 1 return violations == 0, violations # -------------------------------------------------------------------------- # 5. VISUALISASI # -------------------------------------------------------------------------- def render_multi_roll(rolls, original_dims, item_margins, px_per_unit=4.0): if not rolls: return None, 0, 0, 0 max_roll_w = max(w for _, _, w in rolls) img_w = max(1, int(round(max_roll_w * px_per_unit))) gap = 40 total_h = sum(int(round(h * px_per_unit)) for _, h, _ in rolls) total_h += gap * (len(rolls) - 1) + 60 img = Image.new("RGB", (img_w, total_h), "white") draw = ImageDraw.Draw(img) font = load_font(14) font_small = load_font(11) font_title = load_font(16) y_offset, total_true, total_roll_area, total_rot = 0, 0, 0, 0 for roll_idx, (placed, used_height, roll_width) in enumerate(rolls): roll_h_px = int(round(used_height * px_per_unit)) 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 draw.rectangle([0, roll_y0, int(round(roll_width * px_per_unit)) - 1, roll_y1], outline="red", width=3) 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] item_margin = item_margins.get(r.rid, 0.0) is_rotated = round(r.width - item_margin * 2, 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 = item_margin * px_per_unit ix0, iy0 = x0 + m, y0 + m ix1, iy1 = x1 - m, y1 - m draw.rectangle([x0, y0, x1, y1], fill=outer_color, outline="black", width=2) if ix1 > ix0 and iy1 > iy0: draw.rectangle([ix0, iy0, ix1, iy1], fill=inner_color, outline="black", width=1) 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 += orig_w * orig_h if is_rotated: total_rot += 1 for x in range(0, int(round(roll_width * px_per_unit)), 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), (int(round(roll_width * px_per_unit)) - 1, y)], fill="#f5f5f5", width=1) total_roll_area += roll_width * used_height y_offset = roll_y1 + gap return img, total_true, total_roll_area, total_rot # -------------------------------------------------------------------------- # 5b. EKSPOR SVG (skala 1 unit SVG = 1 cm, untuk dibuka di CorelDraw/Illustrator) # -------------------------------------------------------------------------- def _xml_escape(text: str) -> str: return ( str(text) .replace("&", "&") .replace("<", "<") .replace(">", ">") .replace('"', """) ) def render_svg(rolls, original_dims, item_margins, roll_gap_cm=10.0, header_h_cm=2.0): """ Render layout nesting sebagai SVG vektor, 1 unit SVG = 1 cm. Tiap item digambar dengan DUA kotak: - Kotak LUAR (garis hitam) = area termasuk margin/jarak antar item = garis potong roll. - Kotak DALAM (garis biru putus-putus) = ukuran desain ASLI banner (tanpa margin). Ini adalah area yang harus diisi dengan desain asli saat file dibuka di CorelDraw, sehingga posisinya sudah pas dengan hasil nesting. Jika item diputar 90°, kotak dalam otomatis ikut ditukar (swap w/h) supaya tetap merepresentasikan orientasi tempel yang benar. Roll ditumpuk vertikal, sama seperti pratinjau PNG, supaya keduanya konsisten secara visual. """ if not rolls: return None max_roll_w = max(w for _, _, w in rolls) total_h = ( sum(h for _, h, _ in rolls) + header_h_cm * len(rolls) + roll_gap_cm * max(0, len(rolls) - 1) ) svg = [] svg.append( f'' ) svg.append( 'Layout nesting banner. 1 unit SVG = 1 cm. ' 'Kotak hitam = garis potong roll (termasuk margin). ' 'Kotak biru putus-putus = ukuran & posisi desain asli banner.' ) y_offset = 0.0 for roll_idx, (placed, used_height, roll_width) in enumerate(rolls): label_y = y_offset + header_h_cm - 0.4 svg.append( f'ROLL {roll_idx + 1} | {roll_width:g} x {used_height:.1f} cm' ) roll_y0 = y_offset + header_h_cm roll_y1 = roll_y0 + used_height svg.append( f'' ) for r in placed: base_label = r.rid.rsplit("#", 1)[0] orig_w, orig_h = original_dims[r.rid] item_margin = item_margins.get(r.rid, 0.0) is_rotated = round(r.width - item_margin * 2, 3) != round(orig_w, 3) # Kotak luar (footprint termasuk margin), y di-flip spy sama # orientasinya dgn pratinjau PNG (roll dibaca dari bawah ke atas). x0 = r.x y0 = roll_y0 + (used_height - r.y - r.height) w0 = r.width h0 = r.height svg.append( f'' ) # Kotak dalam = ukuran desain asli (swap kalau item diputar) inner_w, inner_h = (orig_h, orig_w) if is_rotated else (orig_w, orig_h) ix0 = x0 + item_margin iy0 = y0 + item_margin if inner_w > 0 and inner_h > 0: svg.append( f'' ) label_text = f"{base_label} ({orig_w:g}x{orig_h:g}{'R' if is_rotated else ''})" svg.append( f'{_xml_escape(label_text)}' ) y_offset = roll_y1 + roll_gap_cm svg.append('') return "\n".join(svg) def export_svg_file(rolls, original_dims, item_margins): """ Tulis hasil render_svg() ke file .svg di folder 'exports/' dan kembalikan path-nya, supaya bisa dipakai sebagai output gr.File (tombol download). Nama file memakai uuid4 (bukan timestamp detik) supaya aman dipakai banyak user sekaligus di HuggingFace Space publik tanpa risiko tabrakan/overwrite antar request yang terjadi di detik yang sama. """ if not rolls or not original_dims: return None svg_str = render_svg(rolls, original_dims, item_margins or {}) if not svg_str: return None import os import uuid out_dir = "exports" os.makedirs(out_dir, exist_ok=True) path = os.path.join(out_dir, f"nesting_layout_{uuid.uuid4().hex}.svg") with open(path, "w", encoding="utf-8") as f: f.write(svg_str) return path # -------------------------------------------------------------------------- # 6. STRATEGI PRE-SORT # -------------------------------------------------------------------------- def get_pre_sort_strategies(rects): strategies = [] def area(r): return r[0] * r[1] def max_side(r): return max(r[0], r[1]) def ratio(r): return max(r[0], r[1]) / max(min(r[0], r[1]), 0.001) base = [ ("default", rects[:]), ("area_desc", sorted(rects, key=area, reverse=True)), ("area_asc", sorted(rects, key=area)), ("width_desc", sorted(rects, key=lambda r: r[0], reverse=True)), ("width_asc", sorted(rects, key=lambda r: r[0])), ("height_desc", sorted(rects, key=lambda r: r[1], reverse=True)), ("height_asc", sorted(rects, key=lambda r: r[1])), ("longest_desc", sorted(rects, key=max_side, reverse=True)), ("ratio_desc", sorted(rects, key=ratio, reverse=True)), ("ratio_asc", sorted(rects, key=ratio)), ] strategies.extend(base) label_groups = {} for r in rects: label = r[2].rsplit("#", 1)[0] label_groups.setdefault(label, []).append(r) grouped = [] for label in sorted(label_groups.keys()): grouped.extend(label_groups[label]) strategies.append(("group_label", grouped)) by_area = sorted(rects, key=area, reverse=True) interleaved = [] i, j = 0, len(by_area) - 1 while i <= j: interleaved.append(by_area[i]) if i != j: interleaved.append(by_area[j]) i += 1 j -= 1 strategies.append(("interleave", interleaved)) return strategies # -------------------------------------------------------------------------- # 7. SIMULATED ANNEALING # -------------------------------------------------------------------------- def calculate_waste(rolls, original_dims): total_true = sum( original_dims[r.rid][0] * original_dims[r.rid][1] for placed, _, _ in rolls for r in placed ) total_roll = sum(w * h for _, h, w in rolls) return total_roll - total_true, (total_roll - total_true) / total_roll * 100 if total_roll else 100 def unified_key(waste, num_rolls, not_placed): """ Langkah 5: format key SATU-SATUNYA yang dipakai untuk membandingkan hasil single-width, multi-width, dan mode cepat, supaya perbandingan `key < best_key` semantiknya valid di seluruh jalur di process(). Item yang tidak muat diberi penalti besar (bukan diskualifikasi total), supaya solusi yang menempatkan semua item selalu diprioritaskan tapi solusi hampir-sempurna tetap bisa bersaing. """ return (waste + not_placed * 1e6, num_rolls, not_placed) def simulated_annealing(rects, roll_width, max_height, allow_rotation, pack_algo, sort_algo, original_dims, initial_temp=100, cooling=0.995, max_iter=3000, stall_limit=250, reheat_factor=0.6, seed=None): """ Perbaikan #4: menambah dua mekanisme supaya SA tidak terjebak di local optimum begitu saja: - REHEATING: kalau tidak ada perbaikan pada `best_waste` selama `stall_limit` iterasi berturut-turut, suhu dinaikkan kembali (temp = initial_temp * reheat_factor) supaya SA berani "melompat" keluar dari lembah lokal yang sedang dieksplorasi, alih-alih terus mendingin menuju nol dan berhenti bergerak. - SEED: parameter `seed` memungkinkan tiap chain SA (dijalankan paralel lewat _run_parallel) benar-benar independen satu sama lain (multi-start), bukan mengulang jalur pencarian yang persis sama. """ rng = random.Random(seed) if seed is not None else random current = rects[:] best = rects[:] best_result = None best_waste = float('inf') current_result, _ = pack_multi_roll( current, roll_width, max_height, allow_rotation, pack_algo, sort_algo, False ) if not current_result: return None, float('inf') current_waste, _ = calculate_waste(current_result, original_dims) temp = initial_temp stall = 0 for i in range(max_iter): neighbor = current[:] op = rng.choice(['swap', 'reverse', 'insert']) if op == 'swap' and len(neighbor) > 1: a, b = rng.sample(range(len(neighbor)), 2) neighbor[a], neighbor[b] = neighbor[b], neighbor[a] elif op == 'reverse' and len(neighbor) > 2: a, b = sorted(rng.sample(range(len(neighbor)), 2)) neighbor[a:b + 1] = list(reversed(neighbor[a:b + 1])) elif op == 'insert' and len(neighbor) > 1: a = rng.randint(0, len(neighbor) - 1) b = rng.randint(0, len(neighbor) - 1) item = neighbor.pop(a) neighbor.insert(b, item) rolls, _ = pack_multi_roll( neighbor, roll_width, max_height, allow_rotation, pack_algo, sort_algo, False ) if not rolls: stall += 1 else: waste, _ = calculate_waste(rolls, original_dims) if waste < best_waste - 1e-9: best_waste = waste best = neighbor[:] best_result = rolls stall = 0 else: stall += 1 if waste < current_waste or rng.random() < math.exp((current_waste - waste) / max(temp, 0.001)): current = neighbor[:] current_waste = waste if stall >= stall_limit: temp = initial_temp * reheat_factor stall = 0 else: temp *= cooling return best_result, best_waste # -------------------------------------------------------------------------- # 8. MULTI-WIDTH MULTI-ROLL (FIXED: tambah original_dims parameter) # -------------------------------------------------------------------------- def _try_pack_width(remaining, w, max_height, allow_rotation, pack_algo, sort_algo, original_dims): """ Helper: coba pack 'remaining' rects ke satu bin lebar w. Return None kalau gagal, atau (waste, placed, used_height, new_remaining) kalau berhasil. Dipakai bersama oleh pack_multi_width_multi_roll (greedy dan lookahead). """ kwargs = {"rotation": allow_rotation} if pack_algo: kwargs["pack_algo"] = pack_algo if sort_algo: kwargs["sort_algo"] = sort_algo packer = newPacker(**kwargs) for rect_w, rect_h, rid in remaining: packer.add_rect(rect_w, rect_h, rid=rid) packer.add_bin(w, max_height) packer.pack() if len(packer) == 0 or len(packer[0]) == 0: return None placed = packer[0] used_height = max(r.y + r.height for r in placed) placed_ids = {r.rid for r in placed} true_area = sum( (original_dims[rid][0] * original_dims[rid][1]) for _, _, rid in remaining if rid in placed_ids ) roll_area = w * used_height waste = roll_area - true_area new_remaining = [r for r in remaining if r[2] not in placed_ids] return waste, placed, used_height, new_remaining def pack_multi_width_multi_roll(rects, widths, max_height, allow_rotation, original_dims, # <-- FIX: tambah parameter ini pack_algo=None, sort_algo=None, reverse=False, lookahead=False, lookahead_k=3): """ Packing di mana TIAP ROLL boleh beda lebar. Langkah 4: bila lookahead=True, alih-alih langsung memilih lebar dengan waste terkecil untuk roll SAAT INI saja (murni greedy), fungsi ini mengambil top-`lookahead_k` kandidat lebar berdasar waste roll ini, lalu untuk tiap kandidat mengintip 1 roll ke depan (waste terbaik yang bisa dicapai pada sisa item) dan memilih kandidat dengan total waste gabungan (roll ini + estimasi roll berikutnya) terkecil. Ini membantu menghindari jebakan lokal di mana pilihan yang "tampak" optimal untuk roll saat ini justru membuat sisa item sulit dinestik secara efisien di roll berikutnya. """ remaining = list(reversed(rects)) if reverse else rects[:] all_rolls = [] safety = 50 for _ in range(safety): if not remaining: break candidates = [] for w in widths: res = _try_pack_width(remaining, w, max_height, allow_rotation, pack_algo, sort_algo, original_dims) if res is None: continue waste, placed, used_height, new_remaining = res candidates.append((waste, placed, used_height, w, new_remaining)) if not candidates: return all_rolls, len(remaining) candidates.sort(key=lambda c: c[0]) if not lookahead or len(candidates) <= 1: chosen = candidates[0] else: topk = candidates[:lookahead_k] chosen = None best_total = float('inf') for waste, placed, used_height, w, new_remaining in topk: if new_remaining: # Intip 1 langkah ke depan: waste terbaik di antara semua # lebar untuk sisa item setelah kandidat ini dipilih. next_best = float('inf') for w2 in widths: res2 = _try_pack_width(new_remaining, w2, max_height, allow_rotation, pack_algo, sort_algo, original_dims) if res2 is not None and res2[0] < next_best: next_best = res2[0] total = waste + (next_best if next_best != float('inf') else 0) else: total = waste if total < best_total: best_total = total chosen = (waste, placed, used_height, w, new_remaining) _, placed, used_height, w, new_remaining = chosen all_rolls.append((placed, used_height, w)) remaining = new_remaining return all_rolls, len(remaining) # -------------------------------------------------------------------------- # 8b. SIMULATED ANNEALING UNTUK MULTI-WIDTH MULTI-ROLL (Langkah 2) # -------------------------------------------------------------------------- def simulated_annealing_multi_width(rects, widths, max_height, allow_rotation, pack_algo, sort_algo, original_dims, initial_temp=100, cooling=0.995, max_iter=1500, stall_limit=200, reheat_factor=0.6, seed=None): """ Versi SA dari simulated_annealing(), tapi memakai pack_multi_width_multi_roll sebagai fungsi evaluasi sehingga tiap roll boleh punya lebar berbeda. Key evaluasi memakai (waste, not_placed) supaya solusi yang menempatkan semua item tetap diprioritaskan, tapi solusi dengan sedikit item tidak muat tidak langsung dibuang (lihat _mw_score). Perbaikan #4: reheating (keluar dari local optimum saat stagnan) dan dukungan `seed` untuk multi-start yang benar-benar independen. """ def _mw_score(rolls, not_placed): waste, _ = calculate_waste(rolls, original_dims) # Penalti besar per item tidak muat, tapi tidak diskualifikasi total return waste + not_placed * 1e6, waste rng = random.Random(seed) if seed is not None else random current = rects[:] best = rects[:] best_result = None best_not_placed = None best_waste = float('inf') best_score = float('inf') current_result, current_not_placed = pack_multi_width_multi_roll( current, widths, max_height, allow_rotation, original_dims, pack_algo, sort_algo, False ) if not current_result: return None, float('inf'), None current_score, current_waste = _mw_score(current_result, current_not_placed) best_result, best_not_placed, best_waste, best_score = ( current_result, current_not_placed, current_waste, current_score ) temp = initial_temp stall = 0 for _ in range(max_iter): neighbor = current[:] op = rng.choice(['swap', 'reverse', 'insert']) if op == 'swap' and len(neighbor) > 1: a, b = rng.sample(range(len(neighbor)), 2) neighbor[a], neighbor[b] = neighbor[b], neighbor[a] elif op == 'reverse' and len(neighbor) > 2: a, b = sorted(rng.sample(range(len(neighbor)), 2)) neighbor[a:b + 1] = list(reversed(neighbor[a:b + 1])) elif op == 'insert' and len(neighbor) > 1: a = rng.randint(0, len(neighbor) - 1) b = rng.randint(0, len(neighbor) - 1) item = neighbor.pop(a) neighbor.insert(b, item) rolls, not_placed = pack_multi_width_multi_roll( neighbor, widths, max_height, allow_rotation, original_dims, pack_algo, sort_algo, False ) if not rolls: stall += 1 else: score, waste = _mw_score(rolls, not_placed) if score < best_score - 1e-9: best_score = score best_waste = waste best_not_placed = not_placed best = neighbor[:] best_result = rolls stall = 0 else: stall += 1 if score < current_score or rng.random() < math.exp((current_score - score) / max(temp, 0.001)): current = neighbor[:] current_score = score if stall >= stall_limit: temp = initial_temp * reheat_factor stall = 0 else: temp *= cooling return best_result, best_waste, best_not_placed # -------------------------------------------------------------------------- # 8c. PARALLEL EXECUTION HELPERS (Perbaikan #3) # -------------------------------------------------------------------------- # Semua worker di bawah ini WAJIB berupa fungsi top-level (bukan closure/ # nested function) supaya bisa di-pickle dan dikirim ke proses worker oleh # ProcessPoolExecutor. Tiap worker menerima satu tuple argumen (payload) # dan mengembalikan hasil yang ringkas (bukan object rectpack mentah bila # tidak perlu), supaya biaya serialisasi antar-proses tetap murah. # Jumlah worker proses dibatasi supaya tidak membebani host (mis. HF Spaces # free tier biasanya cuma 2 vCPU). Bisa di-override lewat env var kalau perlu. _MAX_WORKERS = max(1, min(int(os.environ.get("NESTING_MAX_WORKERS", os.cpu_count() or 2)), 8)) # Berapa banyak "chain" independen yang dijalankan untuk tiap konfigurasi SA # (multi-start). Tiap chain pakai seed acak berbeda supaya benar-benar # menjelajah ruang solusi yang berbeda, bukan cuma mengulang jalur yang sama. _SA_STARTS = 3 def _run_parallel(worker_fn, tasks): """ Jalankan `worker_fn` untuk tiap item di `tasks` secara paralel memakai proses terpisah (menghindari GIL, supaya CPU-bound packing benar-benar berjalan bersamaan). Kalau environment tidak mengizinkan pembuatan proses baru (mis. container sandboxed), otomatis fallback ke eksekusi sekuensial biasa, supaya fitur ini tidak pernah membuat aplikasi crash. """ if not tasks: return [] if len(tasks) == 1 or _MAX_WORKERS <= 1: return [worker_fn(t) for t in tasks] try: max_workers = min(len(tasks), _MAX_WORKERS) with concurrent.futures.ProcessPoolExecutor(max_workers=max_workers) as executor: return list(executor.map(worker_fn, tasks)) except Exception: # Fallback aman: platform tidak mendukung multiprocessing (mis. # beberapa sandbox), atau objek gagal di-pickle. Jangan sampai # optimasi paralel mematikan fitur inti. return [worker_fn(t) for t in tasks] def _grid_worker(payload): """Worker untuk satu kombinasi (pack_algo, sort_algo, reverse) — single width.""" (rects, roll_width, max_height, allow_rotation, pack_algo, sort_algo, reverse, original_dims, label) = payload try: rolls, not_placed = pack_multi_roll( rects, roll_width, max_height, allow_rotation, pack_algo, sort_algo, reverse ) except Exception: return (label, None, None, None) if not rolls: return (label, None, None, None) waste, _ = calculate_waste(rolls, original_dims) return (label, rolls, not_placed, waste) def _sa_worker(payload): """Worker untuk satu chain Simulated Annealing (single width, multi-start).""" (rects, roll_width, max_height, allow_rotation, pack_algo, sort_algo, original_dims, initial_temp, cooling, max_iter, stall_limit, reheat_factor, seed, label) = payload rolls, waste = simulated_annealing( rects, roll_width, max_height, allow_rotation, pack_algo, sort_algo, original_dims, initial_temp=initial_temp, cooling=cooling, max_iter=max_iter, stall_limit=stall_limit, reheat_factor=reheat_factor, seed=seed, ) return (label, rolls, waste) def _swap_worker(payload): """Worker untuk satu percobaan local-swap (Fase 4).""" (order, roll_width, max_height, allow_rotation, original_dims, label) = payload rolls, not_placed = pack_multi_roll(order, roll_width, max_height, allow_rotation, None, None, False) if not rolls: return (label, None, None, None) waste, _ = calculate_waste(rolls, original_dims) return (label, rolls, not_placed, waste) def _mw_grid_worker(payload): """Worker untuk satu kombinasi (pack_algo, sort_algo, reverse) — multi-width.""" (rects, widths, max_height, allow_rotation, original_dims, pack_algo, sort_algo, reverse, label) = payload rolls, not_placed = pack_multi_width_multi_roll( rects, widths, max_height, allow_rotation, original_dims, pack_algo, sort_algo, reverse ) return (label, rolls, not_placed) def _mw_lookahead_worker(payload): """Worker untuk satu konfigurasi lookahead — multi-width.""" (rects, widths, max_height, allow_rotation, original_dims, pack_algo, sort_algo, label) = payload rolls, not_placed = pack_multi_width_multi_roll( rects, widths, max_height, allow_rotation, original_dims, pack_algo, sort_algo, False, lookahead=True, lookahead_k=3 ) return (label, rolls, not_placed) def _sa_mw_worker(payload): """Worker untuk satu chain Simulated Annealing multi-width (multi-start).""" (rects, widths, max_height, allow_rotation, pack_algo, sort_algo, original_dims, initial_temp, cooling, max_iter, stall_limit, reheat_factor, seed, label) = payload rolls, waste, not_placed = simulated_annealing_multi_width( rects, widths, max_height, allow_rotation, pack_algo, sort_algo, original_dims, initial_temp=initial_temp, cooling=cooling, max_iter=max_iter, stall_limit=stall_limit, reheat_factor=reheat_factor, seed=seed, ) return (label, rolls, waste, not_placed) # -------------------------------------------------------------------------- # 9. PENCARIAN UNTUK SATU LEBAR ROLL # -------------------------------------------------------------------------- def search_single_width(rects, original_dims, total_rects, max_height, roll_width, item_margins, allow_rotation, search_mode, target_waste_pct, px_per_unit): best_result = None best_key = None best_config = None best_rolls = None tried, failed = 0, 0 hit_target = False def consider(rolls, not_placed, config_name): """ Perbaikan #1: dulu fungsi ini (`evaluate`) memakai key (waste, num_rolls, not_placed) TANPA penalti — beda dengan `unified_key` yang dipakai process() untuk membandingkan lintas lebar roll. Akibatnya "terbaik per lebar" bisa tidak konsisten dengan perbandingan level atas. Sekarang keduanya memakai `unified_key` yang sama persis. """ nonlocal best_result, best_key, best_config, best_rolls, hit_target if not rolls: return waste, waste_pct = calculate_waste(rolls, original_dims) num_rolls = len(rolls) key = unified_key(waste, num_rolls, not_placed) if best_key is None or key < best_key: best_key = key best_result = (rolls, not_placed) best_config = config_name best_rolls = rolls if waste_pct <= target_waste_pct and not_placed == 0: hit_target = True def should_stop(): return hit_target def consider_batch(results): """Reduce hasil satu batch paralel: catat tried/failed lalu consider().""" nonlocal tried, failed for label, rolls, not_placed, waste in results: tried += 1 if not rolls: failed += 1 continue consider(rolls, not_placed, label) ALL_PACK = [ None, MaxRectsBssf, MaxRectsBaf, MaxRectsBl, MaxRectsBlsf, SkylineBl, SkylineBlWm, SkylineMwf, SkylineMwfl, SkylineMwfWm, SkylineMwflWm, GuillotineBssfSas, GuillotineBssfLas, GuillotineBssfMaxas, GuillotineBafSas, GuillotineBafLas, GuillotineBafMaxas, GuillotineBlsfSas, GuillotineBlsfLas, ] ALL_SORT = [None, SORT_AREA, SORT_PERI, SORT_LSIDE, SORT_RATIO, SORT_DIFF] # PHASE 1: GRID SEARCH (Perbaikan #3: satu batch besar dievaluasi paralel # lintas proses, bukan sekuensial satu-per-satu — jauh lebih cepat untuk # ratusan kombinasi algo x sort x reverse pada mode deep/pro/exhaustive) if search_mode in ("standard", "deep", "pro", "exhaustive"): if search_mode == "standard": pack_algos = [None, MaxRectsBssf, MaxRectsBaf, MaxRectsBlsf, SkylineMwfl, GuillotineBssfSas, GuillotineBafSas] sort_algos = [None, SORT_AREA, SORT_LSIDE] else: pack_algos, sort_algos = ALL_PACK, ALL_SORT tasks = [] for pack_algo in pack_algos: for sort_algo in sort_algos: for reverse in [False, True]: algo_name = pack_algo.__name__ if pack_algo else "Default" label = f"[Grid] {algo_name} + {get_sort_name(sort_algo)}{' rev' if reverse else ''}" tasks.append((rects, roll_width, max_height, allow_rotation, pack_algo, sort_algo, reverse, original_dims, label)) consider_batch(_run_parallel(_grid_worker, tasks)) # PHASE 2: PRE-SORT (dijalankan hanya kalau Fase 1 belum capai target) if search_mode in ("pro", "exhaustive") and not should_stop(): tasks = [] for sort_name, sorted_rects in get_pre_sort_strategies(rects): for pack_algo in [None, MaxRectsBssf, GuillotineBssfSas]: for reverse in [False, True]: algo_name = pack_algo.__name__ if pack_algo else "Default" label = f"[PreSort:{sort_name}] {algo_name}{' rev' if reverse else ''}" tasks.append((sorted_rects, roll_width, max_height, allow_rotation, pack_algo, SORT_NONE, reverse, original_dims, label)) consider_batch(_run_parallel(_grid_worker, tasks)) # PHASE 3: SIMULATED ANNEALING (Perbaikan #4: multi-start — tiap # kombinasi (pack_algo, sort_algo) dijalankan sebagai beberapa chain # independen dengan seed berbeda dan reheating aktif, semua dieksekusi # paralel, lalu diambil chain dengan waste terkecil.) if search_mode in ("pro", "exhaustive") and not should_stop(): sa_configs = [ (None, None), (MaxRectsBssf, SORT_AREA), (GuillotineBssfSas, SORT_AREA) ] max_iter = 5000 if search_mode == "exhaustive" else 2000 tasks = [] for pack_algo, sort_algo in sa_configs: algo_name = pack_algo.__name__ if pack_algo else "Default" for start in range(_SA_STARTS): seed = random.randint(0, 2**31 - 1) label = f"[SA] {algo_name} (start {start + 1}/{_SA_STARTS})" tasks.append((rects, roll_width, max_height, allow_rotation, pack_algo, sort_algo, original_dims, 100, 0.995, max_iter, 250, 0.6, seed, label)) results = _run_parallel(_sa_worker, tasks) for label, sa_rolls, sa_waste in results: tried += 1 if sa_rolls: consider(sa_rolls, 0, f"{label} (waste {sa_waste:.1f})") else: failed += 1 # PHASE 4: LOCAL SWAP (dievaluasi sebagai satu batch paralel alih-alih # perbaikan sekuensial satu-satu; sedikit kehilangan sifat "progresif" # tapi jauh lebih banyak kandidat swap yang bisa dicoba dalam waktu sama) if search_mode == "exhaustive" and best_rolls and not should_stop(): 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) n_trials = min(500, n * n) if n > 1 else 0 tasks = [] seen_pairs = set() attempts = 0 while len(tasks) < n_trials and attempts < n_trials * 4: attempts += 1 i, j = random.randint(0, n - 1), random.randint(0, n - 1) if i == j or (i, j) in seen_pairs: continue seen_pairs.add((i, j)) swapped = best_order[:] swapped[i], swapped[j] = swapped[j], swapped[i] tasks.append((swapped, roll_width, max_height, allow_rotation, original_dims, f"[Swap:{i}-{j}]")) consider_batch(_run_parallel(_swap_worker, tasks)) if best_result is None: return None, f"⚠️ Lebar {roll_width:g} cm: tidak muat.", None, None, None, tried, False, None, None rolls, not_placed = best_result img, total_true, total_roll, total_rot = render_multi_roll( rolls, original_dims, item_margins, px_per_unit ) waste, waste_pct = calculate_waste(rolls, original_dims) num_rolls = len(rolls) is_guillotine, g_violations = is_guillotine_cuttable(rolls) target_status = "✅ TARGET TERCAPAI!" if waste_pct <= target_waste_pct else "❌ Target belum tercapai" stats = [ f"{'🎯' if waste_pct <= target_waste_pct else '⚠️'} {target_status}", f"🏆 Algoritma terpilih : {best_config}", f"🔍 Mode : {search_mode.upper()}", f"🔍 Iterasi dicoba : {tried} (gagal: {failed})", f"📏 Lebar roll : {roll_width:g} cm", f"📦 Jumlah roll : {num_rolls}", f"📏 Total panjang : {sum(h for _, h, _ in rolls):.1f} cm", f"✅ Item ditempatkan : {sum(len(p) for p, _, _ in rolls)} / {total_rects}", f"🔄 Diputar 90° : {total_rot}", f"📐 Luas item (asli) : {total_true:.1f} cm²", f"📐 Luas roll terpakai : {total_roll:.1f} cm²", f"♻️ TOTAL WASTE : {waste:.1f} cm²", f"📊 Persentase waste : {waste_pct:.2f}% (target: ≤{target_waste_pct}%)", f"🔪 Guillotine cuttable : {'✅ Ya' if is_guillotine else f'⚠️ Tidak ({g_violations} pelanggaran)'}", ] if not_placed > 0: stats.insert(7, f"⚠️ Item TIDAK muat : {not_placed}") return img, "\n".join(stats), waste, waste_pct, num_rolls, tried, hit_target, not_placed, rolls # -------------------------------------------------------------------------- # 10. FUNGSI UTAMA # -------------------------------------------------------------------------- def process(roll_widths_text, allow_rotation, search_mode, target_waste_pct, enable_multiwidth, table_data): if table_data is None or len(table_data) == 0: return None, "⚠️ Silakan isi tabel daftar banner terlebih dahulu.", None, None, None df = pd.DataFrame(table_data, columns=["Label", "Width", "Height", "Margin"]) df = df.dropna(subset=["Width", "Height"], how="any") df["Margin"] = pd.to_numeric(df["Margin"], errors="coerce").fillna(0.0) 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.", None, None, None if not widths: return None, "⚠️ Masukkan minimal satu lebar roll yang valid.", None, None, None try: target_waste_pct = float(target_waste_pct) if target_waste_pct < 0: target_waste_pct = 5.0 except (TypeError, ValueError): target_waste_pct = 5.0 rects, original_dims, item_margins, total_rects, max_height = prepare_rects(df, bool(allow_rotation)) if rects is None: return None, "⚠️ Tidak ada data banner yang valid.", None, None, None # Auto-generate lebar tambahan # MURNI MENGGUNAKAN INPUT USER (TANPA AUTO-GENERATE) # Hitung lebar roll minimal yang dibutuhkan. # PERBAIKAN BUG: sebelumnya kode selalu memakai kolom "Width" (w) saja, # padahal kalau rotasi diizinkan, sisi manapun dari banner bisa menempel # ke arah lebar roll — jadi syarat muatnya adalah SISI TERPENDEK + margin, # bukan w + margin. Akibatnya banner yang sebenarnya muat (setelah # diputar) malah ditolak duluan di sini sebelum sempat dicoba di-nesting. if allow_rotation: min_banner_w = max( min(w, h) + item_margins[rid] * 2 for rid, (w, h) in original_dims.items() ) else: min_banner_w = max( w + item_margins[rid] * 2 for rid, (w, h) in original_dims.items() ) # Filter: Hanya ambil lebar roll dari input user yang >= lebar minimal yang dibutuhkan all_widths = sorted([w for w in widths if w >= min_banner_w]) # Validasi jika tidak ada lebar roll yang cocok if not all_widths: rotasi_note = ( "(sudah memperhitungkan rotasi — sisi terpendek banner + margin)" if allow_rotation else "(rotasi tidak diaktifkan, jadi memakai kolom Width apa adanya)" ) return None, ( f"⚠️ Tidak ada lebar roll yang valid untuk menampung banner.\n" f"Lebar roll minimal yang diinput harus ≥ {min_banner_w:.1f} cm " f"(Lebar banner terbesar yang dibutuhkan + margin item tersebut) {rotasi_note}." ), None, None, None best_overall = None best_key = None best_width = None width_results = [] global_tried = 0 # MULTI-WIDTH MULTI-ROLL if enable_multiwidth and search_mode in ("pro", "exhaustive"): tried = 0 mw_best_rolls = None mw_best_not_placed = None mw_best_config = None # key global untuk multi-width sendiri: (waste + penalti not_placed, num_rolls) # dibandingkan terpisah dari single-width supaya kombinasi terbaik multi-width # yang benar-benar ditemukan (bukan cuma kombinasi pertama yang all-placed) mw_best_key = None def _mw_key(rolls, not_placed): waste, _ = calculate_waste(rolls, original_dims) return unified_key(waste, len(rolls), not_placed) def _consider_mw(rolls, not_placed, config_name): nonlocal mw_best_rolls, mw_best_not_placed, mw_best_config, mw_best_key if not rolls: return key = _mw_key(rolls, not_placed) if mw_best_key is None or key < mw_best_key: mw_best_key = key mw_best_rolls = rolls mw_best_not_placed = not_placed mw_best_config = config_name # Perbaikan #3: Fase A/B/D dibangun sebagai daftar task lalu # dievaluasi paralel lintas proses lewat _run_parallel, alih-alih # loop sekuensial murni. Fase C (SA) memakai multi-start (Perbaikan # #4) yang juga paralel. # --- Fase A: grid search dasar (kombinasi algo x sort x reverse) --- tasks = [] for pack_algo in [None, MaxRectsBssf, GuillotineBssfSas]: for sort_algo in [None, SORT_AREA]: for reverse in [False, True]: algo_name = pack_algo.__name__ if pack_algo else "Default" label = f"[Grid] {algo_name}+{get_sort_name(sort_algo)}{' rev' if reverse else ''}" tasks.append((rects, all_widths, max_height, allow_rotation, original_dims, pack_algo, sort_algo, reverse, label)) for label, rolls, not_placed in _run_parallel(_mw_grid_worker, tasks): tried += 1 _consider_mw(rolls, not_placed, label) # --- Fase B (Langkah 1): pre-sort strategies, sama seperti single-width --- if search_mode in ("pro", "exhaustive"): tasks = [] for sort_name, sorted_rects in get_pre_sort_strategies(rects): for pack_algo in [None, MaxRectsBssf, GuillotineBssfSas]: for reverse in [False, True]: algo_name = pack_algo.__name__ if pack_algo else "Default" label = f"[MW-PreSort:{sort_name}] {algo_name}{' rev' if reverse else ''}" tasks.append((sorted_rects, all_widths, max_height, allow_rotation, original_dims, pack_algo, SORT_NONE, reverse, label)) for label, rolls, not_placed in _run_parallel(_mw_grid_worker, tasks): tried += 1 _consider_mw(rolls, not_placed, label) # --- Fase C (Langkah 2): Simulated Annealing versi multi-width, # sekarang dengan multi-start (Perbaikan #4) --- if search_mode in ("pro", "exhaustive"): sa_mw_configs = [ (None, None), (MaxRectsBssf, SORT_AREA), (GuillotineBssfSas, SORT_AREA) ] max_iter = 2500 if search_mode == "exhaustive" else 1200 tasks = [] for pack_algo, sort_algo in sa_mw_configs: algo_name = pack_algo.__name__ if pack_algo else "Default" for start in range(_SA_STARTS): seed = random.randint(0, 2**31 - 1) label = f"[MW-SA] {algo_name} (start {start + 1}/{_SA_STARTS})" tasks.append((rects, all_widths, max_height, allow_rotation, pack_algo, sort_algo, original_dims, 100, 0.995, max_iter, 200, 0.6, seed, label)) for label, sa_rolls, sa_waste, sa_not_placed in _run_parallel(_sa_mw_worker, tasks): tried += 1 if sa_rolls: _consider_mw(sa_rolls, sa_not_placed, f"{label} (waste {sa_waste:.1f})") # --- Fase D (Langkah 4): pilihan lebar dgn lookahead 1-langkah --- # Dibatasi ke beberapa config saja karena tiap panggilan lebih mahal # (evaluasi top-k kandidat x semua lebar untuk mengintip roll berikutnya). if search_mode in ("pro", "exhaustive"): lookahead_configs = [(None, None), (MaxRectsBssf, SORT_AREA)] tasks = [] for pack_algo, sort_algo in lookahead_configs: for sort_name, sorted_rects in [("default", rects), ("area_desc", sorted(rects, key=lambda r: r[0] * r[1], reverse=True))]: algo_name = pack_algo.__name__ if pack_algo else "Default" label = f"[MW-Lookahead:{sort_name}] {algo_name}" tasks.append((sorted_rects, all_widths, max_height, allow_rotation, original_dims, pack_algo, sort_algo, label)) for label, rolls, not_placed in _run_parallel(_mw_lookahead_worker, tasks): tried += 1 _consider_mw(rolls, not_placed, label) # --- Bandingkan hasil terbaik multi-width dengan best_overall global --- if mw_best_rolls is not None: waste, waste_pct = calculate_waste(mw_best_rolls, original_dims) key = unified_key(waste, len(mw_best_rolls), mw_best_not_placed) if best_key is None or key < best_key: best_key = key img, total_true, total_roll, total_rot = render_multi_roll( mw_best_rolls, original_dims, item_margins ) is_g, g_v = is_guillotine_cuttable(mw_best_rolls) stats = [ "🎯 MULTI-WIDTH MULTI-ROLL (tiap roll beda lebar)", f"🏆 Algoritma terpilih : {mw_best_config}", f"🔍 Iterasi dicoba (multi-width): {tried}", f"📦 Jumlah roll : {len(mw_best_rolls)}", f"📏 Lebar per roll : {', '.join(f'{w:.0f}' for _, _, w in mw_best_rolls)} cm", f"📏 Total panjang : {sum(h for _, h, _ in mw_best_rolls):.1f} cm", f"✅ Item ditempatkan : {sum(len(p) for p, _, _ in mw_best_rolls)} / {total_rects}", f"♻️ TOTAL WASTE : {waste:.1f} cm²", f"📊 Persentase waste : {waste_pct:.2f}% (target: ≤{target_waste_pct}%)", f"🔪 Guillotine cuttable : {'✅ Ya' if is_g else f'⚠️ Tidak ({g_v} pelanggaran)'}", ] if mw_best_not_placed: stats.insert(7, f"⚠️ Item TIDAK muat : {mw_best_not_placed}") best_overall = (img, "\n".join(stats), waste, waste_pct, mw_best_rolls) best_width = "multi" # Langkah 6 (persiapan): masukkan hasil multi-width ke tabel perbandingan juga width_results.append(("multi", waste, waste_pct, len(mw_best_rolls), f"{waste_pct:.2f}%")) global_tried += tried # SINGLE-WIDTH per lebar for width in all_widths: if search_mode == "quick": result = pack_multi_roll(rects, width, max_height, bool(allow_rotation)) if not result or not result[0]: width_results.append((width, None, None, "Gagal")) continue rolls, not_placed = result img, total_true, total_roll, total_rot = render_multi_roll( rolls, original_dims, item_margins ) waste, waste_pct = calculate_waste(rolls, original_dims) num_rolls = len(rolls) stats = [ f"🏆 Mode : CEPAT", f"📏 Lebar roll : {width:g} cm", f"📦 Jumlah roll : {num_rolls}", f"♻️ Total waste : {waste:.1f} cm²", f"📊 Persentase waste : {waste_pct:.2f}%", ] key = unified_key(waste, num_rolls, not_placed) if best_key is None or key < best_key: best_key = key best_overall = (img, "\n".join(stats), waste, waste_pct, rolls) best_width = width width_results.append((width, waste, waste_pct, num_rolls, f"{waste_pct:.2f}%")) global_tried += 1 if waste_pct <= target_waste_pct: break else: img, stats, waste, waste_pct, num_rolls, tried, hit, sw_not_placed, sw_rolls = search_single_width( rects, original_dims, total_rects, max_height, width, item_margins, bool(allow_rotation), search_mode, target_waste_pct, 4.0 ) global_tried += tried if img is None: width_results.append((width, None, None, None, "Gagal")) continue key = unified_key( waste if waste is not None else float('inf'), num_rolls if num_rolls else 99, sw_not_placed if sw_not_placed is not None else 0, ) if best_key is None or key < best_key: best_key = key best_overall = (img, stats, waste, waste_pct, sw_rolls) best_width = width width_results.append((width, waste, waste_pct, num_rolls, f"{waste_pct:.2f}%")) if hit: break if best_overall is None: return None, "⚠️ Tidak ada satupun lebar roll yang bisa menampung semua banner.", None, None, None img, stats, best_waste, best_waste_pct, best_rolls_final = best_overall comparison = ["\n" + "─" * 55, "📋 PERBANDINGAN LEBAR ROLL (10 teratas):"] sorted_r = sorted([r for r in width_results if r[1] is not None], key=lambda x: (x[1], x[3])) for w, waste, wpct, num_rolls_disp, note in sorted_r[:10]: mark = " ⭐ PALING HEMAT" if w == best_width else "" target = " 🎯" if isinstance(wpct, (int, float)) and wpct <= target_waste_pct else "" w_label = "MULTI (beda lebar)" if w == "multi" else f"{w:g} cm" comparison.append( f" {'✅' if w == best_width else ' '} {w_label} → " f"{num_rolls_disp} roll, waste {waste:.1f} cm² ({note}){mark}{target}" ) final = stats + "\n" + "\n".join(comparison) final += f"\n{'─' * 55}\n🔍 Total iterasi keseluruhan: {global_tried} kombinasi" return img, final, best_rolls_final, original_dims, item_margins # -------------------------------------------------------------------------- # 11. UI GRADIO # -------------------------------------------------------------------------- with gr.Blocks(title="Nesting Otomatis Banner v2 — Super Optimized") as demo: gr.Markdown("# 🖨️ Nesting Otomatis v2 — Simulated Annealing + Multi-Width") gr.Markdown( "Upgrade: **Simulated Annealing**, **Multi-Width Multi-Roll**, " "dan **Guillotine Validation**. Berburu waste minimum dengan target." ) with gr.Row(): with gr.Column(scale=1): roll_widths = gr.Textbox( label="Daftar Lebar Roll (cm, pisah koma)", value="150, 200, 250, 300", placeholder="Contoh: 150, 200, 250, 300", ) gr.Markdown( "ℹ️ Jarak Antar Item / Margin kini diatur **per banner** lewat " "kolom **Margin** di form & tabel di bawah, bukan satu nilai global." ) allow_rotation = gr.Checkbox(label="Izinkan Rotasi Otomatis", value=True) target_waste = gr.Number( label="🎯 Target Waste Maksimum (%)", value=5.0, minimum=0.1, maximum=50.0, step=0.5, ) # 1. Multi-width aktif by default (True) enable_multiwidth = gr.Checkbox( label="🎨 Aktifkan Multi-Width Multi-Roll (tiap roll beda lebar)", value=True, ) # 2. Mode pencarian diatur ke "exhaustive" (Menyeluruh) by default search_mode = gr.Dropdown( label="Mode Pencarian", choices=[ ("⚡ Cepat", "quick"), ("🎯 Standar (~120)", "standard"), ("🔍 Dalaman (~464)", "deep"), ("🧠 Pro (~3.000+ + Simulated Annealing)", "pro"), ("💎 Menyeluruh (~8.000+ + SA + Swap)", "exhaustive"), ], value="exhaustive", ) gr.Markdown("### 📥 Form Input Banner Baru") with gr.Row(): input_label = gr.Textbox(label="Label Banner", value="") input_width = gr.Number(label="Lebar (cm)", value=100) with gr.Row(): input_height = gr.Number(label="Tinggi (cm)", value=60) input_margin = gr.Number( label="Margin (cm)", value=2.5, minimum=0 ) btn_add = gr.Button("➕ Tambah ke Daftar Banner", variant="secondary") gr.Markdown( "💡 Untuk mencetak banner yang sama lebih dari satu kali, tekan " "tombol tambah beberapa kali (atau tambahkan baris manual di tabel)." ) gr.Markdown("### 📋 Daftar Banner") # 3. Daftar banner default dikosongkan (value=[]) data_input = gr.Dataframe( headers=["Label", "Width", "Height", "Margin"], datatype=["str", "number", "number", "number"], row_count=(0, "dynamic"), value=[], ) # Event listener untuk tombol tambah banner berulang kali btn_add.click( fn=add_banner_to_list, inputs=[input_label, input_width, input_height, input_margin, data_input], outputs=[data_input] ) btn = gr.Button("🚀 PROSES SUPER OPTIMIZED", 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=16) gr.Markdown("### 📤 Ekspor Layout Terpilih") btn_export_svg = gr.Button("💾 Download Layout (SVG untuk CorelDraw)", variant="secondary") output_svg_file = gr.File(label="File SVG Hasil Nesting (1 unit = 1 cm)") # State tersembunyi: menyimpan data mentah hasil nesting terbaik supaya # bisa dipakai ulang oleh tombol export SVG tanpa proses ulang perhitungan. state_best_rolls = gr.State(None) state_original_dims = gr.State(None) state_item_margins = gr.State(None) btn.click( fn=process, inputs=[roll_widths, allow_rotation, search_mode, target_waste, enable_multiwidth, data_input], outputs=[output_img, output_stats, state_best_rolls, state_original_dims, state_item_margins], ) btn_export_svg.click( fn=export_svg_file, inputs=[state_best_rolls, state_original_dims, state_item_margins], outputs=[output_svg_file], ) if __name__ == "__main__": demo.launch()