2e23ad5d2f
- window_capture.py: enumerate top-level windows (pygetwindow) and capture a specific one via PrintWindow PW_RENDERFULLCONTENT (works on non-focused windows). Linux falls back to mss region grab. - recognizer.py: replace MAE matcher with NCC over numpy vectors. Each rotatable slab generates 4 templates (0/90/180/270). Adds 248 artifact templates and an empty-cell heuristic (low mean/std-dev). Cells below confidence floor are tagged "unknown" — likely merged "?" boxes. - gui.py: new ScreenshotFrame with [게임 창 선택] button → window picker dialog → bbox crop → recognize → editable preview grid with per-cell CellEditor that handles slab / artifact / merged(?) / empty. Merged cells let user pick which two slabs got combined + a level. - artifacts.py + bundled _artifacts.json (248 entries from WhiteDog1004/sephiria) for matching and rendering. - renderer.py: factored CDN fetch into _fetch_image; added fetch_artifact_image(). - requirements.txt: + numpy, pygetwindow (Win), pywin32 (Win). - docker-build-cmd.sh: upgrade PyInstaller to 5.x inside cdrx container so numpy DLL manifest reads work. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
882 lines
36 KiB
Python
882 lines
36 KiB
Python
"""Tkinter GUI for the Sephiria inventory optimizer.
|
||
|
||
Two input modes via Notebook:
|
||
- "게임창 캡처": list visible Windows top-level windows, pick the Sephiria
|
||
one, capture its full client area (PrintWindow, works even when not
|
||
focused), click two corners of the bag area, then run the recognizer
|
||
(NCC + 4 rotations + artifacts + empty/unknown). Mis-recognized cells
|
||
can be fixed by click. Unknown ("?") cells likely correspond to merged
|
||
slab boxes — clicking one opens a popup that lets the user describe
|
||
which two slabs got merged.
|
||
- "수동 선택": existing tier-grouped +/- input.
|
||
|
||
Both modes feed a basket → solver → renderer pipeline shown on the right.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import os
|
||
import sys
|
||
import threading
|
||
import tkinter as tk
|
||
from tkinter import filedialog, messagebox, ttk
|
||
from typing import Dict, List, Optional, Tuple
|
||
|
||
from PIL import Image, ImageTk
|
||
|
||
from .artifacts import ARTIFACTS, ARTIFACTS_BY_VALUE
|
||
from .recognizer import CellResult, recognize_image, warm_templates
|
||
from .renderer import fetch_artifact_image, fetch_slab_image, render_solution
|
||
from .slabs import (
|
||
GRID_COLS,
|
||
SLABS,
|
||
SLABS_BY_VALUE,
|
||
TIER_LABEL,
|
||
TIER_ORDER,
|
||
generate_grid_config,
|
||
)
|
||
from .solver import solve
|
||
|
||
|
||
# ---------- helpers ----------
|
||
|
||
def _slab_thumb(value: str, size: int = 48) -> Optional[ImageTk.PhotoImage]:
|
||
slab = SLABS_BY_VALUE.get(value)
|
||
if not slab:
|
||
return None
|
||
img = fetch_slab_image(slab.image)
|
||
if img is None:
|
||
return None
|
||
return ImageTk.PhotoImage(img.resize((size, size)))
|
||
|
||
|
||
def _artifact_thumb(value: str, size: int = 48) -> Optional[ImageTk.PhotoImage]:
|
||
a = ARTIFACTS_BY_VALUE.get(value)
|
||
if not a:
|
||
return None
|
||
img = fetch_artifact_image(a.image)
|
||
if img is None:
|
||
return None
|
||
return ImageTk.PhotoImage(img.resize((size, size)))
|
||
|
||
|
||
# ---------- window-picker dialog ----------
|
||
|
||
class WindowPicker(tk.Toplevel):
|
||
"""List visible windows; the chosen WindowInfo ends up on .selected."""
|
||
|
||
def __init__(self, parent: tk.Tk) -> None:
|
||
super().__init__(parent)
|
||
self.title("게임 창 선택")
|
||
self.transient(parent)
|
||
self.selected = None
|
||
|
||
from .window_capture import list_windows, find_sephiria
|
||
windows = list_windows()
|
||
|
||
wrap = ttk.Frame(self, padding=8)
|
||
wrap.pack(fill="both", expand=True)
|
||
|
||
if not windows:
|
||
ttk.Label(wrap, text=(
|
||
"현재 OS 에서 창 목록을 가져올 수 없습니다.\n"
|
||
"(Windows 전용 기능 - 리눅스/맥에서는 전체 화면 캡처를 쓰세요)"
|
||
), justify="left").pack(pady=8)
|
||
ttk.Button(wrap, text="닫기", command=self.destroy).pack()
|
||
self.grab_set()
|
||
return
|
||
|
||
ttk.Label(wrap, text="아래 목록에서 세피리아 게임 창을 더블클릭하세요:") \
|
||
.pack(anchor="w")
|
||
|
||
tree_frame = ttk.Frame(wrap)
|
||
tree_frame.pack(fill="both", expand=True, pady=6)
|
||
cols = ("title", "size")
|
||
self.tree = ttk.Treeview(tree_frame, columns=cols, show="headings", height=14)
|
||
self.tree.heading("title", text="창 이름")
|
||
self.tree.heading("size", text="크기")
|
||
self.tree.column("title", width=440)
|
||
self.tree.column("size", width=120, anchor="center")
|
||
sb = ttk.Scrollbar(tree_frame, orient="vertical", command=self.tree.yview)
|
||
self.tree.configure(yscrollcommand=sb.set)
|
||
self.tree.pack(side="left", fill="both", expand=True)
|
||
sb.pack(side="right", fill="y")
|
||
|
||
self._windows = windows
|
||
# auto-promote Sephiria-matching entries
|
||
auto = find_sephiria()
|
||
sel_idx = None
|
||
for i, w in enumerate(windows):
|
||
self.tree.insert(
|
||
"", "end", iid=str(i),
|
||
values=(w.title, f"{w.width}×{w.height}"),
|
||
)
|
||
if auto and w.handle == auto.handle:
|
||
sel_idx = i
|
||
if sel_idx is not None:
|
||
self.tree.selection_set(str(sel_idx))
|
||
self.tree.see(str(sel_idx))
|
||
|
||
self.tree.bind("<Double-Button-1>", lambda _e: self._confirm())
|
||
|
||
btns = ttk.Frame(wrap)
|
||
btns.pack(fill="x", pady=(6, 0))
|
||
ttk.Button(btns, text="선택", command=self._confirm).pack(side="left")
|
||
ttk.Button(btns, text="취소", command=self.destroy).pack(side="right")
|
||
|
||
self.grab_set()
|
||
self.focus_set()
|
||
|
||
def _confirm(self) -> None:
|
||
sel = self.tree.selection()
|
||
if not sel:
|
||
return
|
||
self.selected = self._windows[int(sel[0])]
|
||
self.destroy()
|
||
|
||
|
||
# ---------- crop dialog (two-click bbox) ----------
|
||
|
||
class CropDialog(tk.Toplevel):
|
||
MAX_DISPLAY = 1100
|
||
|
||
def __init__(self, parent: tk.Tk, img: Image.Image) -> None:
|
||
super().__init__(parent)
|
||
self.title("가방 영역 선택 — 좌상단과 우하단을 차례로 클릭")
|
||
self.transient(parent)
|
||
self.img_full = img
|
||
self.bbox: Optional[Tuple[int, int, int, int]] = None
|
||
self._clicks: List[Tuple[int, int]] = []
|
||
|
||
w, h = img.size
|
||
self.scale = min(1.0, self.MAX_DISPLAY / max(w, h))
|
||
disp = img.resize((int(w * self.scale), int(h * self.scale)))
|
||
self.tk_img = ImageTk.PhotoImage(disp)
|
||
|
||
ttk.Label(
|
||
self, justify="left",
|
||
text=(
|
||
"가방(인벤토리) 격자의 좌상단을 먼저 클릭하고, 우하단을 다시 클릭하세요.\n"
|
||
"그리드 안쪽 첫 칸의 좌상단 모서리와 마지막 칸의 우하단 모서리로 맞추는 게 정확합니다."
|
||
),
|
||
).pack(padx=8, pady=(8, 4))
|
||
|
||
self.canvas = tk.Canvas(
|
||
self, width=disp.size[0], height=disp.size[1], highlightthickness=0
|
||
)
|
||
self.canvas.pack(padx=8, pady=4)
|
||
self.canvas.create_image(0, 0, anchor="nw", image=self.tk_img)
|
||
self.canvas.bind("<Button-1>", self._click)
|
||
|
||
bar = ttk.Frame(self)
|
||
bar.pack(fill="x", padx=8, pady=(4, 8))
|
||
ttk.Button(bar, text="처음부터", command=self._reset).pack(side="left")
|
||
ttk.Button(bar, text="취소", command=self._cancel).pack(side="right")
|
||
|
||
self.protocol("WM_DELETE_WINDOW", self._cancel)
|
||
self.grab_set()
|
||
self.focus_set()
|
||
|
||
def _click(self, e: tk.Event) -> None:
|
||
self._clicks.append((e.x, e.y))
|
||
self.canvas.create_oval(
|
||
e.x - 5, e.y - 5, e.x + 5, e.y + 5, outline="#ff5050", width=2
|
||
)
|
||
if len(self._clicks) == 2:
|
||
(x1, y1), (x2, y2) = self._clicks
|
||
lx, ty = min(x1, x2), min(y1, y2)
|
||
rx, by = max(x1, x2), max(y1, y2)
|
||
self.canvas.create_rectangle(lx, ty, rx, by, outline="#50ff80", width=2)
|
||
inv = 1.0 / self.scale
|
||
self.bbox = (int(lx * inv), int(ty * inv), int(rx * inv), int(by * inv))
|
||
self.after(120, self.destroy)
|
||
|
||
def _reset(self) -> None:
|
||
self._clicks.clear()
|
||
self.canvas.delete("all")
|
||
self.canvas.create_image(0, 0, anchor="nw", image=self.tk_img)
|
||
|
||
def _cancel(self) -> None:
|
||
self.bbox = None
|
||
self.destroy()
|
||
|
||
|
||
# ---------- cell editor (slab / artifact / merged / empty) ----------
|
||
|
||
class CellEditor(tk.Toplevel):
|
||
"""Modal editor. Result on .result: dict {kind, value, rotation, merged}."""
|
||
|
||
def __init__(self, parent: tk.Tk, current: Optional[CellResult]) -> None:
|
||
super().__init__(parent)
|
||
self.title("셀 수정")
|
||
self.transient(parent)
|
||
self.result: Optional[dict] = None
|
||
cur_kind = current.kind if current else "empty"
|
||
cur_val = current.value if current else None
|
||
|
||
wrap = ttk.Frame(self, padding=8)
|
||
wrap.pack(fill="both", expand=True)
|
||
|
||
ttk.Label(wrap, text="이 셀의 종류:").pack(anchor="w")
|
||
self.kind_var = tk.StringVar(value=cur_kind if cur_kind in ("slab", "artifact", "empty", "merged") else "empty")
|
||
kind_row = ttk.Frame(wrap)
|
||
kind_row.pack(fill="x", pady=(0, 6))
|
||
for label, key in [("석판", "slab"), ("아티팩트", "artifact"),
|
||
("합쳐진(?)", "merged"), ("빈칸", "empty")]:
|
||
ttk.Radiobutton(kind_row, text=label, value=key,
|
||
variable=self.kind_var, command=self._render).pack(side="left", padx=2)
|
||
|
||
self.body = ttk.Frame(wrap)
|
||
self.body.pack(fill="both", expand=True)
|
||
self._slab_buttons: List[ttk.Button] = []
|
||
self._artifact_buttons: List[ttk.Button] = []
|
||
self._chosen_value: Optional[str] = cur_val
|
||
self._chosen_kind: str = self.kind_var.get()
|
||
# merged sub-state
|
||
self._merged_a = tk.StringVar(value="")
|
||
self._merged_b = tk.StringVar(value="")
|
||
self._merged_lvl = tk.IntVar(value=1)
|
||
|
||
self._render()
|
||
|
||
bar = ttk.Frame(self)
|
||
bar.pack(fill="x", padx=8, pady=(0, 8))
|
||
ttk.Button(bar, text="확인", command=self._ok).pack(side="left")
|
||
ttk.Button(bar, text="취소", command=self.destroy).pack(side="right")
|
||
|
||
self.grab_set()
|
||
self.focus_set()
|
||
|
||
def _render(self) -> None:
|
||
for c in self.body.winfo_children():
|
||
c.destroy()
|
||
k = self.kind_var.get()
|
||
if k == "slab":
|
||
self._build_slab_picker()
|
||
elif k == "artifact":
|
||
self._build_artifact_picker()
|
||
elif k == "merged":
|
||
self._build_merged_picker()
|
||
else:
|
||
ttk.Label(self.body, text="이 칸은 빈칸으로 처리됩니다.").pack(pady=20)
|
||
|
||
def _build_slab_picker(self) -> None:
|
||
sub = ttk.Frame(self.body)
|
||
sub.pack(fill="both", expand=True)
|
||
cnv = tk.Canvas(sub, height=320, highlightthickness=0)
|
||
sb = ttk.Scrollbar(sub, orient="vertical", command=cnv.yview)
|
||
inner = ttk.Frame(cnv)
|
||
inner.bind("<Configure>", lambda e: cnv.configure(scrollregion=cnv.bbox("all")))
|
||
cnv.create_window((0, 0), window=inner, anchor="nw")
|
||
cnv.configure(yscrollcommand=sb.set)
|
||
cnv.pack(side="left", fill="both", expand=True)
|
||
sb.pack(side="right", fill="y")
|
||
by_tier: Dict[str, List] = {}
|
||
for s in SLABS:
|
||
by_tier.setdefault(s.tier, []).append(s)
|
||
for tier in sorted(by_tier, key=lambda t: TIER_ORDER.get(t, 99)):
|
||
ttk.Label(inner, text=TIER_LABEL.get(tier, tier),
|
||
font=("TkDefaultFont", 10, "bold")).pack(anchor="w", pady=(8, 2))
|
||
grid = ttk.Frame(inner)
|
||
grid.pack(fill="x")
|
||
for i, s in enumerate(by_tier[tier]):
|
||
b = ttk.Button(grid, text=s.ko_label, width=8,
|
||
command=lambda v=s.value: self._pick_slab(v))
|
||
b.grid(row=i // 6, column=i % 6, padx=2, pady=2, sticky="w")
|
||
|
||
def _build_artifact_picker(self) -> None:
|
||
sub = ttk.Frame(self.body)
|
||
sub.pack(fill="both", expand=True)
|
||
ttk.Label(sub, text=(
|
||
f"아티팩트 {len(ARTIFACTS)}종. 한글명으로 검색:"
|
||
)).pack(anchor="w")
|
||
sv = tk.StringVar()
|
||
ttk.Entry(sub, textvariable=sv).pack(fill="x", pady=2)
|
||
list_frame = ttk.Frame(sub)
|
||
list_frame.pack(fill="both", expand=True)
|
||
lb = tk.Listbox(list_frame, height=14)
|
||
lb.pack(side="left", fill="both", expand=True)
|
||
sb = ttk.Scrollbar(list_frame, orient="vertical", command=lb.yview)
|
||
sb.pack(side="right", fill="y")
|
||
lb.configure(yscrollcommand=sb.set)
|
||
|
||
items = sorted(ARTIFACTS, key=lambda a: (TIER_ORDER.get(a.tier, 99), a.ko_label))
|
||
|
||
def refresh(*_a):
|
||
lb.delete(0, "end")
|
||
q = sv.get().strip()
|
||
for a in items:
|
||
if not q or q in a.ko_label or q in a.value:
|
||
lb.insert("end", f"[{TIER_LABEL.get(a.tier, a.tier)}] {a.ko_label}")
|
||
|
||
sv.trace_add("write", refresh)
|
||
refresh()
|
||
|
||
def on_pick(_e=None):
|
||
sel = lb.curselection()
|
||
if not sel:
|
||
return
|
||
label = lb.get(sel[0])
|
||
# match by Korean label
|
||
ko = label.split("] ", 1)[1] if "] " in label else label
|
||
for a in ARTIFACTS:
|
||
if a.ko_label == ko:
|
||
self._chosen_value = a.value
|
||
self._chosen_kind = "artifact"
|
||
return
|
||
lb.bind("<<ListboxSelect>>", on_pick)
|
||
|
||
def _build_merged_picker(self) -> None:
|
||
sub = ttk.Frame(self.body, padding=4)
|
||
sub.pack(fill="both", expand=True)
|
||
ttk.Label(sub, text=(
|
||
"합쳐진 박스(?)에 어떤 두 석판이 들어갔는지 고르고, 누적 레벨을 지정하세요.\n"
|
||
"선택한 정보로 결과 이미지에 합쳐진 형태가 표시됩니다."
|
||
), justify="left").pack(anchor="w", pady=(0, 6))
|
||
|
||
slab_values = [s.value for s in SLABS]
|
||
slab_labels = {s.value: f"{s.ko_label} ({s.value})" for s in SLABS}
|
||
|
||
def labelled(v: str) -> str:
|
||
return slab_labels.get(v, v)
|
||
|
||
rowA = ttk.Frame(sub); rowA.pack(fill="x", pady=2)
|
||
ttk.Label(rowA, text="첫 번째 석판:", width=14).pack(side="left")
|
||
ttk.OptionMenu(rowA, self._merged_a, "",
|
||
*[""] + [labelled(v) for v in slab_values]).pack(side="left", fill="x", expand=True)
|
||
|
||
rowB = ttk.Frame(sub); rowB.pack(fill="x", pady=2)
|
||
ttk.Label(rowB, text="두 번째 석판:", width=14).pack(side="left")
|
||
ttk.OptionMenu(rowB, self._merged_b, "",
|
||
*[""] + [labelled(v) for v in slab_values]).pack(side="left", fill="x", expand=True)
|
||
|
||
rowL = ttk.Frame(sub); rowL.pack(fill="x", pady=2)
|
||
ttk.Label(rowL, text="누적 레벨:", width=14).pack(side="left")
|
||
ttk.Spinbox(rowL, from_=1, to=10, textvariable=self._merged_lvl,
|
||
width=6).pack(side="left")
|
||
|
||
def _pick_slab(self, value: str) -> None:
|
||
self._chosen_value = value
|
||
self._chosen_kind = "slab"
|
||
|
||
def _ok(self) -> None:
|
||
k = self.kind_var.get()
|
||
if k == "slab":
|
||
if not self._chosen_value:
|
||
messagebox.showinfo("안내", "석판을 선택하세요.")
|
||
return
|
||
self.result = {"kind": "slab", "value": self._chosen_value,
|
||
"rotation": 0, "merged": None}
|
||
elif k == "artifact":
|
||
if not self._chosen_value:
|
||
messagebox.showinfo("안내", "아티팩트를 선택하세요.")
|
||
return
|
||
self.result = {"kind": "artifact", "value": self._chosen_value,
|
||
"rotation": 0, "merged": None}
|
||
elif k == "merged":
|
||
def _val_from_label(lbl: str) -> Optional[str]:
|
||
if not lbl:
|
||
return None
|
||
if "(" in lbl and lbl.endswith(")"):
|
||
return lbl[lbl.rfind("(") + 1: -1]
|
||
return None
|
||
a = _val_from_label(self._merged_a.get())
|
||
b = _val_from_label(self._merged_b.get())
|
||
if not a or not b:
|
||
messagebox.showinfo("안내", "두 석판을 모두 선택하세요.")
|
||
return
|
||
self.result = {"kind": "merged", "value": None, "rotation": 0,
|
||
"merged": {"a": a, "b": b, "level": int(self._merged_lvl.get())}}
|
||
else:
|
||
self.result = {"kind": "empty", "value": None, "rotation": 0, "merged": None}
|
||
self.destroy()
|
||
|
||
|
||
# ---------- screenshot/game-window frame ----------
|
||
|
||
class ScreenshotFrame(ttk.Frame):
|
||
def __init__(self, master, on_confirmed) -> None:
|
||
super().__init__(master, padding=6)
|
||
self.on_confirmed = on_confirmed
|
||
self.slot_var = master.master.slot_var # type: ignore[attr-defined]
|
||
self.image: Optional[Image.Image] = None
|
||
self.bbox: Optional[Tuple[int, int, int, int]] = None
|
||
self.cells: List[CellResult] = []
|
||
# per-slot override: dict slot_id -> {kind, value, rotation, merged}
|
||
self.overrides: Dict[str, dict] = {}
|
||
self._thumbs: List[ImageTk.PhotoImage] = []
|
||
self._templates_warmed = False
|
||
|
||
ctl = ttk.Frame(self)
|
||
ctl.pack(fill="x")
|
||
ttk.Button(ctl, text="🎮 게임 창 선택…", command=self._pick_window).pack(side="left")
|
||
ttk.Button(ctl, text="🖥 전체 화면 캡처", command=self._capture_screen).pack(side="left", padx=4)
|
||
ttk.Button(ctl, text="📂 파일 열기…", command=self._open_file).pack(side="left", padx=4)
|
||
ttk.Button(ctl, text="🔁 영역 재지정", command=self._reselect_bbox).pack(side="left", padx=4)
|
||
ttk.Button(ctl, text="✅ 이 구성으로 계산", command=self._confirm).pack(side="right")
|
||
|
||
self.status = ttk.Label(
|
||
self,
|
||
text=(
|
||
"1) [게임 창 선택] 으로 Sephiria 창을 고르거나, [전체 화면 캡처]/[파일 열기] 로 이미지를 가져옵니다.\n"
|
||
"2) 가방 격자의 좌상단/우하단을 두 번 클릭해 영역을 지정합니다.\n"
|
||
"3) 자동 인식 후 잘못된 셀은 클릭해서 종류/석판/아티팩트/합쳐진(?) 으로 교정하세요."
|
||
),
|
||
wraplength=520, justify="left",
|
||
)
|
||
self.status.pack(fill="x", pady=(6, 4))
|
||
|
||
self.preview_canvas = tk.Canvas(self, height=440, highlightthickness=0)
|
||
self.preview_canvas.pack(fill="both", expand=True)
|
||
self.preview_inner = ttk.Frame(self.preview_canvas)
|
||
self.preview_canvas.create_window((0, 0), window=self.preview_inner, anchor="nw")
|
||
self.preview_inner.bind(
|
||
"<Configure>",
|
||
lambda e: self.preview_canvas.configure(
|
||
scrollregion=self.preview_canvas.bbox("all")
|
||
),
|
||
)
|
||
|
||
# ----- input modes -----
|
||
def _pick_window(self) -> None:
|
||
dlg = WindowPicker(self.winfo_toplevel())
|
||
self.winfo_toplevel().wait_window(dlg)
|
||
if not dlg.selected:
|
||
return
|
||
try:
|
||
from .window_capture import capture_window
|
||
self.image = capture_window(dlg.selected)
|
||
except Exception as e:
|
||
messagebox.showerror("창 캡처 실패", str(e))
|
||
return
|
||
self.status["text"] = f"창 캡처 완료: {dlg.selected.title} ({self.image.size[0]}×{self.image.size[1]})"
|
||
self._pick_bbox_and_recognize()
|
||
|
||
def _capture_screen(self) -> None:
|
||
try:
|
||
from .capture import capture_screen
|
||
top = self.winfo_toplevel()
|
||
top.withdraw(); top.update()
|
||
try:
|
||
self.image = capture_screen(monitor=1)
|
||
finally:
|
||
top.deiconify()
|
||
except Exception as e:
|
||
self.winfo_toplevel().deiconify()
|
||
messagebox.showerror("캡처 실패", str(e))
|
||
return
|
||
self._pick_bbox_and_recognize()
|
||
|
||
def _open_file(self) -> None:
|
||
path = filedialog.askopenfilename(
|
||
title="스크린샷 선택",
|
||
filetypes=[("Images", "*.png *.jpg *.jpeg *.webp"), ("All", "*.*")],
|
||
)
|
||
if not path:
|
||
return
|
||
try:
|
||
self.image = Image.open(path).convert("RGB")
|
||
except Exception as e:
|
||
messagebox.showerror("열기 실패", str(e))
|
||
return
|
||
self._pick_bbox_and_recognize()
|
||
|
||
def _reselect_bbox(self) -> None:
|
||
if self.image is None:
|
||
messagebox.showinfo("안내", "먼저 캡처 또는 파일 열기를 해주세요.")
|
||
return
|
||
self._pick_bbox_and_recognize()
|
||
|
||
# ----- pipeline -----
|
||
def _pick_bbox_and_recognize(self) -> None:
|
||
assert self.image is not None
|
||
dlg = CropDialog(self.winfo_toplevel(), self.image)
|
||
self.winfo_toplevel().wait_window(dlg)
|
||
if not dlg.bbox:
|
||
return
|
||
self.bbox = dlg.bbox
|
||
self.overrides.clear()
|
||
self.status["text"] = "템플릿 준비 + 셀 인식 중…"
|
||
self.update_idletasks()
|
||
threading.Thread(target=self._recognize_thread, daemon=True).start()
|
||
|
||
def _recognize_thread(self) -> None:
|
||
try:
|
||
if not self._templates_warmed:
|
||
# First call may download a lot — keep artifacts on (user wants them)
|
||
warm_templates(include_artifacts=True)
|
||
self._templates_warmed = True
|
||
slot_num = int(round(self.slot_var.get()))
|
||
cells = recognize_image(
|
||
self.image, self.bbox,
|
||
slot_num=slot_num, include_artifacts=True,
|
||
)
|
||
self.after(0, self._show_cells, cells)
|
||
except Exception as e:
|
||
self.after(0, lambda: messagebox.showerror("인식 실패", str(e)))
|
||
|
||
def _show_cells(self, cells: List[CellResult]) -> None:
|
||
self.cells = cells
|
||
for c in self.preview_inner.winfo_children():
|
||
c.destroy()
|
||
self._thumbs.clear()
|
||
|
||
slot_num = int(round(self.slot_var.get()))
|
||
grid = generate_grid_config(slot_num)
|
||
slot_to_cell = {c.slot_id: c for c in cells}
|
||
|
||
kind_counts = {"slab": 0, "artifact": 0, "empty": 0, "unknown": 0, "merged": 0}
|
||
for row_cfg in grid:
|
||
y = row_cfg["rows"]
|
||
for x in range(GRID_COLS):
|
||
if x >= row_cfg["cols"]:
|
||
tk.Frame(self.preview_inner, width=64, height=80,
|
||
bg=self.preview_inner.winfo_toplevel()["bg"]) \
|
||
.grid(row=y, column=x, padx=2, pady=2)
|
||
continue
|
||
slot_id = f"{y}-{x}"
|
||
cell = slot_to_cell.get(slot_id)
|
||
ov = self.overrides.get(slot_id)
|
||
effective = self._effective(cell, ov)
|
||
kind_counts[effective["kind"]] = kind_counts.get(effective["kind"], 0) + 1
|
||
self._make_cell(y, x, slot_id, effective)
|
||
|
||
msg = (
|
||
f"석판 {kind_counts.get('slab', 0)} · 아티팩트 {kind_counts.get('artifact', 0)} · "
|
||
f"빈칸 {kind_counts.get('empty', 0)} · 합쳐진(?) {kind_counts.get('merged', 0)} · "
|
||
f"미인식 {kind_counts.get('unknown', 0)}\n"
|
||
"셀을 클릭하면 종류/값을 교정할 수 있습니다. 끝나면 [이 구성으로 계산]."
|
||
)
|
||
self.status["text"] = msg
|
||
|
||
def _effective(self, cell: Optional[CellResult], ov: Optional[dict]) -> dict:
|
||
if ov is not None:
|
||
return ov
|
||
if cell is None:
|
||
return {"kind": "empty", "value": None, "rotation": 0, "merged": None, "score": 0.0}
|
||
return {
|
||
"kind": cell.kind, "value": cell.value,
|
||
"rotation": cell.rotation, "merged": None, "score": cell.score,
|
||
}
|
||
|
||
def _make_cell(self, y: int, x: int, slot_id: str, info: dict) -> None:
|
||
kind = info.get("kind", "empty")
|
||
value = info.get("value")
|
||
rot = info.get("rotation", 0) or 0
|
||
score = info.get("score", 0.0)
|
||
border = {"slab": "#7a4a8a", "artifact": "#6a82c8", "merged": "#c870c0",
|
||
"unknown": "#c8a050", "empty": "#3a2a3a"}.get(kind, "#3a2a3a")
|
||
frame = tk.Frame(self.preview_inner, bd=2, relief="solid",
|
||
width=72, height=82, bg="#2c1a2a",
|
||
highlightbackground=border, highlightthickness=2)
|
||
frame.grid(row=y, column=x, padx=2, pady=2)
|
||
frame.grid_propagate(False)
|
||
|
||
if kind == "slab" and value:
|
||
thumb = _slab_thumb(value, size=44)
|
||
if thumb is not None:
|
||
if rot:
|
||
# generate rotated thumb on the fly
|
||
base = fetch_slab_image(SLABS_BY_VALUE[value].image)
|
||
if base is not None:
|
||
base = base.resize((44, 44)).rotate(-90 * rot, expand=False)
|
||
thumb = ImageTk.PhotoImage(base)
|
||
self._thumbs.append(thumb)
|
||
lbl = tk.Label(frame, image=thumb, bg="#2c1a2a")
|
||
else:
|
||
lbl = tk.Label(frame, text=SLABS_BY_VALUE[value].ko_label,
|
||
fg="#fff", bg="#2c1a2a")
|
||
elif kind == "artifact" and value:
|
||
thumb = _artifact_thumb(value, size=44)
|
||
if thumb is not None:
|
||
self._thumbs.append(thumb)
|
||
lbl = tk.Label(frame, image=thumb, bg="#2c1a2a")
|
||
else:
|
||
a = ARTIFACTS_BY_VALUE.get(value)
|
||
lbl = tk.Label(frame, text=a.ko_label if a else value,
|
||
fg="#9bf", bg="#2c1a2a")
|
||
elif kind == "merged":
|
||
lbl = tk.Label(frame, text="?", font=("TkDefaultFont", 26, "bold"),
|
||
fg="#ffaaff", bg="#2c1a2a")
|
||
elif kind == "unknown":
|
||
lbl = tk.Label(frame, text="?", font=("TkDefaultFont", 26, "bold"),
|
||
fg="#ffd070", bg="#2c1a2a")
|
||
else:
|
||
lbl = tk.Label(frame, text="·", fg="#666", bg="#2c1a2a")
|
||
lbl.pack(expand=True)
|
||
|
||
caption = ""
|
||
if kind == "slab" and value:
|
||
caption = SLABS_BY_VALUE[value].ko_label
|
||
if rot:
|
||
caption += f" ↻{rot}"
|
||
elif kind == "artifact" and value:
|
||
a = ARTIFACTS_BY_VALUE.get(value)
|
||
caption = a.ko_label if a else value
|
||
elif kind == "merged":
|
||
m = info.get("merged") or {}
|
||
la = SLABS_BY_VALUE.get(m.get("a", "")) if m else None
|
||
lb = SLABS_BY_VALUE.get(m.get("b", "")) if m else None
|
||
caption = f"{la.ko_label if la else '?'}+{lb.ko_label if lb else '?'} L{m.get('level', 1)}" if m else "합쳐진 박스"
|
||
elif kind == "unknown":
|
||
caption = f"미인식 {score:.2f}"
|
||
else:
|
||
caption = "빈칸"
|
||
tk.Label(frame, text=caption, fg="#cfcfcf", bg="#2c1a2a",
|
||
font=("TkDefaultFont", 7)).pack(fill="x")
|
||
|
||
def on_click(_e=None, sid=slot_id):
|
||
self._edit(sid)
|
||
for w in (frame, lbl):
|
||
w.bind("<Button-1>", on_click)
|
||
|
||
def _edit(self, slot_id: str) -> None:
|
||
cell = next((c for c in self.cells if c.slot_id == slot_id), None)
|
||
dlg = CellEditor(self.winfo_toplevel(), cell)
|
||
self.winfo_toplevel().wait_window(dlg)
|
||
if dlg.result is None:
|
||
return
|
||
# store override, then re-render
|
||
self.overrides[slot_id] = {**dlg.result, "score": 1.0}
|
||
self._show_cells(self.cells)
|
||
|
||
def _confirm(self) -> None:
|
||
if not self.cells and not self.overrides:
|
||
messagebox.showinfo("안내", "먼저 캡처 + 영역 지정을 해주세요.")
|
||
return
|
||
basket: List[str] = []
|
||
for cell in self.cells:
|
||
ov = self.overrides.get(cell.slot_id)
|
||
eff = self._effective(cell, ov)
|
||
if eff["kind"] == "slab" and eff.get("value"):
|
||
basket.append(eff["value"])
|
||
elif eff["kind"] == "merged":
|
||
m = eff.get("merged") or {}
|
||
# treat a merged box as having both its component slabs in the basket
|
||
if m.get("a"):
|
||
basket.append(m["a"])
|
||
if m.get("b"):
|
||
basket.append(m["b"])
|
||
self.on_confirmed(basket)
|
||
|
||
|
||
# ---------- manual input frame ----------
|
||
|
||
class ManualFrame(ttk.Frame):
|
||
def __init__(self, master, on_changed) -> None:
|
||
super().__init__(master, padding=4)
|
||
self.counts: Dict[str, int] = {s.value: 0 for s in SLABS}
|
||
self.count_labels: Dict[str, tk.Label] = {}
|
||
self.on_changed = on_changed
|
||
self._build()
|
||
|
||
def _build(self) -> None:
|
||
canvas = tk.Canvas(self, highlightthickness=0)
|
||
scroll = ttk.Scrollbar(self, orient="vertical", command=canvas.yview)
|
||
inner = ttk.Frame(canvas)
|
||
inner.bind("<Configure>",
|
||
lambda e: canvas.configure(scrollregion=canvas.bbox("all")))
|
||
canvas.create_window((0, 0), window=inner, anchor="nw")
|
||
canvas.configure(yscrollcommand=scroll.set)
|
||
canvas.pack(side="left", fill="both", expand=True)
|
||
scroll.pack(side="right", fill="y")
|
||
|
||
by_tier: Dict[str, List] = {}
|
||
for s in SLABS:
|
||
by_tier.setdefault(s.tier, []).append(s)
|
||
|
||
row = 0
|
||
for tier in sorted(by_tier, key=lambda t: TIER_ORDER.get(t, 99)):
|
||
ttk.Label(inner, text=TIER_LABEL.get(tier, tier),
|
||
font=("TkDefaultFont", 10, "bold")) \
|
||
.grid(row=row, column=0, columnspan=4, sticky="w", pady=(8, 2))
|
||
row += 1
|
||
for slab in by_tier[tier]:
|
||
ttk.Label(inner, text=slab.ko_label, width=8).grid(row=row, column=0, sticky="w")
|
||
ttk.Button(inner, text="−", width=2,
|
||
command=lambda v=slab.value: self._change(v, -1)).grid(row=row, column=1)
|
||
lbl = ttk.Label(inner, text="0", width=3, anchor="center")
|
||
lbl.grid(row=row, column=2)
|
||
self.count_labels[slab.value] = lbl
|
||
ttk.Button(inner, text="+", width=2,
|
||
command=lambda v=slab.value: self._change(v, 1)).grid(row=row, column=3)
|
||
row += 1
|
||
|
||
def _change(self, v: str, d: int) -> None:
|
||
self.counts[v] = max(0, self.counts.get(v, 0) + d)
|
||
self.count_labels[v]["text"] = str(self.counts[v])
|
||
self.on_changed()
|
||
|
||
def clear(self) -> None:
|
||
for v in self.counts:
|
||
self.counts[v] = 0
|
||
self.count_labels[v]["text"] = "0"
|
||
self.on_changed()
|
||
|
||
def basket(self) -> List[str]:
|
||
out: List[str] = []
|
||
for v, n in self.counts.items():
|
||
out.extend([v] * n)
|
||
return out
|
||
|
||
|
||
# ---------- main app ----------
|
||
|
||
class App(tk.Tk):
|
||
def __init__(self) -> None:
|
||
super().__init__()
|
||
self.title("Sephiria Inventory Optimizer")
|
||
self.geometry("1320x820")
|
||
self.minsize(1100, 640)
|
||
|
||
self.slot_var = tk.IntVar(value=34)
|
||
self.basket: List[str] = []
|
||
self.summary_var = tk.StringVar(value="선택된 석판: 0개")
|
||
self.score_var = tk.StringVar(value="score: -")
|
||
self.solving = False
|
||
self.preview_image: Optional[ImageTk.PhotoImage] = None
|
||
self.last_solution = None
|
||
self._build()
|
||
|
||
def _build(self) -> None:
|
||
root = ttk.Frame(self, padding=8)
|
||
root.pack(fill="both", expand=True)
|
||
root.columnconfigure(0, weight=2)
|
||
root.columnconfigure(1, weight=3)
|
||
root.rowconfigure(0, weight=1)
|
||
|
||
nb = ttk.Notebook(root)
|
||
nb.grid(row=0, column=0, sticky="nsew", padx=(0, 6))
|
||
self.screenshot = ScreenshotFrame(nb, on_confirmed=self._on_screenshot_confirmed)
|
||
nb.add(self.screenshot, text="게임창/스크린샷")
|
||
self.manual = ManualFrame(nb, on_changed=self._on_manual_changed)
|
||
nb.add(self.manual, text="수동 선택")
|
||
self.nb = nb
|
||
|
||
right = ttk.Frame(root)
|
||
right.grid(row=0, column=1, sticky="nsew")
|
||
right.columnconfigure(0, weight=1)
|
||
right.rowconfigure(2, weight=1)
|
||
|
||
ctl = ttk.LabelFrame(right, text="옵션", padding=8)
|
||
ctl.grid(row=0, column=0, sticky="ew")
|
||
ttk.Label(ctl, text="슬롯 수").grid(row=0, column=0, sticky="w")
|
||
slot_scale = ttk.Scale(ctl, from_=18, to=60, orient="horizontal",
|
||
variable=self.slot_var, command=self._on_slot)
|
||
slot_scale.grid(row=0, column=1, sticky="ew", padx=6)
|
||
ctl.columnconfigure(1, weight=1)
|
||
self.slot_label = ttk.Label(ctl, text="34")
|
||
self.slot_label.grid(row=0, column=2, sticky="w")
|
||
|
||
ttk.Button(ctl, text="비우기", command=self._clear_basket).grid(
|
||
row=1, column=0, pady=(8, 0), sticky="w")
|
||
self.solve_btn = ttk.Button(ctl, text="최적 배치 계산", command=self._solve)
|
||
self.solve_btn.grid(row=1, column=1, pady=(8, 0), sticky="ew", padx=6)
|
||
ttk.Button(ctl, text="이미지 저장…", command=self._save).grid(
|
||
row=1, column=2, pady=(8, 0), sticky="e")
|
||
|
||
summary = ttk.Frame(right)
|
||
summary.grid(row=1, column=0, sticky="ew", pady=(6, 0))
|
||
ttk.Label(summary, textvariable=self.summary_var).pack(side="left")
|
||
ttk.Label(summary, textvariable=self.score_var).pack(side="right")
|
||
|
||
preview_frame = ttk.LabelFrame(right, text="결과 미리보기", padding=4)
|
||
preview_frame.grid(row=2, column=0, sticky="nsew", pady=(6, 0))
|
||
self.preview = ttk.Label(
|
||
preview_frame, anchor="center",
|
||
text="좌측에서 인벤토리를 가져오거나 석판을 추가한 뒤 "
|
||
"'최적 배치 계산'을 눌러주세요.",
|
||
)
|
||
self.preview.pack(fill="both", expand=True)
|
||
|
||
def _on_manual_changed(self) -> None:
|
||
self.basket = self.manual.basket()
|
||
self.summary_var.set(f"선택된 석판: {len(self.basket)}개 (수동)")
|
||
|
||
def _on_screenshot_confirmed(self, basket: List[str]) -> None:
|
||
self.basket = list(basket)
|
||
self.summary_var.set(f"선택된 석판: {len(self.basket)}개 (스크린샷)")
|
||
messagebox.showinfo("확정",
|
||
f"{len(self.basket)}개를 가져왔습니다. '최적 배치 계산'을 누르세요.")
|
||
|
||
def _on_slot(self, _evt) -> None:
|
||
v = int(round(self.slot_var.get()))
|
||
self.slot_var.set(v)
|
||
self.slot_label["text"] = str(v)
|
||
|
||
def _clear_basket(self) -> None:
|
||
self.manual.clear()
|
||
self.basket = []
|
||
self.summary_var.set("선택된 석판: 0개")
|
||
|
||
def _solve(self) -> None:
|
||
if self.solving:
|
||
return
|
||
if not self.basket:
|
||
messagebox.showinfo("안내",
|
||
"먼저 인벤토리를 가져오거나 수동 선택으로 석판을 추가해주세요.")
|
||
return
|
||
slot_num = int(round(self.slot_var.get()))
|
||
basket = list(self.basket)
|
||
if len(basket) > slot_num:
|
||
if not messagebox.askyesno("확인",
|
||
f"슬롯({slot_num})보다 석판({len(basket)})이 많습니다. 초과분 무시?"):
|
||
return
|
||
self.solving = True
|
||
self.solve_btn["state"] = "disabled"
|
||
self.score_var.set("score: 계산 중…")
|
||
threading.Thread(target=self._solve_worker, args=(basket, slot_num), daemon=True).start()
|
||
|
||
def _solve_worker(self, basket: List[str], slot_num: int) -> None:
|
||
try:
|
||
sol = solve(basket, slot_num=slot_num, time_limit=4.0)
|
||
img = render_solution(sol, download=True)
|
||
self.after(0, self._show_result, sol, img)
|
||
except Exception as e:
|
||
self.after(0, lambda: messagebox.showerror("오류", str(e)))
|
||
finally:
|
||
self.after(0, self._solve_done)
|
||
|
||
def _solve_done(self) -> None:
|
||
self.solving = False
|
||
self.solve_btn["state"] = "normal"
|
||
|
||
def _show_result(self, sol, img: Image.Image) -> None:
|
||
self.last_solution = sol
|
||
w = max(self.preview.winfo_width(), 600)
|
||
scale = min(1.0, w / img.width)
|
||
if scale < 1.0:
|
||
img = img.resize((int(img.width * scale), int(img.height * scale)))
|
||
self.preview_image = ImageTk.PhotoImage(img)
|
||
self.preview.configure(image=self.preview_image, text="")
|
||
self.score_var.set(f"score: {sol.score}")
|
||
|
||
def _save(self) -> None:
|
||
if self.last_solution is None:
|
||
messagebox.showinfo("안내", "먼저 계산을 실행하세요.")
|
||
return
|
||
path = filedialog.asksaveasfilename(
|
||
defaultextension=".png", filetypes=[("PNG", "*.png")],
|
||
initialfile="sephiria_layout.png",
|
||
)
|
||
if not path:
|
||
return
|
||
img = render_solution(self.last_solution, download=True)
|
||
img.save(path)
|
||
messagebox.showinfo("완료", f"저장됨: {path}")
|
||
|
||
|
||
def main() -> int:
|
||
try:
|
||
app = App()
|
||
except tk.TclError as e:
|
||
print(f"GUI를 띄울 수 없습니다 ({e}). CLI 모드를 시도하세요:", file=sys.stderr)
|
||
print(" python -m sephiria_inv --help", file=sys.stderr)
|
||
return 1
|
||
app.mainloop()
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|