escaner-app 1.0.0__tar.gz

escaner_app-1.0.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: escaner-app
+Version: 1.0.0
+Summary: Aplicación de escaneo de fotos con auto-recorte
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Requires-Dist: opencv-python
+Requires-Dist: pillow
+Requires-Dist: pywin32

escaner_app-1.0.0/escaner/app.py

@@ -0,0 +1,1124 @@
+"""
+EscanApp - Aplicación de escaneo moderna para Windows
+Soporte para 1–5 fotos por escaneo con auto-recorte y diseño mejorado.
+
+Requiere: pip install Pillow pywin32 opencv-python numpy
+"""
+
+import tkinter as tk
+from tkinter import ttk, filedialog, messagebox
+import threading
+import os
+from datetime import datetime
+from pathlib import Path
+
+try:
+    from PIL import Image, ImageTk, ImageOps, ImageFilter, ImageEnhance
+    PIL_AVAILABLE = True
+except ImportError:
+    PIL_AVAILABLE = False
+
+try:
+    import cv2
+    import numpy as np
+    CV2_AVAILABLE = True
+except ImportError:
+    CV2_AVAILABLE = False
+
+# ── Paleta oscura monocromática ────────────────────────────────────────────────
+BG_MAIN      = "#1a1a1a"      # fondo principal casi negro
+BG_SIDEBAR   = "#111111"      # sidebar negro
+BG_CARD      = "#242424"      # tarjetas gris muy oscuro
+BG_CANVAS    = "#1e1e1e"      # fondo canvas
+ACCENT       = "#e0e0e0"      # blanco/gris claro (acento principal)
+ACCENT2      = "#c0c0c0"      # gris medio
+ACCENT_LIGHT = "#888888"      # gris medio-claro
+ACCENT_DIM   = "#333333"      # gris oscuro (hover/seleccion)
+ACCENT_DARK  = "#ffffff"      # blanco puro (hover boton primario)
+TEXT_DARK    = "#f0f0f0"      # texto principal casi blanco
+TEXT_MID     = "#cccccc"      # texto medio gris claro
+TEXT_GREY    = "#888888"      # gris neutro
+TEXT_DIM     = "#555555"      # gris tenue
+SUCCESS      = "#aaaaaa"      # gris claro (exito)
+WARNING      = "#999999"      # gris medio (advertencia)
+DANGER       = "#bbbbbb"      # gris (error)
+BORDER       = "#3a3a3a"      # borde gris oscuro
+
+FONT_HEAD    = ("Segoe UI", 13, "bold")
+FONT_BODY    = ("Segoe UI", 10)
+FONT_SMALL   = ("Segoe UI", 9)
+FONT_MONO    = ("Consolas", 9)
+FONT_BIG_BTN = ("Segoe UI", 12, "bold")
+FONT_LOGO    = ("Segoe UI", 17, "bold")
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  UTILIDADES CV2
+# ══════════════════════════════════════════════════════════════════════════════
+
+def pil_to_cv2(pil_img):
+    arr = np.array(pil_img.convert("RGB"))
+    return cv2.cvtColor(arr, cv2.COLOR_RGB2BGR)
+
+def cv2_to_pil(cv2_img):
+    rgb = cv2.cvtColor(cv2_img, cv2.COLOR_BGR2RGB)
+    return Image.fromarray(rgb)
+
+def order_points(pts):
+    rect = np.zeros((4, 2), dtype="float32")
+    s = pts.sum(axis=1)
+    rect[0] = pts[np.argmin(s)];  rect[2] = pts[np.argmax(s)]
+    diff = np.diff(pts, axis=1)
+    rect[1] = pts[np.argmin(diff)]; rect[3] = pts[np.argmax(diff)]
+    return rect
+
+def four_point_transform(image, pts):
+    rect = order_points(pts)
+    tl, tr, br, bl = rect
+    maxW = max(int(np.linalg.norm(br - bl)), int(np.linalg.norm(tr - tl)))
+    maxH = max(int(np.linalg.norm(tr - br)), int(np.linalg.norm(tl - bl)))
+    dst  = np.array([[0,0],[maxW-1,0],[maxW-1,maxH-1],[0,maxH-1]], dtype="float32")
+    M    = cv2.getPerspectiveTransform(rect, dst)
+    return cv2.warpPerspective(image, M, (maxW, maxH))
+
+def _crop_one(cv_img, cnt, w, h, margin=0):
+    peri   = cv2.arcLength(cnt, True)
+    approx = cv2.approxPolyDP(cnt, 0.02 * peri, True)
+    if len(approx) == 4:
+        pts = approx.reshape(4, 2).astype("float32")
+        return cv2_to_pil(four_point_transform(cv_img, pts))
+    x, y, bw, bh = cv2.boundingRect(cnt)
+    x1 = max(0, x - margin);  y1 = max(0, y - margin)
+    x2 = min(w, x + bw + margin); y2 = min(h, y + bh + margin)
+    return cv2_to_pil(cv_img[y1:y2, x1:x2])
+
+def auto_white_balance(pil_img):
+    """
+    Corrección de balance de blancos percentil.
+    Elimina el tono gris/amarillo/azulado del cristal del escáner.
+    """
+    arr = np.array(pil_img.convert("RGB")).astype(np.float32)
+    for ch in range(3):
+        lo = np.percentile(arr[:, :, ch], 0.5)
+        hi = np.percentile(arr[:, :, ch], 99.5)
+        rng = max(hi - lo, 1.0)
+        arr[:, :, ch] = np.clip((arr[:, :, ch] - lo) / rng * 255.0, 0, 255)
+    return Image.fromarray(arr.astype(np.uint8))
+
+def enhance_scanned_photo(pil_img,
+                          do_white_balance=True,
+                          do_auto_contrast=True,
+                          do_sharpen=True,
+                          do_denoise=False):
+    """
+    Pipeline de mejora de calidad equivalente al escáner de Windows / impresoras HP:
+      1. Balance de blancos  → elimina tono del cristal
+      2. Autocontraste       → niveles automáticos (sombras/luces)
+      3. Nitidez (unsharp)   → igual que el modo 'Texto y fotos' del driver
+      4. Reducción de ruido  → opcional, para 150 DPI
+    Devuelve una copia mejorada; nunca modifica el original.
+    """
+    img = pil_img.copy().convert("RGB")
+
+    # ── 1. Balance de blancos ─────────────────────────────────────────────────
+    if do_white_balance and CV2_AVAILABLE:
+        img = auto_white_balance(img)
+
+    # ── 2. Autocontraste (niveles) ────────────────────────────────────────────
+    if do_auto_contrast:
+        img = ImageOps.autocontrast(img, cutoff=0.5)
+
+    # ── 3. Nitidez (Unsharp Mask) ─────────────────────────────────────────────
+    #   radius=1.5, percent=140, threshold=3  →  similar al perfil "Fotos" de WIA
+    if do_sharpen:
+        img = img.filter(ImageFilter.UnsharpMask(radius=1.5, percent=140, threshold=3))
+
+    # ── 4. Reducción de ruido suave (opcional) ────────────────────────────────
+    if do_denoise:
+        img = img.filter(ImageFilter.MedianFilter(size=3))
+
+    return img
+
+def auto_crop_n_photos(pil_img, n_expected=1, margin_px=0):
+    """
+    Detecta hasta n_expected fotografías en el folio y las devuelve como lista.
+    Devuelve ([PIL, ...], mensaje_str)
+    """
+    if not CV2_AVAILABLE:
+        return [pil_img], "OpenCV no disponible — sin recorte automático"
+
+    cv_img = pil_to_cv2(pil_img)
+    h, w   = cv_img.shape[:2]
+    total  = h * w
+
+    gray  = cv2.cvtColor(cv_img, cv2.COLOR_BGR2GRAY)
+    blur  = cv2.GaussianBlur(gray, (5, 5), 0)
+    _, thresh = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 15))
+    closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
+
+    cnts, _ = cv2.findContours(closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not cnts:
+        return [pil_img], "No se encontraron objetos — imagen original"
+
+    # Máx. área por foto: si hay 5 fotos en un A4, cada una ocupa ~20% máx
+    max_area_ratio = min(0.90, 1.0 / max(n_expected - 0.5, 1) + 0.1)
+    valid = [c for c in cnts
+             if total * 0.03 < cv2.contourArea(c) < total * max_area_ratio]
+    valid.sort(key=cv2.contourArea, reverse=True)
+    valid = valid[:n_expected]  # tomar solo las n más grandes
+
+    if not valid:
+        return [pil_img], "No se detectaron fotos — imagen original"
+
+    results = [_crop_one(cv_img, c, w, h, margin_px) for c in valid]
+    n = len(results)
+    msg = f"✓ {n} foto{'s' if n>1 else ''} detectada{'s' if n>1 else ''} y recortada{'s' if n>1 else ''}"
+    return results, msg
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  WIA
+# ══════════════════════════════════════════════════════════════════════════════
+
+def get_wia_scanners():
+    try:
+        import win32com.client, pythoncom
+        pythoncom.CoInitialize()
+        try:
+            wia = win32com.client.Dispatch("WIA.DeviceManager")
+            devices = []
+            for info in wia.DeviceInfos:
+                if info.Type == 1:
+                    devices.append((info.Properties("Name").Value, info.DeviceID))
+            return devices
+        finally:
+            pythoncom.CoUninitialize()
+    except Exception:
+        return []
+
+def scan_with_wia(device_id=None, dpi=300, color_mode="Color"):
+    import win32com.client, tempfile, pythoncom
+    pythoncom.CoInitialize()
+    try:
+        wia = win32com.client.Dispatch("WIA.DeviceManager")
+        device_info = None
+        for info in wia.DeviceInfos:
+            if info.Type == 1:
+                if device_id is None or info.DeviceID == device_id:
+                    device_info = info
+                    break
+        if device_info is None:
+            raise RuntimeError("No se encontró ningún escáner WIA conectado.")
+        device = device_info.Connect()
+        item   = device.Items(1)
+        color_map = {"Color": 4, "Grayscale": 2, "BlackWhite": 1}
+        def set_prop(it, pid, val):
+            try: it.Properties(pid).Value = val
+            except Exception: pass
+        set_prop(item, 6147, dpi)
+        set_prop(item, 6148, dpi)
+        set_prop(item, 4103, color_map.get(color_mode, 4))
+        img_file = item.Transfer("{B96B3CAB-0728-11D3-9D7B-0000F81EF32E}")
+        tmp = tempfile.mktemp(suffix=".png")
+        img_file.SaveFile(tmp)
+        pil_img = Image.open(tmp).copy()
+        os.remove(tmp)
+        return pil_img
+    finally:
+        pythoncom.CoUninitialize()
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  TOOLTIP
+# ══════════════════════════════════════════════════════════════════════════════
+
+class Tooltip:
+    def __init__(self, widget, text):
+        self.widget = widget; self.text = text; self.tip = None
+        widget.bind("<Enter>", self.show); widget.bind("<Leave>", self.hide)
+    def show(self, _=None):
+        x = self.widget.winfo_rootx() + 30
+        y = self.widget.winfo_rooty() + self.widget.winfo_height() + 4
+        self.tip = tk.Toplevel(self.widget)
+        self.tip.wm_overrideredirect(True)
+        self.tip.wm_geometry(f"+{x}+{y}")
+        tk.Label(self.tip, text=self.text, bg=ACCENT, fg="white",
+                 font=FONT_SMALL, padx=8, pady=4, relief="flat").pack()
+    def hide(self, _=None):
+        if self.tip: self.tip.destroy(); self.tip = None
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  WIDGET AUXILIAR: RoundedFrame (canvas con bordes redondeados)
+# ══════════════════════════════════════════════════════════════════════════════
+
+def rounded_rect(canvas, x1, y1, x2, y2, r, **kwargs):
+    """Dibuja un rectángulo con esquinas redondeadas en un Canvas."""
+    points = [
+        x1+r, y1,  x2-r, y1,
+        x2, y1,    x2, y1+r,
+        x2, y2-r,  x2, y2,
+        x2-r, y2,  x1+r, y2,
+        x1, y2,    x1, y2-r,
+        x1, y1+r,  x1, y1,
+    ]
+    return canvas.create_polygon(points, smooth=True, **kwargs)
+
+
+class Card(tk.Frame):
+    """Frame con borde redondeado simulado mediante padding y color."""
+    def __init__(self, parent, radius=10, bg=BG_CARD, border_color=BORDER,
+                 border_width=2, **kwargs):
+        # Outer frame actúa de borde
+        outer = tk.Frame(parent, bg=border_color,
+                         padx=border_width, pady=border_width)
+        super().__init__(outer, bg=bg, **kwargs)
+        self._outer = outer
+        self.pack(fill="both", expand=True)
+
+    def grid(self, **kwargs):
+        self._outer.grid(**kwargs)
+
+    def pack(self, **kwargs):
+        # Solo para el inner frame dentro del outer
+        super().pack(**kwargs)
+
+    def grid_outer(self, **kwargs):
+        self._outer.grid(**kwargs)
+
+    def pack_outer(self, **kwargs):
+        self._outer.pack(**kwargs)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  APP PRINCIPAL
+# ══════════════════════════════════════════════════════════════════════════════
+
+MAX_PHOTOS = 5
+
+class EscanApp(tk.Tk):
+    def __init__(self):
+        super().__init__()
+        self.title("EscanApp")
+        self.geometry("1400x800")
+        self.minsize(1100, 650)
+        self.configure(bg=BG_MAIN)
+
+        # Estado por foto (índices 0..MAX_PHOTOS-1)
+        self.scanned_raw  = None
+        self.photos       = [None] * MAX_PHOTOS   # PIL images
+        self.tk_images    = [None] * MAX_PHOTOS   # ImageTk refs
+        self.zoom_levels  = [1.0]  * MAX_PHOTOS
+        self.canvases     = [None] * MAX_PHOTOS
+        self.info_labels  = [None] * MAX_PHOTOS
+        self.save_btns    = [None] * MAX_PHOTOS
+
+        self.scan_history = []
+        self.history_idx  = -1
+        self.scanner_list = []
+
+        self.scan_var_dpi      = tk.IntVar(value=300)
+        self.scan_var_color    = tk.StringVar(value="Color")
+        self.scan_var_device   = tk.StringVar(value="")
+        self.scan_var_autocrop = tk.BooleanVar(value=True)
+        self.scan_var_nfotos   = tk.IntVar(value=2)   # ← nº de fotos
+        self.status_text       = tk.StringVar(value="Listo para escanear")
+
+        # ── Variables de mejora de imagen ──────────────────────────────────────
+        self.scan_var_enhance_wb   = tk.BooleanVar(value=True)   # balance blancos
+        self.scan_var_enhance_ac   = tk.BooleanVar(value=True)   # autocontraste
+        self.scan_var_enhance_sh   = tk.BooleanVar(value=True)   # nitidez
+        self.scan_var_enhance_dn   = tk.BooleanVar(value=False)  # reducir ruido
+
+        if not PIL_AVAILABLE:
+            messagebox.showerror("Error", "Instala Pillow:\npip install Pillow")
+            self.destroy(); return
+
+        self._build_ui()
+        self._refresh_scanners()
+        self._animate_dot()
+
+    # ── Layout principal ──────────────────────────────────────────────────────
+    def _build_ui(self):
+        self.columnconfigure(1, weight=1)
+        self.rowconfigure(0, weight=1)
+        self._build_sidebar()
+        self._build_main()
+        self._build_statusbar()
+
+    # ══════════════════════════════════════════════════════════════════════════
+    #  SIDEBAR
+    # ══════════════════════════════════════════════════════════════════════════
+    def _build_sidebar(self):
+        # ── Contenedor externo fijo ────────────────────────────────────────────
+        sb_outer = tk.Frame(self, bg=BG_SIDEBAR, width=285)
+        sb_outer.grid(row=0, column=0, sticky="nsew")
+        sb_outer.grid_propagate(False)
+        sb_outer.rowconfigure(1, weight=1)
+        sb_outer.columnconfigure(0, weight=1)
+
+        # ── Logo FIJO (fuera del scroll) ───────────────────────────────────────
+        logo_frame = tk.Frame(sb_outer, bg="#000000", pady=16)
+        logo_frame.grid(row=0, column=0, sticky="ew")
+        tk.Label(logo_frame, text="⬡  EscanApp",
+                 font=FONT_LOGO, bg="#000000", fg=TEXT_DARK
+                 ).pack()
+        tk.Label(logo_frame, text="Escaneo inteligente de fotos",
+                 font=("Segoe UI", 8), bg="#000000", fg=TEXT_DIM
+                 ).pack()
+
+        # ── Canvas scrollable ──────────────────────────────────────────────────
+        sb_canvas = tk.Canvas(sb_outer, bg=BG_SIDEBAR,
+                              highlightthickness=0, bd=0)
+        sb_canvas.grid(row=1, column=0, sticky="nsew")
+
+        sb_scroll = ttk.Scrollbar(sb_outer, orient="vertical",
+                                  command=sb_canvas.yview)
+        sb_scroll.grid(row=1, column=1, sticky="ns")
+        sb_canvas.configure(yscrollcommand=sb_scroll.set)
+
+        # Frame interior donde va todo el contenido del sidebar
+        sb = tk.Frame(sb_canvas, bg=BG_SIDEBAR)
+        sb_canvas.create_window((0, 0), window=sb, anchor="nw")
+        sb.columnconfigure(0, weight=1)
+
+        def _on_sb_configure(e):
+            sb_canvas.configure(scrollregion=sb_canvas.bbox("all"))
+            sb_canvas.itemconfig(1, width=sb_canvas.winfo_width())
+
+        sb.bind("<Configure>", _on_sb_configure)
+        sb_canvas.bind("<Configure>",
+                       lambda e: sb_canvas.itemconfig(1, width=e.width))
+
+        def _on_mousewheel(e):
+            sb_canvas.yview_scroll(int(-1 * (e.delta / 120)), "units")
+
+        sb_canvas.bind_all("<MouseWheel>", _on_mousewheel)
+
+        # ── Contenido del sidebar (en sb, que sí hace scroll) ─────────────────
+        r = 0
+        self._sep(sb, r); r += 1
+
+        # — Escáner —
+        self._sec(sb, r, "ESCANER"); r += 1
+        self.device_combo = ttk.Combobox(sb, textvariable=self.scan_var_device,
+                                         state="readonly", font=FONT_SMALL)
+        self.device_combo.grid(row=r, column=0, sticky="ew", padx=14, pady=(0,4))
+        r += 1
+        self._flat_btn(sb, r, "Actualizar lista",
+                       self._refresh_scanners, small=True)
+        r += 1
+        self._sep(sb, r); r += 1
+
+        # — Nº de fotos —
+        self._sec(sb, r, "FOTOS EN EL ESCANER"); r += 1
+
+        nf_card = tk.Frame(sb, bg=BG_CARD, bd=0,
+                           highlightthickness=1,
+                           highlightbackground=BORDER)
+        nf_card.grid(row=r, column=0, sticky="ew", padx=14, pady=(0,10))
+        nf_card.columnconfigure(0, weight=1)
+        r += 1
+
+        tk.Label(nf_card,
+                 text="Cuantas fotos hay encima\ndel cristal?",
+                 font=FONT_SMALL, bg=BG_CARD, fg=TEXT_DARK,
+                 justify="left", padx=10, pady=6
+                 ).grid(row=0, column=0, sticky="w")
+
+        btn_row = tk.Frame(nf_card, bg=BG_CARD, pady=4)
+        btn_row.grid(row=1, column=0, sticky="ew", padx=8, pady=(0,8))
+
+        self._nfotos_btns = []
+        for i in range(1, MAX_PHOTOS + 1):
+            b = tk.Radiobutton(
+                btn_row, text=str(i),
+                variable=self.scan_var_nfotos, value=i,
+                bg=BG_CARD, fg=TEXT_DARK,
+                selectcolor=ACCENT, activebackground=BG_CARD,
+                activeforeground=TEXT_DARK,
+                font=("Segoe UI", 11, "bold"),
+                indicator=0, relief="flat",
+                padx=10, pady=6,
+                highlightthickness=0, cursor="hand2",
+                command=self._on_nfotos_change)
+            b.grid(row=0, column=i-1, padx=2)
+            btn_row.columnconfigure(i-1, weight=1)
+            self._nfotos_btns.append(b)
+
+        self._update_nfotos_colors()
+
+        self._sep(sb, r); r += 1
+
+        # — Resolución —
+        self._sec(sb, r, "RESOLUCION (DPI)"); r += 1
+        dpi_f = tk.Frame(sb, bg=BG_SIDEBAR)
+        dpi_f.grid(row=r, column=0, sticky="ew", padx=14, pady=(0,10))
+        dpi_f.columnconfigure((0,1,2), weight=1)
+        for i, d in enumerate([150, 300, 600]):
+            tk.Radiobutton(dpi_f, text=str(d), variable=self.scan_var_dpi,
+                           value=d, bg=BG_SIDEBAR, fg=TEXT_DARK,
+                           selectcolor=ACCENT_DIM,
+                           activebackground=BG_SIDEBAR,
+                           activeforeground=TEXT_DARK,
+                           font=FONT_SMALL, indicator=0, relief="flat",
+                           padx=6, pady=4, highlightthickness=0, cursor="hand2"
+                           ).grid(row=0, column=i, padx=2)
+        r += 1
+
+        # — Modo color —
+        self._sec(sb, r, "MODO DE COLOR"); r += 1
+        for mode, lbl in [("Color","Color"),
+                           ("Grayscale","Escala de grises"),
+                           ("BlackWhite","Blanco y negro")]:
+            tk.Radiobutton(sb, text=lbl, variable=self.scan_var_color,
+                           value=mode, bg=BG_SIDEBAR, fg=TEXT_DARK,
+                           selectcolor=ACCENT_DIM,
+                           activebackground=BG_SIDEBAR,
+                           activeforeground=TEXT_DARK,
+                           font=FONT_SMALL, anchor="w",
+                           highlightthickness=0, cursor="hand2"
+                           ).grid(row=r, column=0, sticky="ew", padx=20, pady=1)
+            r += 1
+        self._sep(sb, r); r += 1
+
+        # — Auto-recorte —
+        self._sec(sb, r, "AUTO-RECORTE"); r += 1
+        ac_card = tk.Frame(sb, bg=BG_CARD, bd=0,
+                           highlightthickness=1,
+                           highlightbackground=BORDER)
+        ac_card.grid(row=r, column=0, sticky="ew", padx=14, pady=(0,6))
+        ac_card.columnconfigure(0, weight=1)
+        r += 1
+
+        tr = tk.Frame(ac_card, bg=BG_CARD, pady=8)
+        tr.grid(row=0, column=0, sticky="ew", padx=10)
+        tr.columnconfigure(0, weight=1)
+        tk.Label(tr, text="Recorte automatico",
+                 font=FONT_SMALL, bg=BG_CARD, fg=TEXT_DARK, anchor="w"
+                 ).grid(row=0, column=0, sticky="w")
+        tk.Checkbutton(tr, variable=self.scan_var_autocrop,
+                       bg=BG_CARD, fg=ACCENT,
+                       selectcolor=ACCENT_DIM, activebackground=BG_CARD,
+                       cursor="hand2", onvalue=True, offvalue=False,
+                       command=self._on_crop_toggle
+                       ).grid(row=0, column=1, padx=4)
+        tk.Label(ac_card,
+                 text="Detecta cada foto y elimina\nel espacio blanco del folio.",
+                 font=("Segoe UI", 8), bg=BG_CARD, fg=TEXT_GREY,
+                 justify="left", padx=10, pady=0
+                 ).grid(row=1, column=0, sticky="w", pady=(0,8))
+
+        self.crop_now_btn = tk.Button(sb,
+            text="Recortar ahora",
+            font=FONT_SMALL, bg=ACCENT_LIGHT, fg=BG_MAIN,
+            activebackground=ACCENT, activeforeground=BG_MAIN,
+            relief="flat", bd=0, pady=7, cursor="hand2",
+            command=self._manual_crop, state="disabled")
+        self.crop_now_btn.grid(row=r, column=0, sticky="ew", padx=14, pady=(0,3))
+        r += 1
+
+        self.restore_btn = tk.Button(sb,
+            text="Restaurar original",
+            font=FONT_SMALL, bg=BG_CARD, fg=TEXT_GREY,
+            activebackground=ACCENT_DIM, activeforeground=TEXT_DARK,
+            relief="flat", bd=0, pady=7, cursor="hand2",
+            command=self._restore_original, state="disabled")
+        self.restore_btn.grid(row=r, column=0, sticky="ew", padx=14, pady=(0,10))
+        r += 1
+        self._sep(sb, r); r += 1
+
+        # — Mejora de imagen —
+        self._sec(sb, r, "MEJORA DE IMAGEN"); r += 1
+        enh_card = tk.Frame(sb, bg=BG_CARD, bd=0,
+                            highlightthickness=1,
+                            highlightbackground=BORDER)
+        enh_card.grid(row=r, column=0, sticky="ew", padx=14, pady=(0,6))
+        enh_card.columnconfigure(0, weight=1)
+        r += 1
+
+        enh_opts = [
+            (self.scan_var_enhance_wb, "Balance de blancos",
+             "Elimina el tono gris/amarillo del cristal"),
+            (self.scan_var_enhance_ac, "Contraste automatico",
+             "Ajusta sombras y luces (niveles)"),
+            (self.scan_var_enhance_sh, "Nitidez (Unsharp Mask)",
+             "Definicion equivalente al driver de Windows"),
+            (self.scan_var_enhance_dn, "Reducir ruido",
+             "Util a 150 DPI; puede suavizar a 600 DPI"),
+        ]
+        for ei, (var, label, tip) in enumerate(enh_opts):
+            row_f = tk.Frame(enh_card, bg=BG_CARD)
+            row_f.grid(row=ei, column=0, sticky="ew", padx=10,
+                       pady=(6 if ei == 0 else 2, 2 if ei < 3 else 8))
+            row_f.columnconfigure(0, weight=1)
+            lbl = tk.Label(row_f, text=label,
+                           font=FONT_SMALL, bg=BG_CARD, fg=TEXT_DARK, anchor="w")
+            lbl.grid(row=0, column=0, sticky="w")
+            Tooltip(lbl, tip)
+            tk.Checkbutton(row_f, variable=var,
+                           bg=BG_CARD, fg=ACCENT,
+                           selectcolor=ACCENT_DIM, activebackground=BG_CARD,
+                           cursor="hand2"
+                           ).grid(row=0, column=1)
+
+        self._sep(sb, r); r += 1
+
+        # — Botón ESCANEAR —
+        scan_btn = tk.Button(sb,
+            text="ESCANEAR",
+            font=FONT_BIG_BTN, bg=ACCENT, fg=BG_MAIN,
+            activebackground=ACCENT_DARK, activeforeground=BG_MAIN,
+            relief="flat", bd=0, pady=15, cursor="hand2",
+            command=self._start_scan)
+        scan_btn.grid(row=r, column=0, sticky="ew", padx=14, pady=(0,6))
+        r += 1
+
+        # — Historial —
+        self._sec(sb, r, "HISTORIAL"); r += 1
+        hf = tk.Frame(sb, bg=BG_SIDEBAR)
+        hf.grid(row=r, column=0, sticky="ew", padx=14, pady=(0,14))
+        hf.columnconfigure((0,1), weight=1)
+        for col, (lbl, cmd) in enumerate([
+                ("<- Anterior", self._history_prev),
+                ("Siguiente ->", self._history_next)]):
+            tk.Button(hf, text=lbl, font=FONT_SMALL,
+                      bg=BG_CARD, fg=TEXT_GREY,
+                      activebackground=ACCENT_DIM, activeforeground=TEXT_DARK,
+                      relief="flat", bd=0, pady=6, cursor="hand2",
+                      command=cmd).grid(
+                          row=0, column=col,
+                          padx=(0,3) if col==0 else (3,0), sticky="ew")
+
+    def _on_nfotos_change(self):
+        self._update_nfotos_colors()
+        self._rebuild_photo_grid()
+
+    def _update_nfotos_colors(self):
+        n = self.scan_var_nfotos.get()
+        for i, b in enumerate(self._nfotos_btns):
+            if i + 1 == n:
+                b.config(bg=ACCENT, fg="white", selectcolor=ACCENT)
+            else:
+                b.config(bg=ACCENT_DIM, fg=TEXT_DARK, selectcolor=ACCENT_DIM)
+
+    def _sep(self, p, r, color=BORDER):
+        tk.Frame(p, bg=color, height=1
+                 ).grid(row=r, column=0, sticky="ew", padx=14, pady=(0,8))
+
+    def _sec(self, p, r, text):
+        tk.Label(p, text=text, font=("Segoe UI", 8, "bold"),
+                 bg=BG_SIDEBAR, fg=TEXT_GREY
+                 ).grid(row=r, column=0, sticky="w", padx=18, pady=(8,3))
+
+    def _flat_btn(self, parent, row, text, cmd, small=False):
+        b = tk.Button(parent, text=text,
+                      font=FONT_SMALL if small else FONT_BODY,
+                      bg=BG_CARD, fg=TEXT_GREY,
+                      activebackground=ACCENT_DIM, activeforeground=TEXT_DARK,
+                      relief="flat", bd=0, pady=6, cursor="hand2", command=cmd)
+        b.grid(row=row, column=0, sticky="ew", padx=14, pady=(0,8))
+        return b
+
+    # ══════════════════════════════════════════════════════════════════════════
+    #  PANEL CENTRAL
+    # ══════════════════════════════════════════════════════════════════════════
+    def _build_main(self):
+        self.main_frame = tk.Frame(self, bg=BG_MAIN)
+        self.main_frame.grid(row=0, column=1, sticky="nsew")
+        self.main_frame.rowconfigure(1, weight=1)
+        self.main_frame.columnconfigure(0, weight=1)
+
+        self._build_toolbar()
+        self._build_photo_grid_container()
+
+    def _build_toolbar(self):
+        tb = tk.Frame(self.main_frame, bg=BG_CARD, pady=8,
+                      highlightthickness=1, highlightbackground=BORDER)
+        tb.grid(row=0, column=0, sticky="ew", padx=0, pady=0)
+        self._toolbar = tb
+
+        def tb_btn(text, cmd, tip=None):
+            b = tk.Button(tb, text=text, font=("Segoe UI", 11),
+                          bg=BG_CARD, fg=TEXT_DARK,
+                          activebackground=ACCENT_DIM,
+                          activeforeground=ACCENT_DARK,
+                          relief="flat", bd=0, padx=10, pady=4,
+                          cursor="hand2", command=cmd)
+            b.pack(side="left", padx=2)
+            if tip: Tooltip(b, tip)
+            return b
+
+        tk.Label(tb, text="Zoom:", font=FONT_SMALL,
+                 bg=BG_CARD, fg=TEXT_GREY).pack(side="left", padx=(14,4))
+        tb_btn("−", self._zoom_out)
+        self.zoom_label = tk.Label(tb, text="100%", font=FONT_MONO,
+                                   bg=BG_CARD, fg=TEXT_DARK, width=5)
+        self.zoom_label.pack(side="left")
+        tb_btn("+", self._zoom_in)
+        tb_btn("⊡ Ajustar", self._zoom_fit)
+
+        tk.Frame(tb, bg=BORDER, width=1).pack(side="left", fill="y", padx=10, pady=4)
+        tb_btn("↺", lambda: self._rotate_all(-90), "Rotar todas izquierda")
+        tb_btn("↻", lambda: self._rotate_all(90),  "Rotar todas derecha")
+
+        # Info general
+        self.info_general = tk.Label(tb, text="", font=FONT_SMALL,
+                                     bg=BG_CARD, fg=TEXT_GREY)
+        self.info_general.pack(side="right", padx=14)
+
+    def _build_photo_grid_container(self):
+        self.grid_container = tk.Frame(self.main_frame, bg=BG_MAIN)
+        self.grid_container.grid(row=1, column=0, sticky="nsew",
+                                 padx=12, pady=12)
+        self._rebuild_photo_grid()
+
+    def _rebuild_photo_grid(self):
+        """Destruye y reconstruye la cuadrícula de paneles de foto."""
+        for w in self.grid_container.winfo_children():
+            w.destroy()
+
+        n = self.scan_var_nfotos.get()
+
+        # Calcular layout: máx 3 columnas
+        if n == 1:
+            cols, rows = 1, 1
+        elif n == 2:
+            cols, rows = 2, 1
+        elif n == 3:
+            cols, rows = 3, 1
+        elif n == 4:
+            cols, rows = 2, 2
+        else:  # 5
+            cols, rows = 3, 2   # 3 arriba, 2 abajo centradas
+
+        for c in range(cols):
+            self.grid_container.columnconfigure(c, weight=1)
+        for r in range(rows):
+            self.grid_container.rowconfigure(r, weight=1)
+
+        # Resetear canvases
+        self.canvases    = [None] * MAX_PHOTOS
+        self.info_labels = [None] * MAX_PHOTOS
+        self.save_btns   = [None] * MAX_PHOTOS
+
+        for idx in range(n):
+            col = idx % cols
+            row = idx // cols
+
+            # Para n=5, la última fila tiene 2 celdas → centrar
+            if n == 5 and row == 1:
+                # Usar columnspan y columna de inicio para centrar 2 en 3
+                col_start = [0, 1][idx - 3]   # índice 3→col0, 4→col1... centrar
+                col_start = idx - 3            # 0,1
+                # centrar: empieza en col 0 para idx=3, col=1 para idx=4... no, pon en col 0 y 2
+                col_start = [0, 2][idx - 3]
+            else:
+                col_start = col
+
+            self._make_photo_panel(idx, row, col_start)
+
+    def _make_photo_panel(self, idx, row, col):
+        """Crea un panel con canvas y botones para la foto idx."""
+        n_label = idx + 1
+
+        outer = tk.Frame(self.grid_container, bg=BORDER, padx=1, pady=1)
+        outer.grid(row=row, column=col, sticky="nsew", padx=5, pady=5)
+        outer.columnconfigure(0, weight=1)
+        outer.rowconfigure(1, weight=1)
+
+        inner = tk.Frame(outer, bg=BG_CARD)
+        inner.pack(fill="both", expand=True)
+        inner.columnconfigure(0, weight=1)
+        inner.rowconfigure(1, weight=1)
+
+        # Cabecera
+        hdr = tk.Frame(inner, bg=ACCENT_DIM, pady=5)
+        hdr.grid(row=0, column=0, columnspan=2, sticky="ew")
+        hdr.columnconfigure(0, weight=1)
+        tk.Label(hdr, text=f"FOTO {n_label}",
+                 font=("Segoe UI", 9, "bold"),
+                 bg=ACCENT_DIM, fg=TEXT_DARK, anchor="w", padx=10
+                 ).grid(row=0, column=0, sticky="w")
+        info = tk.Label(hdr, text="Sin imagen", font=FONT_SMALL,
+                        bg=ACCENT_DIM, fg=TEXT_GREY, anchor="e", padx=10)
+        info.grid(row=0, column=1, sticky="e")
+        self.info_labels[idx] = info
+
+        # Canvas
+        cv = tk.Canvas(inner, bg=BG_CANVAS,
+                       highlightthickness=0, cursor="crosshair")
+        cv.grid(row=1, column=0, sticky="nsew")
+        vb = ttk.Scrollbar(inner, orient="vertical",   command=cv.yview)
+        vb.grid(row=1, column=1, sticky="ns")
+        hb = ttk.Scrollbar(inner, orient="horizontal", command=cv.xview)
+        hb.grid(row=2, column=0, sticky="ew")
+        cv.configure(yscrollcommand=vb.set, xscrollcommand=hb.set)
+        cv.bind("<Configure>", lambda e, i=idx: self._on_resize(i))
+        self.canvases[idx] = cv
+
+        # Botón guardar
+        sb_btn = tk.Button(inner,
+            text=f"Guardar Foto {n_label}",
+            font=FONT_BODY, bg=BG_CARD, fg=TEXT_DARK,
+            activebackground=ACCENT_DIM, activeforeground=ACCENT_DARK,
+            relief="flat", bd=0, pady=7, cursor="hand2",
+            command=lambda i=idx: self._save_image(i),
+            state="disabled")
+        sb_btn.grid(row=3, column=0, columnspan=2, sticky="ew")
+        self.save_btns[idx] = sb_btn
+
+        self._draw_placeholder(idx)
+
+    # ── Status bar ────────────────────────────────────────────────────────────
+    def _build_statusbar(self):
+        bar = tk.Frame(self, bg="#000000", pady=6)
+        bar.grid(row=1, column=0, columnspan=2, sticky="ew")
+        bar.columnconfigure(1, weight=1)
+        self.dot_lbl = tk.Label(bar, text="●", font=FONT_SMALL,
+                                bg="#000000", fg=BORDER)
+        self.dot_lbl.grid(row=0, column=0, padx=(14,4))
+        tk.Label(bar, textvariable=self.status_text, font=FONT_SMALL,
+                 bg="#000000", fg=TEXT_DARK, anchor="w"
+                 ).grid(row=0, column=1, sticky="ew")
+        self.progress = ttk.Progressbar(bar, mode="indeterminate", length=120)
+        self.progress.grid(row=0, column=2, padx=14)
+
+    # ══════════════════════════════════════════════════════════════════════════
+    #  ESCANEO
+    # ══════════════════════════════════════════════════════════════════════════
+    def _refresh_scanners(self):
+        self.scanner_list = get_wia_scanners()
+        names = [n for n, _ in self.scanner_list]
+        self.device_combo["values"] = names or ["(ningún escáner detectado)"]
+        if names:
+            self.scan_var_device.set(names[0])
+            self.status_text.set(f"Escáner encontrado: {names[0]}")
+        else:
+            self.scan_var_device.set("(ningún escáner detectado)")
+            self.status_text.set("No se detectó ningún escáner WIA")
+
+    def _start_scan(self):
+        if not self.scanner_list:
+            messagebox.showwarning("Sin escáner",
+                "Comprueba que el escáner está encendido y pulsa 'Actualizar lista'.")
+            return
+        self.status_text.set("Escaneando…")
+        self.progress.start(10)
+        threading.Thread(target=self._do_scan, daemon=True).start()
+
+    def _do_scan(self):
+        try:
+            sel = self.scan_var_device.get()
+            did = next((d for n, d in self.scanner_list if n == sel), None)
+            img = scan_with_wia(device_id=did,
+                                dpi=self.scan_var_dpi.get(),
+                                color_mode=self.scan_var_color.get())
+            self.after(0, self._scan_done, img)
+        except Exception as e:
+            self.after(0, self._scan_error, str(e))
+
+    def _scan_done(self, img):
+        self.progress.stop()
+        self.scanned_raw = img
+        ts   = datetime.now().strftime("%H:%M:%S")
+        dpi  = self.scan_var_dpi.get()
+        mode = self.scan_var_color.get()
+        n    = self.scan_var_nfotos.get()
+
+        if self.scan_var_autocrop.get():
+            self.status_text.set(f"Detectando {n} foto(s) y recortando…")
+            photos, msg = auto_crop_n_photos(img, n_expected=n)
+        else:
+            photos = [img] + [None] * (n - 1)
+            msg    = "✓ Escaneo completado"
+
+        # ── Mejora de imagen (pipeline calidad escáner profesional) ───────────
+        do_wb = self.scan_var_enhance_wb.get()
+        do_ac = self.scan_var_enhance_ac.get()
+        do_sh = self.scan_var_enhance_sh.get()
+        do_dn = self.scan_var_enhance_dn.get()
+        if do_wb or do_ac or do_sh or do_dn:
+            enhanced = []
+            for ph in photos:
+                if ph is not None:
+                    enhanced.append(enhance_scanned_photo(
+                        ph,
+                        do_white_balance=do_wb,
+                        do_auto_contrast=do_ac,
+                        do_sharpen=do_sh,
+                        do_denoise=do_dn))
+                else:
+                    enhanced.append(None)
+            photos = enhanced
+
+        # Rellenar con None si hay menos fotos que slots
+        while len(photos) < n:
+            photos.append(None)
+
+        # Asignar
+        for i in range(MAX_PHOTOS):
+            self.photos[i] = photos[i] if i < len(photos) else None
+
+        # Actualizar UI
+        for i in range(n):
+            img_i = self.photos[i]
+            if img_i:
+                w, h = img_i.size
+                self.info_labels[i].config(
+                    text=f"{w}×{h}px · {dpi}DPI · {ts}", fg=SUCCESS)
+                self.save_btns[i].config(state="normal")
+                self.zoom_levels[i] = 1.0
+                self._zoom_fit_one(i)
+            else:
+                self.info_labels[i].config(text="No detectada", fg=WARNING)
+                self._draw_placeholder(i)
+
+        self.scan_history.append(list(self.photos))
+        self.history_idx = len(self.scan_history) - 1
+        self.status_text.set(msg)
+        self.crop_now_btn.config(state="normal")
+        self.restore_btn.config(state="normal")
+        self.info_general.config(
+            text=f"Escaneo {datetime.now().strftime('%H:%M:%S')}  ·  {n} foto(s)  ·  {dpi} DPI")
+
+    def _scan_error(self, msg):
+        self.progress.stop()
+        self.status_text.set("Error al escanear")
+        messagebox.showerror("Error de escaneo",
+            f"No se pudo completar el escaneo:\n\n{msg}\n\n"
+            "Comprueba que el escáner está listo.")
+
+    # ══════════════════════════════════════════════════════════════════════════
+    #  RECORTE
+    # ══════════════════════════════════════════════════════════════════════════
+    def _on_crop_toggle(self):
+        if not CV2_AVAILABLE and self.scan_var_autocrop.get():
+            messagebox.showwarning("OpenCV no instalado",
+                "pip install opencv-python numpy\n\nEl recorte se ha desactivado.")
+            self.scan_var_autocrop.set(False)
+
+    def _manual_crop(self):
+        if not self.scanned_raw: return
+        if not CV2_AVAILABLE:
+            messagebox.showwarning("OpenCV no instalado", "pip install opencv-python numpy")
+            return
+        n = self.scan_var_nfotos.get()
+        self.status_text.set("Recortando…")
+        def _do():
+            photos, msg = auto_crop_n_photos(self.scanned_raw, n_expected=n)
+            self.after(0, self._crop_done, photos, msg)
+        threading.Thread(target=_do, daemon=True).start()
+
+    def _crop_done(self, photos, msg):
+        # ── Mejora de imagen tras recorte manual ──────────────────────────────
+        do_wb = self.scan_var_enhance_wb.get()
+        do_ac = self.scan_var_enhance_ac.get()
+        do_sh = self.scan_var_enhance_sh.get()
+        do_dn = self.scan_var_enhance_dn.get()
+        if do_wb or do_ac or do_sh or do_dn:
+            photos = [
+                enhance_scanned_photo(ph,
+                    do_white_balance=do_wb,
+                    do_auto_contrast=do_ac,
+                    do_sharpen=do_sh,
+                    do_denoise=do_dn)
+                if ph is not None else None
+                for ph in photos
+            ]
+        for i in range(MAX_PHOTOS):
+            self.photos[i] = photos[i] if i < len(photos) else None
+        n = self.scan_var_nfotos.get()
+        for i in range(n):
+            img_i = self.photos[i]
+            if img_i:
+                w, h = img_i.size
+                self.info_labels[i].config(text=f"{w}×{h}px (recortada)", fg=SUCCESS)
+                self.save_btns[i].config(state="normal")
+                self.zoom_levels[i] = 1.0
+                self._zoom_fit_one(i)
+            else:
+                self.info_labels[i].config(text="No detectada", fg=WARNING)
+                self._draw_placeholder(i)
+        self.status_text.set(msg)
+
+    def _restore_original(self):
+        if not self.scanned_raw: return
+        raw = self.scanned_raw
+        for i in range(MAX_PHOTOS):
+            self.photos[i] = None
+        self.photos[0] = raw
+        n = self.scan_var_nfotos.get()
+        w, h = raw.size
+        self.info_labels[0].config(text=f"{w}×{h}px (original)", fg=WARNING)
+        self.zoom_levels[0] = 1.0
+        self._zoom_fit_one(0)
+        for i in range(1, n):
+            self.info_labels[i].config(text="Sin imagen", fg=TEXT_GREY)
+            self._draw_placeholder(i)
+        self.status_text.set("Imagen original restaurada")
+
+    # ══════════════════════════════════════════════════════════════════════════
+    #  CANVAS / ZOOM
+    # ══════════════════════════════════════════════════════════════════════════
+    def _draw_placeholder(self, idx):
+        cv = self.canvases[idx]
+        if cv is None: return
+        cv.delete("all")
+        w  = cv.winfo_width()  or 300
+        h  = cv.winfo_height() or 200
+        cx, cy = w // 2, h // 2
+        # Fondo de puntos suaves
+        for x in range(0, w, 24):
+            for y in range(0, h, 24):
+                cv.create_oval(x-1, y-1, x+1, y+1, fill=ACCENT_DIM, outline="")
+        cv.create_text(cx, cy - 22, text="⬡",
+                       font=("Segoe UI", 36), fill=ACCENT_LIGHT)
+        cv.create_text(cx, cy + 16,
+                       text=f"Foto {idx+1} aparecerá aquí",
+                       font=("Segoe UI", 10), fill=TEXT_DIM)
+
+    def _on_resize(self, idx):
+        if self.photos[idx]:
+            self._show_image(idx)
+        else:
+            self._draw_placeholder(idx)
+
+    def _show_image(self, idx):
+        img = self.photos[idx]
+        cv  = self.canvases[idx]
+        if not img or cv is None: return
+        zl  = self.zoom_levels[idx]
+        ow, oh = img.size
+        nw = max(1, int(ow * zl))
+        nh = max(1, int(oh * zl))
+        resized = img.resize((nw, nh), Image.LANCZOS)
+        tk_img  = ImageTk.PhotoImage(resized)
+        self.tk_images[idx] = tk_img  # mantener referencia
+        cv.delete("all")
+        cv.config(scrollregion=(0, 0, nw, nh))
+        cw = cv.winfo_width();  ch = cv.winfo_height()
+        x  = max(nw // 2, cw // 2);  y  = max(nh // 2, ch // 2)
+        cv.create_image(x, y, image=tk_img, anchor="center")
+        self.zoom_label.config(text=f"{int(zl*100)}%")
+
+    def _zoom_fit_one(self, idx):
+        img = self.photos[idx]
+        cv  = self.canvases[idx]
+        if not img or cv is None: return
+        self.update_idletasks()
+        cw = cv.winfo_width();  ch = cv.winfo_height()
+        iw, ih = img.size
+        if iw and ih and cw > 1 and ch > 1:
+            self.zoom_levels[idx] = min((cw - 10) / iw, (ch - 10) / ih, 1.0)
+            self._show_image(idx)
+
+    def _zoom_fit(self):
+        n = self.scan_var_nfotos.get()
+        for i in range(n):
+            self._zoom_fit_one(i)
+
+    def _zoom_in(self):
+        n = self.scan_var_nfotos.get()
+        for i in range(n):
+            if self.photos[i]:
+                self.zoom_levels[i] = min(self.zoom_levels[i] * 1.25, 8.0)
+                self._show_image(i)
+
+    def _zoom_out(self):
+        n = self.scan_var_nfotos.get()
+        for i in range(n):
+            if self.photos[i]:
+                self.zoom_levels[i] = max(self.zoom_levels[i] / 1.25, 0.05)
+                self._show_image(i)
+
+    def _rotate_all(self, deg):
+        n = self.scan_var_nfotos.get()
+        for i in range(n):
+            if self.photos[i]:
+                self.photos[i] = self.photos[i].rotate(-deg, expand=True)
+                self._show_image(i)
+
+    # ══════════════════════════════════════════════════════════════════════════
+    #  HISTORIAL
+    # ══════════════════════════════════════════════════════════════════════════
+    def _history_prev(self):
+        if self.history_idx > 0:
+            self.history_idx -= 1; self._load_history()
+
+    def _history_next(self):
+        if self.history_idx < len(self.scan_history) - 1:
+            self.history_idx += 1; self._load_history()
+
+    def _load_history(self):
+        snap = self.scan_history[self.history_idx]
+        for i in range(MAX_PHOTOS):
+            self.photos[i] = snap[i] if i < len(snap) else None
+        n = self.scan_var_nfotos.get()
+        for i in range(n):
+            if self.photos[i]:
+                self._zoom_fit_one(i)
+            else:
+                self._draw_placeholder(i)
+        self.status_text.set(
+            f"Historial {self.history_idx+1}/{len(self.scan_history)}")
+
+    # ══════════════════════════════════════════════════════════════════════════
+    #  GUARDAR
+    # ══════════════════════════════════════════════════════════════════════════
+    def _save_image(self, idx):
+        img = self.photos[idx]
+        if not img:
+            messagebox.showinfo("Sin imagen", f"No hay imagen en Foto {idx+1}.")
+            return
+        ts   = datetime.now().strftime("%Y%m%d_%H%M%S")
+        path = filedialog.asksaveasfilename(
+            defaultextension=".jpg",
+            filetypes=[("JPEG","*.jpg"),("PNG","*.png"),
+                       ("PDF","*.pdf"),("TIFF","*.tiff")],
+            initialfile=f"foto{idx+1}_{ts}",
+            title=f"Guardar Foto {idx+1}")
+        if not path: return
+        ext = Path(path).suffix.lower()
+        dpi_val = self.scan_var_dpi.get()
+        if ext in (".jpg",".jpeg"):
+            img.convert("RGB").save(
+                path, "JPEG",
+                quality=98,
+                dpi=(dpi_val, dpi_val),
+                optimize=True,
+                subsampling=0)          # 4:4:4 → máxima fidelidad de color
+        elif ext == ".pdf":
+            img.convert("RGB").save(path, "PDF",
+                                    resolution=dpi_val)
+        elif ext == ".tiff":
+            img.save(path, "TIFF",
+                     dpi=(dpi_val, dpi_val),
+                     compression="tiff_lzw")
+        else:  # PNG
+            img.save(path, "PNG",
+                     dpi=(dpi_val, dpi_val))
+        self.status_text.set(f"✓ Foto {idx+1} guardada: {Path(path).name}")
+        messagebox.showinfo("Guardado", f"Foto {idx+1} guardada en:\n{path}")
+
+    # ══════════════════════════════════════════════════════════════════════════
+    #  ANIMACIÓN DOT
+    # ══════════════════════════════════════════════════════════════════════════
+    def _animate_dot(self):
+        colors = [BG_MAIN, BORDER, ACCENT_LIGHT]
+        c = getattr(self, "_dot_c", 0)
+        st = self.status_text.get()
+        if "Listo" in st or "✓" in st:
+            self.dot_lbl.config(fg=colors[c % len(colors)])
+            self._dot_c = c + 1
+        self.after(900, self._animate_dot)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+def main():
+    app = EscanApp()
+    app.mainloop()
+
+if __name__ == "__main__":
+    main()

escaner_app-1.0.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "escaner-app"           # nombre con el que se instala: pip install escaner-app
+version = "1.0.0"
+description = "Aplicación de escaneo de fotos con auto-recorte"
+requires-python = ">=3.9"
+dependencies = [
+    "Pillow",
+    "pywin32",
+    "opencv-python",
+    "numpy",
+]
+
+[project.scripts]
+escaner = "escaner.app:main"   # comando CMD → función main() en escaner/app.py
+
+[tool.hatch.build.targets.wheel]
+packages = ["escaner"]