Create ablation.py

ablation.py

@@ -0,0 +1,1076 @@
+# imgnet_ablation_viewer.py
+# IMGNet Ablation + Comparison Viewer
+# Kiri : Upload 2 foto + score metrics (IMG Sign, AMP, Chain, Cosine)
+# Kanan: Compare (overlay/sign/chain/embedding) & Ablation (baca-ulang sliding window)
+# Ablation: bandingkan HASIL BACA ULANG sliding window (asli vs terdampak-occlusion)
+#           → tampilkan blok/window mana saja yang berubah, bukan cuma skor akhir
+
+import tkinter as tk
+from tkinter import filedialog
+from PIL import Image, ImageTk, ImageDraw
+import numpy as np
+import threading
+from collections import Counter
+
+# ── CONFIG ─────────────────────────────────────────────────
+CKPT_PATH   = r"C:\PythonProj\img_bnn\checkpoints_sw357_conv10_imgsign\SW357_conv10_imgsign\best_model_epoch39_plateau.pth"
+WINDOW_SIZE = 11
+THRESHOLD   = 8
+EMB_DIM     = 1024
+IMG_SIZE    = 112
+NEUTRAL_LEN = 29
+REWARD_RATE = 0.3
+PUNISH_RATE = 1.0
+MASK_COLOR  = 128
+SOFT_BETA          = 5.0   # sharpness tanh agreement per-dimensi (soft sign+magnitude)
+SOFT_GATE_SHARPNESS= 15.0  # sharpness sigmoid gate di sekitar THRESHOLD (landai)
+
+BG=    "#0a0e1a"; CARD=  "#111827"; BORDER="#1e293b"
+BLUE=  "#6366f1"; GREEN= "#10b981"; ORANGE="#f59e0b"
+PURPLE="#a855f7"; TEAL=  "#14b8a6"; RED=   "#ef4444"
+YELLOW="#fbbf24"; WHITE= "#ffffff"; SUB=   "#64748b"; TEXT="#e2e8f0"
+
+REGION_COLS = [
+    "#60a5fa","#34d399","#f59e0b","#f472b6","#a78bfa",
+    "#fb923c","#22d3ee","#e879f9","#facc15","#6ee7b7"
+]
+REGIONS = {
+    "Mata Kiri"   : (25, 20, 50, 55),
+    "Mata Kanan"  : (25, 57, 50, 90),
+    "Semua Mata"  : (18, 12, 52, 100),
+    "Hidung"      : (50, 35, 75, 77),
+    "Mulut"       : (72, 25, 95, 87),
+    "Dahi"        : (4,  18, 27, 94),
+    "Rahang Kiri" : (72, 3,  112, 45),
+    "Rahang Kanan": (72, 67, 112, 109),
+    "Bagian Atas" : (0,  0,  56,  112),
+    "Bagian Bawah": (56, 0,  112, 112),
+}
+CUSTOM_KEY = "Custom (6 Titik)"
+
+# ── MODEL LOAD ─────────────────────────────────────────────
+try:
+    import torch, torch.nn as nn, torch.nn.functional as F
+    TORCH_OK = True
+except: TORCH_OK = False
+
+try:
+    from facenet_pytorch import MTCNN
+    _mtcnn = MTCNN(image_size=112, keep_all=False, post_process=False,
+                   device="cuda" if (TORCH_OK and torch.cuda.is_available()) else "cpu")
+    MTCNN_OK = True
+except: _mtcnn = None; MTCNN_OK = False
+
+_model = None; _device = "cpu"
+
+if TORCH_OK:
+    class _SW(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.fc = nn.Sequential(nn.Linear(240,64),nn.ReLU(True),nn.Linear(64,32))
+        def forward(self, x):
+            B,C,H,W=x.shape; diffs=[]
+            for ws in [3,5,7]:
+                p=ws//2; xp=F.pad(x,[p,p,p,p],mode='reflect')
+                pat=xp.unfold(2,ws,1).unfold(3,ws,1)
+                d=x.unsqueeze(-1).unsqueeze(-1)-pat
+                m=torch.ones(ws,ws,dtype=torch.bool,device=x.device); m[ws//2,ws//2]=False
+                diffs.append(d[:,:,:,:,m])
+            d=torch.cat(diffs,-1); B,C,H,W,N=d.shape
+            o=self.fc(d.permute(0,2,3,1,4).reshape(B*H*W,C*N))
+            return o.reshape(B,H,W,-1).permute(0,3,1,2)
+
+    class _Net(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.sw1=_SW(); self.bn1=nn.BatchNorm2d(32)
+            self.conv2 =nn.Conv2d(32, 64,3,stride=1,padding=1,bias=False); self.bn2 =nn.BatchNorm2d(64)
+            self.conv3 =nn.Conv2d(64, 64,3,stride=2,padding=1,bias=False); self.bn3 =nn.BatchNorm2d(64)
+            self.conv4 =nn.Conv2d(64,128,3,stride=1,padding=1,bias=False); self.bn4 =nn.BatchNorm2d(128)
+            self.conv5 =nn.Conv2d(128,128,3,stride=1,padding=1,bias=False); self.bn5 =nn.BatchNorm2d(128)
+            self.conv6 =nn.Conv2d(128,128,3,stride=2,padding=1,bias=False); self.bn6 =nn.BatchNorm2d(128)
+            self.conv7 =nn.Conv2d(128,256,3,stride=1,padding=1,bias=False); self.bn7 =nn.BatchNorm2d(256)
+            self.conv8 =nn.Conv2d(256,256,3,stride=1,padding=1,bias=False); self.bn8 =nn.BatchNorm2d(256)
+            self.conv9 =nn.Conv2d(256,256,3,stride=2,padding=1,bias=False); self.bn9 =nn.BatchNorm2d(256)
+            self.conv10=nn.Conv2d(256,256,3,stride=1,padding=1,bias=False); self.bn10=nn.BatchNorm2d(256)
+            self.gap=nn.AdaptiveAvgPool2d(1); self.fc=nn.Linear(256,1024); self.bn=nn.BatchNorm1d(1024)
+        def forward(self,x):
+            x=F.relu(self.bn1(self.sw1(x)))
+            for i in range(2,11):
+                x=F.relu(getattr(self,f'bn{i}')(getattr(self,f'conv{i}')(x)))
+            return self.bn(self.fc(self.gap(x).view(x.size(0),-1)))
+
+    import os
+    if os.path.exists(CKPT_PATH):
+        try:
+            _device="cuda" if torch.cuda.is_available() else "cpu"
+            _model=_Net().to(_device)
+            st=torch.load(CKPT_PATH,map_location="cpu",weights_only=False)
+            if isinstance(st,dict) and "model" in st: st=st["model"]
+            _model.load_state_dict(st); _model.eval()
+            print(f"✓ IMGNet loaded  device={_device}")
+        except Exception as e: print(f"✗ {e}"); _model=None
+
+
+# ── UTILS ──────────────────────────────────────────────────
+def get_emb(arr):
+    if _model and TORCH_OK:
+        try:
+            t=torch.from_numpy(arr.astype(np.float32)/255.0).permute(2,0,1).unsqueeze(0).to(_device)
+            with torch.no_grad(): return _model(t).squeeze(0).cpu().numpy()
+        except: pass
+    np.random.seed(int(arr.sum())%2**31)
+    e=np.random.randn(EMB_DIM).astype(np.float32)
+    return e/(np.linalg.norm(e)+1e-8)
+
+def load_face(path):
+    img=Image.open(path).convert("RGB")
+    if MTCNN_OK and _mtcnn:
+        try:
+            face=_mtcnn(img)
+            if face is not None:
+                return np.clip(face.permute(1,2,0).numpy(),0,255).astype(np.uint8)
+        except: pass
+    return np.array(img.resize((IMG_SIZE,IMG_SIZE),Image.BILINEAR))
+
+def occlude(arr, name):
+    out=arr.copy(); r1,c1,r2,c2=REGIONS[name]
+    out[r1:r2,c1:c2]=MASK_COLOR; return out
+
+def polygon_to_mask(points, size=IMG_SIZE):
+    """points: list of (x,y) dalam ruang 112x112 (x=kolom, y=baris).
+    Return boolean mask HxW — True = di dalam polygon."""
+    img=Image.new('L',(size,size),0)
+    ImageDraw.Draw(img).polygon(points,fill=255)
+    return np.array(img)>0
+
+def occlude_mask(arr, mask):
+    if mask is None: return arr
+    out=arr.copy(); out[mask]=MASK_COLOR; return out
+
+def img_sign_score(e1,e2):
+    n=len(e1)-WINDOW_SIZE+1
+    return sum(1 for i in range(n)
+               if sum(1 for j in range(WINDOW_SIZE)
+                      if (e1[i+j]>=0)==(e2[i+j]>=0))>=THRESHOLD)/max(n,1)
+
+def amp_score(e1,e2):
+    n=len(e1)-WINDOW_SIZE+1; tot=0.0
+    for i in range(n):
+        w1,w2=e1[i:i+WINDOW_SIZE],e2[i:i+WINDOW_SIZE]
+        s1=np.where(w1>=0,1,-1).astype(np.int8); s2=np.where(w2>=0,1,-1).astype(np.int8)
+        if int(np.sum(s1==s2))>=THRESHOLD:
+            a1,a2=np.mean(np.abs(w1)),np.mean(np.abs(w2))
+            tot+=max(0.0,1-abs(a1-a2)/max(a1,a2,1e-6))
+    return tot/max(n,1)
+
+def chain_score(e1,e2):
+    n=len(e1)-WINDOW_SIZE+1
+    flags=[int(np.sum(np.where(e1[i:i+WINDOW_SIZE]>=0,1,-1).astype(np.int8)==
+                      np.where(e2[i:i+WINDOW_SIZE]>=0,1,-1).astype(np.int8)))>=THRESHOLD
+           for i in range(n)]
+    total=sum(flags); sg=total/max(n,1)
+    nc=0; ic=False
+    for f in flags:
+        if f and not ic: nc+=1; ic=True
+        elif not f: ic=False
+    if nc==0 or total==0: return 0.0,0,0.0
+    ac=total/nc; diff=ac-NEUTRAL_LEN
+    score=sg+(REWARD_RATE*diff if diff>=0 else PUNISH_RATE*diff)/100
+    return float(np.clip(score,0,1)),nc,ac
+
+def cosine(e1,e2):
+    return float(np.dot(e1,e2)/(np.linalg.norm(e1)*np.linalg.norm(e2)+1e-8))
+
+def lerp_color(t, c1="#ef4444", c2="#10b981"):
+    r1,g1,b1=int(c1[1:3],16),int(c1[3:5],16),int(c1[5:7],16)
+    r2,g2,b2=int(c2[1:3],16),int(c2[3:5],16),int(c2[5:7],16)
+    r=int(r1+(r2-r1)*t); g=int(g1+(g2-g1)*t); b=int(b1+(b2-b1)*t)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+# ── ABLATION: BACA ULANG SLIDING WINDOW ────────────────────
+def window_sign_match(e1, e2):
+    """Baca ulang tiap sliding window (window_size=11, threshold=8) antara e1 dan e2.
+    Return array boolean per window: True = window MASIH cocok (>=THRESHOLD bit
+    searah), False = window ini BERUBAH akibat oklusi.
+    e1 = embedding asli, e2 = embedding foto yang sudah di-occlude."""
+    n=len(e1)-WINDOW_SIZE+1
+    out=np.zeros(n,dtype=bool)
+    for i in range(n):
+        s1=np.where(e1[i:i+WINDOW_SIZE]>=0,1,-1).astype(np.int8)
+        s2=np.where(e2[i:i+WINDOW_SIZE]>=0,1,-1).astype(np.int8)
+        out[i]=int(np.sum(s1==s2))>=THRESHOLD
+    return out
+
+def soft_window_match(e1, e2, beta=SOFT_BETA, gate_sharpness=SOFT_GATE_SHARPNESS):
+    """Versi soft/differentiable dari window_sign_match + amp ratio (numpy port,
+    tanpa torch), berdasarkan:
+        agreement  = (tanh(beta * E1 * E2) + 1) / 2      # per-dimensi
+        soft_match = sliding-window-sum(agreement)        # analog count 0..WINDOW_SIZE
+        gate       = sigmoid(gate_sharpness*(soft_match - THRESHOLD + 0.5))
+        amp1/amp2  = sliding-window-mean(|E1|), sliding-window-mean(|E2|)
+    Tidak ada cliff seperti window_sign_match: 'agreement' juga mempertimbangkan
+    magnitude, dan 'gate' transisi mulus di sekitar THRESHOLD alih-alih lompat.
+    Return (gate, amp_ratio, combined) — semua array sepanjang n_win, TANPA
+    di-gating oleh hasil hard-threshold (beda dari window_amp_sim)."""
+    def window_sum(arr, w):
+        c=np.cumsum(np.insert(arr,0,0.0))
+        return c[w:]-c[:-w]
+    prod=e1.astype(np.float64)*e2.astype(np.float64)
+    agreement=(np.tanh(beta*prod)+1)/2
+    soft_match=window_sum(agreement, WINDOW_SIZE)
+    gate=1.0/(1.0+np.exp(-gate_sharpness*(soft_match-THRESHOLD+0.5)))
+    amp1=window_sum(np.abs(e1.astype(np.float64)), WINDOW_SIZE)/WINDOW_SIZE
+    amp2=window_sum(np.abs(e2.astype(np.float64)), WINDOW_SIZE)/WINDOW_SIZE
+    amp_ratio=np.clip(1.0-np.abs(amp1-amp2)/np.maximum(np.maximum(amp1,amp2),1e-6),0.0,1.0)
+    combined=gate*amp_ratio
+    return gate, amp_ratio, combined
+
+def changed_segments(blocks):
+    """Kelompokkan window yang BERUBAH (False) menjadi segmen kontinu.
+    Return list of (start_idx, length) — dipakai untuk breakdown, bukan cuma
+    angka akhir."""
+    segs=[]; i=0; n=len(blocks)
+    while i<n:
+        if not blocks[i]:
+            j=i
+            while j<n and not blocks[j]: j+=1
+            segs.append((i,j-i)); i=j
+        else:
+            i+=1
+    return segs
+
+
+# ============================================================
+# APP
+# ============================================================
+class App(tk.Tk):
+    def __init__(self):
+        super().__init__()
+        self.title("IMGNet — Ablation + Comparison Viewer")
+        self.geometry("1600x900")
+        self.configure(bg=BG)
+        self.resizable(True,True)
+
+        # State
+        self.arr1=None; self.arr2=None
+        self.e1=None;   self.e2=None
+        self.dc1={};    self.dc2={}   # cache per region: {"emb":..., "blocks":...}
+        self.sel=tk.StringVar(value="Semua Mata")
+        self.mode=tk.StringVar(value="compare")  # compare / ablation
+        self.custom_points={1:[],2:[]}   # titik polygon TERPISAH per foto, max 6 tiap foto
+        self.custom_mask={1:None,2:None} # mask hasil polygon per foto
+        self.custom_active_photo=1       # foto mana yg lagi digambar di kanvas custom
+
+        self._build()
+
+    # ── BUILD ─────────────────────────────────────────────
+    def _build(self):
+        top=tk.Frame(self,bg=BG); top.pack(fill="x",padx=12,pady=(8,4))
+        tk.Label(top,text="IMGNet  ·  Ablation + Comparison Viewer",
+                 font=("Courier",13,"bold"),bg=BG,fg=TEXT).pack(side="left")
+        st=f"Model={'✓' if _model else '✗ dummy'}  MTCNN={'✓' if MTCNN_OK else '✗'}"
+        tk.Label(top,text=st,font=("Courier",9),bg=BG,fg=SUB).pack(side="right")
+
+        main=tk.Frame(self,bg=BG); main.pack(fill="both",expand=True,padx=8,pady=4)
+        main.grid_columnconfigure(0,weight=0,minsize=280)
+        main.grid_columnconfigure(1,weight=1)
+        main.grid_rowconfigure(0,weight=1)
+
+        self._build_left(main)
+        self._build_right(main)
+
+    def _build_left(self,parent):
+        lf_container=tk.Frame(parent,bg=CARD,highlightthickness=1,
+                    highlightbackground=BORDER,width=280)
+        lf_container.grid(row=0,column=0,sticky="nsew",padx=(0,8))
+        lf_container.grid_propagate(False)
+
+        # Panel kiri dibungkus Canvas+Scrollbar supaya SEMUA kontrol (termasuk
+        # region Custom & checkbox tampilan) selalu bisa dicapai walau window
+        # dipersempit / kontennya makin panjang — sebelumnya item di bawah
+        # bisa "hilang" (terpotong) tanpa cara buat mengaksesnya.
+        lf_canvas=tk.Canvas(lf_container,bg=CARD,highlightthickness=0)
+        lf_scroll=tk.Scrollbar(lf_container,orient="vertical",command=lf_canvas.yview)
+        lf_canvas.configure(yscrollcommand=lf_scroll.set)
+        lf_canvas.pack(side="left",fill="both",expand=True)
+        lf_scroll.pack(side="right",fill="y")
+
+        lf=tk.Frame(lf_canvas,bg=CARD)   # frame konten asli — semua widget di bawah nempel di sini
+        lf_window=lf_canvas.create_window((0,0),window=lf,anchor="nw")
+
+        def _on_lf_configure(event):
+            lf_canvas.configure(scrollregion=lf_canvas.bbox("all"))
+        lf.bind("<Configure>",_on_lf_configure)
+
+        def _on_canvas_configure(event):
+            lf_canvas.itemconfig(lf_window,width=event.width)
+        lf_canvas.bind("<Configure>",_on_canvas_configure)
+
+        def _on_mousewheel(event):
+            lf_canvas.yview_scroll(int(-1*(event.delta/120)),"units")
+        def _bind_wheel(_): lf_canvas.bind_all("<MouseWheel>",_on_mousewheel)
+        def _unbind_wheel(_): lf_canvas.unbind_all("<MouseWheel>")
+        lf_canvas.bind("<Enter>",_bind_wheel)
+        lf_canvas.bind("<Leave>",_unbind_wheel)
+
+        # Upload buttons
+        tk.Label(lf,text="FOTO",font=("Courier",10,"bold"),bg=CARD,fg=BLUE).pack(pady=(8,4))
+        btn_f=tk.Frame(lf,bg=CARD); btn_f.pack(fill="x",padx=8)
+        tk.Button(btn_f,text="Upload Foto 1",command=self.upload1,
+                  bg=BLUE,fg=WHITE,font=("Courier",9,"bold"),
+                  relief="flat",pady=4,cursor="hand2").pack(side="left",expand=True,fill="x",padx=2)
+        tk.Button(btn_f,text="Upload Foto 2",command=self.upload2,
+                  bg=GREEN,fg=WHITE,font=("Courier",9,"bold"),
+                  relief="flat",pady=4,cursor="hand2").pack(side="left",expand=True,fill="x",padx=2)
+
+        # Preview row
+        prev=tk.Frame(lf,bg=CARD); prev.pack(fill="x",padx=6,pady=4)
+        prev.grid_columnconfigure(0,weight=1); prev.grid_columnconfigure(1,weight=1)
+        for col,label,color,attr in [(0,"Foto 1",BLUE,"c1"),(1,"Foto 2",GREEN,"c2")]:
+            f=tk.Frame(prev,bg=CARD); f.grid(row=0,column=col,padx=2)
+            tk.Label(f,text=label,font=("Courier",8,"bold"),bg=CARD,fg=color).pack()
+            c=tk.Canvas(f,width=120,height=120,bg="#050810",
+                        highlightthickness=1,highlightbackground=BORDER); c.pack()
+            setattr(self,attr,c)
+
+        # Mode tabs
+        tk.Label(lf,text="MODE",font=("Courier",9,"bold"),bg=CARD,fg=SUB).pack(pady=(6,2))
+        mf=tk.Frame(lf,bg=CARD); mf.pack(fill="x",padx=8)
+        for val,label,col in [("compare","COMPARE",TEAL),("ablation","ABLATION",PURPLE)]:
+            tk.Radiobutton(mf,text=label,variable=self.mode,value=val,
+                          bg=CARD,fg=col,selectcolor=CARD,
+                          font=("Courier",9,"bold"),
+                          command=self._refresh).pack(side="left",padx=6)
+
+        # Indikator region aktif — selalu kelihatan di atas (nggak ikut ke-scroll)
+        # biar nggak ambigu region mana yang benar-benar dipilih.
+        self.region_active_lbl=tk.Label(lf,text="Region aktif: —",
+                                         font=("Courier",8,"bold"),bg="#0a0e1a",fg=YELLOW,
+                                         anchor="w",padx=6,pady=3)
+        self.region_active_lbl.pack(fill="x",padx=8,pady=(2,4))
+
+        # Metrics (compare mode)
+        self.metric_f=tk.Frame(lf,bg=CARD); self.metric_f.pack(fill="x",padx=8,pady=4)
+        self.m_sign  =self._mbox(self.metric_f,"IMG SIGN",GREEN)
+        self.m_amp   =self._mbox(self.metric_f,"AMP IMG", ORANGE)
+        self.m_chain =self._mbox(self.metric_f,"CHAIN",   TEAL)
+        self.m_cos   =self._mbox(self.metric_f,"COSINE",  PURPLE)
+
+        # Verdict
+        self.verdict_lbl=tk.Label(lf,text="—",
+                                   font=("Courier",18,"bold"),bg=CARD,fg=SUB,
+                                   pady=6,highlightthickness=2,highlightbackground=BORDER)
+        self.verdict_lbl.pack(fill="x",padx=8,pady=4)
+
+        # Chain detail
+        self.chain_lbl=tk.Label(lf,text="",font=("Courier",8),bg=CARD,fg=SUB,
+                                 justify="left",wraplength=250)
+        self.chain_lbl.pack(padx=10)
+
+        # Ablation region selector
+        tk.Label(lf,text="REGION OKLUASI",font=("Courier",9,"bold"),
+                 bg=CARD,fg=ORANGE).pack(pady=(10,2))
+        for i,name in enumerate(REGIONS):
+            col=REGION_COLS[i%len(REGION_COLS)]
+            tk.Radiobutton(lf,text=name,variable=self.sel,value=name,
+                          bg=CARD,fg=TEXT,selectcolor=CARD,
+                          font=("Courier",9),
+                          command=self._on_region).pack(anchor="w",padx=16,pady=1)
+        tk.Radiobutton(lf,text=CUSTOM_KEY,variable=self.sel,value=CUSTOM_KEY,
+                      bg=CARD,fg=PURPLE,selectcolor=CARD,
+                      font=("Courier",9,"bold"),
+                      command=self._on_region).pack(anchor="w",padx=16,pady=(4,1))
+
+        # ── Ablation display toggles ────────────────────────
+        tk.Label(lf,text="TAMPILAN BACA-ULANG WINDOW",font=("Courier",9,"bold"),
+                 bg=CARD,fg=YELLOW).pack(pady=(10,2))
+        self.v_show_asli      = tk.BooleanVar(value=True)   # garis biru = embedding asli
+        self.v_show_terdampak = tk.BooleanVar(value=True)   # garis merah = embedding ter-occlude
+        self.v_show_blocks    = tk.BooleanVar(value=True)   # bar blok hijau/merah per window
+        self.v_show_delta     = tk.BooleanVar(value=True)   # sinyal delta besar (spike)
+
+        tk.Checkbutton(lf,text="Garis Asli (Biru)",variable=self.v_show_asli,
+                       bg=CARD,fg=BLUE,selectcolor=CARD,activebackground=CARD,
+                       activeforeground=BLUE,font=("Courier",9,"bold"),
+                       command=self._on_region).pack(anchor="w",padx=16,pady=1)
+        tk.Checkbutton(lf,text="Garis Terdampak (Merah)",variable=self.v_show_terdampak,
+                       bg=CARD,fg=RED,selectcolor=CARD,activebackground=CARD,
+                       activeforeground=RED,font=("Courier",9,"bold"),
+                       command=self._on_region).pack(anchor="w",padx=16,pady=1)
+        tk.Checkbutton(lf,text="Bar Blok Berubah (Hijau/Merah)",variable=self.v_show_blocks,
+                       bg=CARD,fg=YELLOW,selectcolor=CARD,activebackground=CARD,
+                       activeforeground=YELLOW,font=("Courier",9,"bold"),
+                       command=self._on_region).pack(anchor="w",padx=16,pady=1)
+        tk.Checkbutton(lf,text="Tandai Delta Besar (Spike)",variable=self.v_show_delta,
+                       bg=CARD,fg=ORANGE,selectcolor=CARD,activebackground=CARD,
+                       activeforeground=ORANGE,font=("Courier",9,"bold"),
+                       command=self._on_region).pack(anchor="w",padx=16,pady=1)
+
+        # Ablation breakdown (bukan cuma skor akhir)
+        self.abl_lbl=tk.Label(lf,text="",font=("Courier",8),bg=CARD,fg=TEXT,
+                               justify="left",wraplength=250)
+        self.abl_lbl.pack(padx=10,pady=6)
+
+    def _mbox(self,parent,label,color):
+        f=tk.Frame(parent,bg="#0a0e1a",highlightthickness=1,highlightbackground=BORDER)
+        f.pack(side="left",expand=True,fill="both",padx=2,pady=2)
+        tk.Label(f,text=label,font=("Courier",6,"bold"),bg="#0a0e1a",fg=color).pack(pady=(4,0))
+        lbl=tk.Label(f,text="—",font=("Courier",13,"bold"),bg="#0a0e1a",fg=color)
+        lbl.pack(pady=(0,4)); return lbl
+
+    def _build_right(self,parent):
+        rf=tk.Frame(parent,bg=CARD,highlightthickness=1,highlightbackground=BORDER)
+        rf.grid(row=0,column=1,sticky="nsew")
+
+        # ── COMPARE MODE canvases ──────────────────────────
+        self.cmp_frame=tk.Frame(rf,bg=CARD); self.cmp_frame.pack(fill="both",expand=True)
+
+        tk.Label(self.cmp_frame,
+            text="Embedding: Biru=Foto1  Hijau=Foto2  — window aktif di-highlight",
+            font=("Courier",9,"bold"),bg=CARD,fg=TEAL).pack(pady=(6,1))
+        self.c_emb=tk.Canvas(self.cmp_frame,bg="#050810",height=180,
+                              highlightthickness=1,highlightbackground=BORDER)
+        self.c_emb.pack(fill="x",padx=8,pady=2)
+
+        tk.Label(self.cmp_frame,
+            text="Sign match per window (hijau=match ≥8/11, merah=tidak)",
+            font=("Courier",9,"bold"),bg=CARD,fg=GREEN).pack(pady=(4,1))
+        self.c_sign=tk.Canvas(self.cmp_frame,bg="#050810",height=80,
+                               highlightthickness=1,highlightbackground=BORDER)
+        self.c_sign.pack(fill="x",padx=8,pady=2)
+
+        tk.Label(self.cmp_frame,
+            text="Chain pattern (rantai match kontinu — panjang rantai = kualitas kecocokan)",
+            font=("Courier",9,"bold"),bg=CARD,fg=TEAL).pack(pady=(4,1))
+        self.c_chain=tk.Canvas(self.cmp_frame,bg="#050810",height=70,
+                                highlightthickness=1,highlightbackground=BORDER)
+        self.c_chain.pack(fill="x",padx=8,pady=2)
+
+        # Embedding bars foto 1 dan 2
+        emb_row=tk.Frame(self.cmp_frame,bg=CARD)
+        emb_row.pack(fill="x",padx=8,pady=(4,2))
+        emb_row.grid_columnconfigure(0,weight=1)
+        emb_row.grid_columnconfigure(1,weight=1)
+
+        lf1=tk.Frame(emb_row,bg=CARD); lf1.grid(row=0,column=0,sticky="ew",padx=(0,4))
+        tk.Label(lf1,text="Embedding Foto 1 (1024D)",font=("Courier",8,"bold"),
+                 bg=CARD,fg=BLUE).pack()
+        self.c_emb1=tk.Canvas(lf1,bg="#050810",height=60,
+                               highlightthickness=1,highlightbackground=BORDER)
+        self.c_emb1.pack(fill="x")
+
+        lf2=tk.Frame(emb_row,bg=CARD); lf2.grid(row=0,column=1,sticky="ew",padx=(4,0))
+        tk.Label(lf2,text="Embedding Foto 2 (1024D)",font=("Courier",8,"bold"),
+                 bg=CARD,fg=GREEN).pack()
+        self.c_emb2=tk.Canvas(lf2,bg="#050810",height=60,
+                               highlightthickness=1,highlightbackground=BORDER)
+        self.c_emb2.pack(fill="x")
+
+        # ── ABLATION MODE canvases ─────────────────────────
+        self.abl_frame=tk.Frame(rf,bg=CARD); # tidak di-pack dulu
+
+        # Kanvas gambar polygon custom (6 titik) — hanya di-pack saat
+        # region terpilih == CUSTOM_KEY, disisipkan di atas panel hasil
+        self.custom_draw_frame=tk.Frame(self.abl_frame,bg=CARD)
+        tk.Label(self.custom_draw_frame,
+            text="OKLUSI CUSTOM — klik 6 titik di foto (urut, otomatis nutup jadi polygon).  "
+                 "Foto1 & Foto2 digambar TERPISAH — pilih tab di bawah.",
+            font=("Courier",9,"bold"),bg=CARD,fg=PURPLE).pack(pady=(6,2))
+        toggle_row=tk.Frame(self.custom_draw_frame,bg=CARD); toggle_row.pack(pady=(0,4))
+        self.btn_custom_p1=tk.Button(toggle_row,text="✎ Gambar Foto 1",
+                  command=lambda:self._switch_custom_photo(1),
+                  font=("Courier",9,"bold"),relief="flat",padx=10,cursor="hand2")
+        self.btn_custom_p1.pack(side="left",padx=4)
+        self.btn_custom_p2=tk.Button(toggle_row,text="✎ Gambar Foto 2",
+                  command=lambda:self._switch_custom_photo(2),
+                  font=("Courier",9,"bold"),relief="flat",padx=10,cursor="hand2")
+        self.btn_custom_p2.pack(side="left",padx=4)
+        draw_row=tk.Frame(self.custom_draw_frame,bg=CARD); draw_row.pack()
+        self.custom_scale=3
+        cs=IMG_SIZE*self.custom_scale
+        self.c_custom_draw=tk.Canvas(draw_row,width=cs,height=cs,bg="#050810",
+                                      highlightthickness=1,highlightbackground=BORDER,
+                                      cursor="crosshair")
+        self.c_custom_draw.pack(padx=4,pady=2)
+        self.c_custom_draw.bind("<Button-1>", self._on_custom_click)
+        btn_row=tk.Frame(self.custom_draw_frame,bg=CARD); btn_row.pack(pady=(2,6))
+        tk.Button(btn_row,text="Reset Titik",command=self._reset_custom_points,
+                  bg=RED,fg=WHITE,font=("Courier",9,"bold"),relief="flat",
+                  padx=8,cursor="hand2").pack(side="left",padx=4)
+        self.btn_apply_custom=tk.Button(btn_row,text="Terapkan Oklusi",
+                  command=self._apply_custom_occlusion,
+                  bg=PURPLE,fg=WHITE,font=("Courier",9,"bold"),relief="flat",
+                  padx=8,cursor="hand2",state="disabled")
+        self.btn_apply_custom.pack(side="left",padx=4)
+        self.custom_status_lbl=tk.Label(btn_row,text="0/6 titik",
+                  font=("Courier",9,"bold"),bg=CARD,fg=SUB)
+        self.custom_status_lbl.pack(side="left",padx=8)
+        self._update_custom_toggle_style()
+
+        self.abl_d1_title=tk.Label(self.abl_frame,
+            text="Foto1 — Baca Ulang Sliding Window: Asli vs Terdampak",
+            font=("Courier",9,"bold"),bg=CARD,fg=WHITE)
+        self.abl_d1_title.pack(pady=(6,1))
+        self.c_d1=tk.Canvas(self.abl_frame,bg="#050810",height=90,
+                             highlightthickness=1,highlightbackground=BORDER)
+        self.c_d1.pack(fill="x",padx=8,pady=2)
+        self.c_blk1=tk.Canvas(self.abl_frame,bg="#050810",height=50,
+                               highlightthickness=1,highlightbackground=BORDER)
+        self.c_blk1.pack(fill="x",padx=8,pady=(0,6))
+
+        self.abl_d2_title=tk.Label(self.abl_frame,
+            text="Foto2 — Baca Ulang Sliding Window: Asli vs Terdampak",
+            font=("Courier",9,"bold"),bg=CARD,fg=WHITE)
+        self.abl_d2_title.pack(pady=(4,1))
+        self.c_d2=tk.Canvas(self.abl_frame,bg="#050810",height=90,
+                             highlightthickness=1,highlightbackground=BORDER)
+        self.c_d2.pack(fill="x",padx=8,pady=2)
+        self.c_blk2=tk.Canvas(self.abl_frame,bg="#050810",height=50,
+                               highlightthickness=1,highlightbackground=BORDER)
+        self.c_blk2.pack(fill="x",padx=8,pady=(0,6))
+
+        tk.Label(self.abl_frame,
+            text="Perbandingan region — % window yang berubah kalau region ini di-occlude (Biru=Foto1  Hijau=Foto2)",
+            font=("Courier",9,"bold"),bg=CARD,fg=WHITE).pack(pady=(4,1))
+        self.c_multi=tk.Canvas(self.abl_frame,bg="#050810",height=150,
+                                highlightthickness=1,highlightbackground=BORDER)
+        self.c_multi.pack(fill="x",padx=8,pady=(2,6))
+
+        tk.Label(self.abl_frame,
+            text="Konsistensi blok berubah: Foto1 vs Foto2 pada region terpilih — blok merah di lokasi SAMA = region ini konsisten di-encode walau beda orang",
+            font=("Courier",9,"bold"),bg=CARD,fg=WHITE).pack(pady=(4,1))
+        self.c_consist=tk.Canvas(self.abl_frame,bg="#050810",height=110,
+                                  highlightthickness=1,highlightbackground=BORDER)
+        self.c_consist.pack(fill="x",padx=8,pady=(2,6))
+
+        # Bind resize agar grafik re-draw saat ukuran berubah
+        for cv in [self.c_emb,self.c_sign,self.c_chain,
+                   self.c_emb1,self.c_emb2,
+                   self.c_d1,self.c_d2,self.c_blk1,self.c_blk2,
+                   self.c_multi,self.c_consist]:
+            cv.bind("<Configure>", lambda e: self.after(50, self._redraw_all))
+
+        # Default: show compare
+        self.cmp_frame.pack(fill="both",expand=True)
+
+    # ── UPLOAD ────────────────────────────────────────────
+    def _redraw_all(self):
+        """Re-draw semua grafik yang aktif setelah window resize"""
+        if self.mode.get()=="compare":
+            self._draw_compare()
+        else:
+            self._on_region()
+            self._draw_multi()
+
+    def _get_w(self, canvas, fallback=1200):
+        """Get actual canvas width after rendering"""
+        w = canvas.winfo_width()
+        return w if w > 10 else fallback
+
+    def upload1(self):
+        path=filedialog.askopenfilename(filetypes=[("Image","*.jpg *.jpeg *.png *.bmp")])
+        if not path: return
+        self.arr1=load_face(path); self.e1=get_emb(self.arr1)
+        self._show(self.arr1,self.c1,120)
+        self.dc1={}
+        threading.Thread(target=self._precompute,args=(1,),daemon=True).start()
+        self._refresh()
+
+    def upload2(self):
+        path=filedialog.askopenfilename(filetypes=[("Image","*.jpg *.jpeg *.png *.bmp")])
+        if not path: return
+        self.arr2=load_face(path); self.e2=get_emb(self.arr2)
+        self._show(self.arr2,self.c2,120)
+        self.dc2={}
+        threading.Thread(target=self._precompute,args=(2,),daemon=True).start()
+        self._refresh()
+
+    def _show(self,arr,canvas,size,region=None):
+        img=Image.fromarray(arr.astype(np.uint8)).resize((size,size),Image.NEAREST)
+        if region:
+            draw=ImageDraw.Draw(img); r1,c1,r2,c2=REGIONS[region]
+            sc=size/IMG_SIZE
+            draw.rectangle([c1*sc,r1*sc,c2*sc,r2*sc],outline=ORANGE,width=2)
+        tk_img=ImageTk.PhotoImage(img)
+        canvas.delete("all"); canvas.create_image(0,0,anchor="nw",image=tk_img)
+        canvas.image=tk_img
+
+    def _precompute(self,which):
+        """Untuk tiap region: occlude foto, hitung ulang embedding, lalu BACA ULANG
+        sliding window (window_sign_match) antara embedding asli vs embedding
+        ter-occlude. Hasilnya array boolean per window (blocks), bukan kurva delta."""
+        arr=self.arr1 if which==1 else self.arr2
+        emb=self.e1   if which==1 else self.e2
+        dc =self.dc1  if which==1 else self.dc2
+        for name in REGIONS:
+            occ=occlude(arr,name); eo=get_emb(occ)
+            blocks=window_sign_match(emb,eo)   # True=window tetap, False=window berubah
+            dc[name]={"emb":eo,"blocks":blocks}
+        if self.custom_mask.get(which) is not None:
+            self._compute_custom_for(which)
+        self.after(0,self._draw_multi)
+        self.after(0,self._on_region)
+
+    # ── REFRESH MODE ─────────────────────────────────────
+    def _refresh(self):
+        mode=self.mode.get()
+        if mode=="compare":
+            self.abl_frame.pack_forget()
+            self.cmp_frame.pack(fill="both",expand=True)
+            self._draw_compare()
+        else:
+            self.cmp_frame.pack_forget()
+            self.abl_frame.pack(fill="both",expand=True)
+            self._on_region()
+
+    # ── COMPARE DRAWS ─────────────────────────────────────
+    def _draw_compare(self):
+        if self.e1 is None or self.e2 is None: return
+        e1,e2=self.e1,self.e2
+
+        # Scores
+        sg=img_sign_score(e1,e2); ap=amp_score(e1,e2)
+        cs,nc,ac=chain_score(e1,e2); co=cosine(e1,e2)
+        self.m_sign.config(text=f"{sg:.3f}")
+        self.m_amp.config(text=f"{ap:.3f}")
+        self.m_chain.config(text=f"{cs:.3f}")
+        self.m_cos.config(text=f"{co:.3f}")
+        self.chain_lbl.config(
+            text=f"Chains: {nc}  AvgLen: {ac:.1f}  (neutral={NEUTRAL_LEN})")
+
+        thr=0.79; npass=sum([sg>=thr,ap>=thr,cs>=thr])
+        if npass>=2:
+            self.verdict_lbl.config(text="✅  MATCH",fg=WHITE,bg="#064e3b",
+                                     highlightbackground=GREEN)
+        elif npass==1:
+            self.verdict_lbl.config(text="⚠️  UNCERTAIN",fg=WHITE,bg="#78350f",
+                                     highlightbackground=ORANGE)
+        else:
+            self.verdict_lbl.config(text="❌  DIFFERENT",fg=WHITE,bg="#450a0a",
+                                     highlightbackground=RED)
+
+        # Embedding bar
+        self._draw_emb_bars()
+        self._draw_sign_pattern()
+        self._draw_chain_pattern()
+        self._draw_emb_single(self.c_emb1,self.e1,BLUE,"Foto 1")
+        self._draw_emb_single(self.c_emb2,self.e2,GREEN,"Foto 2")
+
+    def _draw_emb_bars(self):
+        c=self.c_emb; c.delete("all")
+        W=self._get_w(c); H=180
+        n=len(self.e1); bw=W/n; mid=H//2
+        c.create_line(0,mid,W,mid,fill=BORDER,width=1,dash=(3,2))
+        for i in range(n):
+            x0=i*bw; x1=x0+bw-0.3
+            v1=float(self.e1[i]); h1=abs(v1)*(mid-4)
+            if v1>=0: c.create_rectangle(x0,mid-h1,x1,mid,fill=BLUE,outline="")
+            else:     c.create_rectangle(x0,mid,x1,mid+h1,fill=BLUE,outline="")
+            v2=float(self.e2[i]); h2=abs(v2)*(mid-4)*0.7
+            if v2>=0: c.create_rectangle(x0,mid-h2,x1,mid,fill=GREEN,outline="",stipple="gray25")
+            else:     c.create_rectangle(x0,mid,x1,mid+h2,fill=GREEN,outline="",stipple="gray25")
+        c.create_text(4,4,anchor="nw",
+            text="Biru=Foto1  Hijau=Foto2  (stipple)  — dimensi yang searah = sign cocok",
+            font=("Courier",7),fill=SUB)
+
+    def _draw_emb_single(self,canvas,emb,color,label):
+        """Grafik embedding individual (1024D) untuk satu foto — dipakai di kedua canvas bawah."""
+        canvas.delete("all")
+        if emb is None:
+            W=self._get_w(canvas); H=60
+            canvas.create_text(W//2,H//2,text=f"Upload {label}...",
+                               font=("Courier",9),fill=SUB)
+            return
+        W=self._get_w(canvas); H=60
+        n=len(emb); bw=W/n; mid=H//2
+        canvas.create_line(0,mid,W,mid,fill=BORDER,width=1,dash=(3,2))
+        for i in range(n):
+            x0=i*bw; x1=x0+bw-0.3
+            v=float(emb[i]); h=abs(v)*(mid-3)
+            if v>=0: canvas.create_rectangle(x0,mid-h,x1,mid,fill=color,outline="")
+            else:    canvas.create_rectangle(x0,mid,x1,mid+h,fill=color,outline="")
+        canvas.create_text(4,2,anchor="nw",
+            text=f"{label}  min={emb.min():.2f}  max={emb.max():.2f}  mean={emb.mean():.3f}",
+            font=("Courier",7),fill=SUB)
+
+    def _draw_sign_pattern(self):
+        c=self.c_sign; c.delete("all")
+        W=self._get_w(c); H=80
+        e1,e2=self.e1,self.e2; n=len(e1)-WINDOW_SIZE+1; bw=W/n
+        for i in range(n):
+            mc=sum(1 for j in range(WINDOW_SIZE)
+                   if (e1[i+j]>=0)==(e2[i+j]>=0))
+            ratio=mc/WINDOW_SIZE; h=ratio*(H-4)
+            col=GREEN if mc>=THRESHOLD else RED
+            x0=i*bw
+            c.create_rectangle(x0,H-h,x0+bw-0.3,H,fill=col,outline="")
+        c.create_line(0,H-(THRESHOLD/WINDOW_SIZE)*(H-4),
+                      W,H-(THRESHOLD/WINDOW_SIZE)*(H-4),
+                      fill=YELLOW,width=1,dash=(4,2))
+        c.create_text(4,4,anchor="nw",
+            text=f"Sign match ratio per window  (thr={THRESHOLD}/{WINDOW_SIZE} = garis kuning)",
+            font=("Courier",7),fill=SUB)
+
+    def _draw_chain_pattern(self):
+        c=self.c_chain; c.delete("all")
+        W=self._get_w(c); H=70
+        e1,e2=self.e1,self.e2; n=len(e1)-WINDOW_SIZE+1; bw=W/n
+        in_chain=False; chain_start=0; chain_num=0
+        for i in range(n):
+            mc=sum(1 for j in range(WINDOW_SIZE)
+                   if (e1[i+j]>=0)==(e2[i+j]>=0))
+            match=mc>=THRESHOLD; x0=i*bw
+            if match:
+                c.create_rectangle(x0,10,x0+bw-0.3,H-10,fill=TEAL,outline="")
+                if not in_chain:
+                    chain_start=i; in_chain=True; chain_num+=1
+                    c.create_line(x0,4,x0,H-4,fill=WHITE,width=1)
+                    c.create_text(x0+1,6,anchor="nw",
+                        text=str(chain_num),font=("Courier",6),fill=WHITE)
+            else:
+                in_chain=False
+        c.create_text(4,4,anchor="nw",
+            text=f"Chain pattern — teal=match, garis putih=awal chain baru, angka=nomor chain",
+            font=("Courier",7),fill=SUB)
+
+    # ── ABLATION: BACA ULANG SLIDING WINDOW ───────────────
+    def _switch_custom_photo(self, which):
+        self.custom_active_photo=which
+        self._update_custom_toggle_style()
+        self._draw_custom_canvas_bg()
+
+    def _update_custom_toggle_style(self):
+        active=self.custom_active_photo
+        p1_done=self.custom_mask.get(1) is not None
+        p2_done=self.custom_mask.get(2) is not None
+        self.btn_custom_p1.config(
+            bg=(BLUE if active==1 else CARD), fg=WHITE if active==1 else BLUE,
+            relief=("sunken" if active==1 else "flat"),
+            text=("✎ Gambar Foto 1 ✓" if p1_done else "✎ Gambar Foto 1"))
+        self.btn_custom_p2.config(
+            bg=(GREEN if active==2 else CARD), fg=WHITE if active==2 else GREEN,
+            relief=("sunken" if active==2 else "flat"),
+            text=("✎ Gambar Foto 2 ✓" if p2_done else "✎ Gambar Foto 2"))
+
+    def _draw_custom_canvas_bg(self):
+        """Gambar ulang background (foto yg lagi aktif di-edit) di kanvas gambar polygon."""
+        self.c_custom_draw.delete("all")
+        cs=IMG_SIZE*self.custom_scale
+        which=self.custom_active_photo
+        arr=self.arr1 if which==1 else self.arr2
+        if arr is not None:
+            img=Image.fromarray(arr.astype(np.uint8)).resize((cs,cs),Image.NEAREST)
+            tkimg=ImageTk.PhotoImage(img)
+            self.c_custom_draw.create_image(0,0,anchor="nw",image=tkimg)
+            self.c_custom_draw.image=tkimg
+        else:
+            self.c_custom_draw.create_text(cs//2,cs//2,text=f"Upload Foto {which} dulu",
+                                           font=("Courier",10),fill=SUB)
+        self._redraw_custom_points()
+
+    def _redraw_custom_points(self):
+        self.c_custom_draw.delete("pt")
+        sc=self.custom_scale
+        which=self.custom_active_photo
+        pts_orig=self.custom_points[which]
+        pts=[(x*sc,y*sc) for (x,y) in pts_orig]
+        col=BLUE if which==1 else GREEN
+        for i,(x,y) in enumerate(pts):
+            self.c_custom_draw.create_oval(x-4,y-4,x+4,y+4,fill=col,outline=WHITE,tags="pt")
+            self.c_custom_draw.create_text(x+8,y-8,text=str(i+1),fill=WHITE,
+                                           font=("Courier",8,"bold"),tags="pt")
+        for i in range(len(pts)-1):
+            x0,y0=pts[i]; x1,y1=pts[i+1]
+            self.c_custom_draw.create_line(x0,y0,x1,y1,fill=col,width=2,tags="pt")
+        if len(pts)==6:
+            x0,y0=pts[0]; x5,y5=pts[5]
+            self.c_custom_draw.create_line(x5,y5,x0,y0,fill=col,width=2,dash=(4,2),tags="pt")
+        self.custom_status_lbl.config(
+            text=f"Foto{which}: {len(pts_orig)}/6 titik")
+        self.btn_apply_custom.config(state=("normal" if len(pts_orig)==6 else "disabled"))
+
+    def _on_custom_click(self, event):
+        which=self.custom_active_photo
+        if len(self.custom_points[which])>=6: return
+        sc=self.custom_scale
+        ox=min(max(event.x/sc,0),IMG_SIZE-1)
+        oy=min(max(event.y/sc,0),IMG_SIZE-1)
+        self.custom_points[which].append((ox,oy))
+        self._redraw_custom_points()
+
+    def _reset_custom_points(self):
+        which=self.custom_active_photo
+        self.custom_points[which]=[]
+        self._redraw_custom_points()
+
+    def _compute_custom_for(self, which):
+        """Hitung ulang embedding+blocks utk region CUSTOM_KEY satu foto,
+        pakai self.custom_mask[which] milik foto itu sendiri (independen dari
+        foto satunya). Aman dipanggil dari thread background (cuma nulis ke
+        dict, tidak sentuh widget)."""
+        mask=self.custom_mask.get(which)
+        if mask is None: return
+        arr=self.arr1 if which==1 else self.arr2
+        emb=self.e1   if which==1 else self.e2
+        dc =self.dc1  if which==1 else self.dc2
+        if arr is None or emb is None: return
+        occ=occlude_mask(arr,mask)
+        eo=get_emb(occ)
+        dc[CUSTOM_KEY]={"emb":eo,"blocks":window_sign_match(emb,eo)}
+
+    def _apply_custom_occlusion(self):
+        which=self.custom_active_photo
+        pts=self.custom_points[which]
+        if len(pts)!=6: return
+        self.custom_mask[which]=polygon_to_mask(pts)
+        self._compute_custom_for(which)
+        self._update_custom_toggle_style()
+        self._draw_multi()
+        self._on_region()
+
+    def _on_region(self,*_):
+        if self.mode.get()!="ablation": return
+        name=self.sel.get()
+        self.region_active_lbl.config(text=f"Region aktif: {name}")
+        if name==CUSTOM_KEY:
+            self.custom_draw_frame.pack(fill="x",padx=8,pady=(2,4),before=self.abl_d1_title)
+            self._draw_custom_canvas_bg()
+            if self.arr1 is not None:
+                self._show(occlude_mask(self.arr1,self.custom_mask.get(1)),self.c1,120)
+            if self.arr2 is not None:
+                self._show(occlude_mask(self.arr2,self.custom_mask.get(2)),self.c2,120)
+        else:
+            self.custom_draw_frame.pack_forget()
+            if self.arr1 is not None: self._show(occlude(self.arr1,name),self.c1,120,region=name)
+            if self.arr2 is not None: self._show(occlude(self.arr2,name),self.c2,120,region=name)
+        self._draw_window_reread(name)
+        self._draw_consistency(name)
+
+    def _draw_window_reread(self,name):
+        """Untuk tiap foto: gambar embedding asli vs terdampak (garis), lalu di
+        bawahnya bar blok per sliding window (hijau=window tetap, merah=window
+        berubah). Breakdown ditampilkan (jumlah window berubah, jumlah segmen,
+        rata-rata panjang segmen) — bukan cuma satu angka skor akhir."""
+        show_asli      = self.v_show_asli.get()
+        show_terdampak = self.v_show_terdampak.get()
+        show_blocks    = self.v_show_blocks.get()
+        show_delta     = self.v_show_delta.get()
+
+        pairs = [
+            (self.c_d1, self.c_blk1, self.dc1, self.e1, self.abl_d1_title, 1),
+            (self.c_d2, self.c_blk2, self.dc2, self.e2, self.abl_d2_title, 2),
+        ]
+
+        for line_canvas, blk_canvas, dc, orig_emb, title_lbl, which in pairs:
+            line_canvas.delete("all"); blk_canvas.delete("all")
+            Wl=self._get_w(line_canvas); Hl=90
+            Wb=self._get_w(blk_canvas)
+
+            if name not in dc or orig_emb is None:
+                msg=("Gambar 6 titik & klik Terapkan Oklusi dulu"
+                     if name==CUSTOM_KEY else f"Menghitung Foto{which}...")
+                line_canvas.create_text(Wl//2,Hl//2,text=msg,
+                                        font=("Courier",9),fill=SUB)
+                continue
+
+            occ_emb = dc[name]["emb"]
+            blocks  = dc[name]["blocks"]     # True=tetap, False=berubah
+            n_dim   = len(orig_emb)
+            n_win   = len(blocks)
+
+            # ── Hitung delta per-dimensi & spike besar ──
+            delta = orig_emb.astype(np.float64) - occ_emb.astype(np.float64)
+            abs_delta = np.abs(delta)
+            mu, sd = float(abs_delta.mean()), float(abs_delta.std())
+            spike_thr = mu + 1.5*sd if sd > 1e-9 else abs_delta.max()+1
+            spike_idx = np.where(abs_delta >= spike_thr)[0]
+            d_max = float(abs_delta.max()) if abs_delta.size else 1e-8
+
+            # ── Baris atas: nilai embedding asli vs terdampak, full 1024D ──
+            mid=Hl/2
+            g_max=max(float(np.abs(orig_emb).max()),float(np.abs(occ_emb).max()))+1e-8
+            bw_d=Wl/n_dim
+
+            # spike bands digambar dulu (di belakang garis) — makin tinggi delta
+            # makin pekat oranye, tanda arah: naik keatas jika asli>terdampak,
+            # kebawah jika terdampak>asli
+            if show_delta:
+                for i in spike_idx:
+                    x0=i*bw_d
+                    t=min(1.0,(abs_delta[i]-spike_thr)/max(d_max-spike_thr,1e-8))
+                    band_col = lerp_color(0.15+0.85*t, c1="#3a2a00", c2=YELLOW)
+                    line_canvas.create_rectangle(x0,4,x0+bw_d+0.6,Hl-4,
+                                                 fill=band_col,outline="")
+
+            line_canvas.create_line(0,mid,Wl,mid,fill=BORDER,width=1,dash=(3,2))
+            if show_asli:
+                pts=[(i*bw_d, mid-(orig_emb[i]/g_max)*(mid-4)) for i in range(n_dim)]
+                for i in range(len(pts)-1):
+                    line_canvas.create_line(pts[i][0],pts[i][1],pts[i+1][0],pts[i+1][1],
+                                            fill=BLUE,width=1)
+            if show_terdampak:
+                pts=[(i*bw_d, mid-(occ_emb[i]/g_max)*(mid-4)) for i in range(n_dim)]
+                for i in range(len(pts)-1):
+                    line_canvas.create_line(pts[i][0],pts[i][1],pts[i+1][0],pts[i+1][1],
+                                            fill=RED,width=1)
+
+            # marker segitiga di puncak tiap spike: ▲ oranye kalau asli>terdampak
+            # (delta positif, dimensi "turun" akibat oklusi), ▼ ungu kalau
+            # terdampak>asli (delta negatif, dimensi "naik" akibat oklusi)
+            if show_delta:
+                for i in spike_idx:
+                    xc=i*bw_d+bw_d/2
+                    yo=mid-(orig_emb[i]/g_max)*(mid-4)
+                    yt=mid-(occ_emb[i]/g_max)*(mid-4)
+                    y_ext = min(yo,yt)-6   # titik ekstrem paling atas
+                    if delta[i] >= 0:
+                        # asli lebih tinggi/lebih positif -> segitiga naik, oranye
+                        line_canvas.create_polygon(
+                            xc,y_ext-6, xc-4,y_ext, xc+4,y_ext,
+                            fill=ORANGE, outline="")
+                    else:
+                        y_ext2 = max(yo,yt)+6
+                        line_canvas.create_polygon(
+                            xc,y_ext2+6, xc-4,y_ext2, xc+4,y_ext2,
+                            fill=PURPLE, outline="")
+
+            n_spike=len(spike_idx)
+            line_canvas.create_text(4,2,anchor="nw",
+                text=f"Foto{which} [{name}]  Biru=Asli  Merah=Terdampak  "
+                     f"Kuning=zona delta besar  ▲/▼=spike ({n_spike} dim, thr≈{spike_thr:.3f})",
+                font=("Courier",7),fill=SUB)
+
+            # ── Baris bawah: hasil BACA ULANG tiap sliding window, di-encode
+            #    pakai AMPLITUDO (persis rumus amp_score) — tinggi & warna bar
+            #    = amp_sim (hijau tinggi=amplitudo mirip, merah pendek=jomplang
+            #    atau sign gagal). Titik oranye = window sign-nya MATCH tapi
+            #    amplitudonya anomali (di atas ambang adaptif mean+1.5*std,
+            #    dihitung hanya dari window yang match). ──
+            n_changed=int(np.sum(~blocks))
+            segs=changed_segments(blocks)
+            avg_len=(n_changed/len(segs)) if segs else 0.0
+
+            gate,amp_ratio,combined=soft_window_match(orig_emb,occ_emb)  # dipakai utk bar visual (soft)
+            amp_sim=np.where(blocks,amp_ratio,0.0)  # basis anomali (hard-gated), diturunkan dari amp_ratio
+            matched_idx=np.where(blocks)[0]
+            if matched_idx.size>0:
+                amp_dev=1-amp_sim[matched_idx]
+                mu_a,sd_a=float(amp_dev.mean()),float(amp_dev.std())
+                amp_thr=mu_a+1.5*sd_a if sd_a>1e-9 else float(amp_dev.max())+1.0
+                avg_amp=float(amp_sim[matched_idx].mean())
+                anomaly_idx=[i for i in matched_idx if (1-amp_sim[i])>=amp_thr]
+            else:
+                amp_thr=2.0; avg_amp=0.0; anomaly_idx=[]
+
+            if show_blocks:
+                Hb=50; bw_w=Wb/n_win
+                for i in range(n_win):
+                    x0=i*bw_w; sim=combined[i]
+                    h=max(2.0,sim*(Hb-4))
+                    col=lerp_color(sim,c1=RED,c2=GREEN)
+                    blk_canvas.create_rectangle(x0,Hb-h,x0+bw_w+0.5,Hb,fill=col,outline="")
+                for i in anomaly_idx:
+                    xc=i*bw_w+bw_w/2; h=max(2.0,combined[i]*(Hb-4))
+                    blk_canvas.create_oval(xc-3,Hb-h-9,xc+3,Hb-h-3,fill=ORANGE,outline="")
+                blk_canvas.create_text(Wb-4,2,anchor="ne",
+                    text="tinggi/warna=soft gate×amp  •=anomali amplitudo (hard)",
+                    font=("Courier",6),fill=SUB)
+
+            blk_canvas.create_text(4,2,anchor="nw",
+                text=f"Berubah:{n_changed}/{n_win}({n_changed/max(n_win,1)*100:.0f}%) "
+                     f"seg:{len(segs)} avglen:{avg_len:.1f} | "
+                     f"AMP avg:{avg_amp:.2f} anomali:{len(anomaly_idx)}",
+                font=("Courier",7,"bold"),fill=WHITE)
+
+            title_lbl.config(
+                text=f"Foto{which} [{name}] — Baca Ulang Sliding Window  "
+                     f"(berubah: {n_changed}/{n_win} = {n_changed/max(n_win,1)*100:.1f}%  "
+                     f"spike delta: {n_spike}  amp avg: {avg_amp:.2f}  amp anomali: {len(anomaly_idx)})")
+
+    def _draw_multi(self):
+        """Bandingkan semua region: berapa persen window yang berubah kalau
+        region tsb ditutup. Biru=Foto1, Hijau=Foto2 — makin tinggi bar makin
+        sensitif region itu terhadap oklusi."""
+        c=self.c_multi; c.delete("all")
+        if not self.dc1 and not self.dc2: return
+        W=self._get_w(c); H=150
+        names=list(REGIONS.keys())
+        if CUSTOM_KEY in self.dc1 or CUSTOM_KEY in self.dc2:
+            names=names+[CUSTOM_KEY]
+        n=len(names)
+        slot=W/n; bar_w=slot*0.32; base=H-28
+
+        c.create_line(0,base,W,base,fill=BORDER)
+        for idx,name in enumerate(names):
+            xc=idx*slot+slot/2
+            col=REGION_COLS[idx%len(REGION_COLS)]
+            if name in self.dc1:
+                r1=np.sum(~self.dc1[name]["blocks"])/len(self.dc1[name]["blocks"])
+                h1=r1*base
+                c.create_rectangle(xc-bar_w,base-h1,xc,base,fill=BLUE,outline="")
+                c.create_text(xc-bar_w/2,base-h1-2,text=f"{r1*100:.0f}",
+                              anchor="s",font=("Courier",6),fill=BLUE)
+            if name in self.dc2:
+                r2=np.sum(~self.dc2[name]["blocks"])/len(self.dc2[name]["blocks"])
+                h2=r2*base
+                c.create_rectangle(xc,base-h2,xc+bar_w,base,fill=GREEN,outline="")
+                c.create_text(xc+bar_w/2,base-h2-2,text=f"{r2*100:.0f}",
+                              anchor="s",font=("Courier",6),fill=GREEN)
+            c.create_text(xc,base+4,text=name.split()[0],anchor="n",
+                          font=("Courier",6),fill=col)
+        c.create_text(W-4,4,anchor="ne",
+            text="Biru=Foto1  Hijau=Foto2  (angka=% window berubah per region)",
+            font=("Courier",7),fill=SUB)
+
+    def _draw_consistency(self,name):
+        """Bandingkan blok yang berubah pada region terpilih antara Foto1 dan
+        Foto2 (bukan kurva delta yang di-smooth). Konsistensi diukur dengan
+        Jaccard overlap dari posisi window yang sama-sama berubah."""
+        c=self.c_consist; c.delete("all")
+        W=self._get_w(c); H=110
+        if name not in self.dc1 or name not in self.dc2:
+            c.create_text(W//2,H//2,text="Tunggu precompute...",
+                         font=("Courier",9),fill=SUB); return
+        b1=self.dc1[name]["blocks"]; b2=self.dc2[name]["blocks"]
+        n=min(len(b1),len(b2)); bw=W/n
+
+        row1_top,row1_bot = 8,44
+        row2_top,row2_bot = 54,90
+
+        for i in range(n):
+            x0=i*bw
+            c.create_rectangle(x0,row1_top,x0+bw+0.5,row1_bot,
+                               fill=(RED if not b1[i] else "#0f2418"),outline="")
+            c.create_rectangle(x0,row2_top,x0+bw+0.5,row2_bot,
+                               fill=(ORANGE if not b2[i] else "#0f2418"),outline="")
+
+        changed1=~b1[:n]; changed2=~b2[:n]
+        inter=int(np.sum(changed1 & changed2))
+        union=int(np.sum(changed1 | changed2))
+        jacc=inter/union if union>0 else 0.0
+        col_j=GREEN if jacc>0.5 else (YELLOW if jacc>0.2 else RED)
+
+        c.create_text(4,H-2,anchor="sw",
+            text=f"Atas=Foto1(merah=berubah)  Bawah=Foto2(oranye=berubah)  overlap={inter}/{union}",
+            font=("Courier",7),fill=SUB)
+        c.create_text(W-4,4,anchor="ne",
+            text=f"Konsistensi (Jaccard): {jacc:.3f}",
+            font=("Courier",9,"bold"),fill=col_j)
+
+        sim1=img_sign_score(self.e1,self.dc1[name]["emb"]) if self.e1 is not None else 0
+        sim2=img_sign_score(self.e2,self.dc2[name]["emb"]) if self.e2 is not None else 0
+        n1=int(np.sum(changed1)); n2=int(np.sum(changed2))
+        self.abl_lbl.config(
+            text=f"[{name}]\n"
+                 f"Foto1: {n1}/{n} window berubah ({n1/max(n,1)*100:.1f}%)  sign-sim akhir={sim1:.4f}\n"
+                 f"Foto2: {n2}/{n} window berubah ({n2/max(n,1)*100:.1f}%)  sign-sim akhir={sim2:.4f}\n"
+                 f"Overlap posisi berubah (Jaccard): {jacc:.3f}\n"
+                 f"({'Konsisten ✓' if jacc>0.4 else 'Tidak konsisten ✗'})",
+            fg=GREEN if jacc>0.4 else RED)
+
+
+if __name__=="__main__":
+    app=App()
+    app.after(200, app._redraw_all)  # trigger setelah window render
+    app.mainloop()