Delete app.py

app.py

@@ -1,379 +0,0 @@
-"""
-Vektor-Studio — PNG/JPG zu SVG
-Saubere Linienführung für generierte Bilder.
-
-Hugging Face Space (Gradio SDK). Start lokal: python app.py
-"""
-
-import os
-import re
-import base64
-import tempfile
-import uuid
-
-import numpy as np
-from PIL import Image, ImageOps, ImageFilter
-import gradio as gr
-import vtracer
-
-MAX_SIDE = 2600          # Obergrenze nach dem Hochskalieren (Speed/Timeout-Schutz)
-OUT_DIR = os.path.join(tempfile.gettempdir(), "svg_out")
-os.makedirs(OUT_DIR, exist_ok=True)
-
-
-# --------------------------------------------------------------------------
-# Bildvorbereitung
-# --------------------------------------------------------------------------
-def flatten(img: Image.Image) -> Image.Image:
-    """Alpha auf Weiß legen, damit Transparenz nicht als Schwarz getract wird."""
-    img = ImageOps.exif_transpose(img)
-    if img.mode in ("RGBA", "LA", "P"):
-        img = img.convert("RGBA")
-        bg = Image.new("RGBA", img.size, (255, 255, 255, 255))
-        img = Image.alpha_composite(bg, img)
-    return img.convert("RGB")
-
-
-def otsu_threshold(arr: np.ndarray) -> int:
-    hist = np.bincount(arr.ravel(), minlength=256).astype(np.float64)
-    total = hist.sum()
-    omega = np.cumsum(hist) / total
-    mu = np.cumsum(hist * np.arange(256)) / total
-    mu_t = mu[-1]
-    denom = omega * (1.0 - omega)
-    denom[denom == 0] = 1e-12
-    sigma_b = (mu_t * omega - mu) ** 2 / denom
-    return int(np.argmax(sigma_b))
-
-
-def binarize(gray: Image.Image, method: str, level: int, block: int, offset: int) -> np.ndarray:
-    """Gibt eine Bool-Maske zurück: True = Tinte (Linie)."""
-    arr = np.asarray(gray, dtype=np.uint8)
-
-    if method == "Adaptiv (ungleiche Beleuchtung)":
-        radius = max(1, int(block) // 2)
-        local = np.asarray(gray.filter(ImageFilter.BoxBlur(radius)), dtype=np.int16)
-        return arr.astype(np.int16) < (local - int(offset))
-
-    if method == "Otsu (automatisch)":
-        level = otsu_threshold(arr)
-
-    return arr < int(level)
-
-
-def zhang_suen(mask: np.ndarray, max_iter: int = 60) -> np.ndarray:
-    """Skelettierung: reduziert jede Linie auf 1 px Mittellinie."""
-    img = mask.copy()
-    for _ in range(max_iter):
-        changed = False
-        for step in (0, 1):
-            P = np.pad(img, 1, constant_values=False)
-            P2, P3, P4 = P[:-2, 1:-1], P[:-2, 2:], P[1:-1, 2:]
-            P5, P6, P7 = P[2:, 2:], P[2:, 1:-1], P[2:, :-2]
-            P8, P9 = P[1:-1, :-2], P[:-2, :-2]
-
-            ring = [P2, P3, P4, P5, P6, P7, P8, P9, P2]
-            B = sum(x.astype(np.uint8) for x in ring[:8])
-            A = np.zeros(img.shape, np.uint8)
-            for i in range(8):
-                A += (~ring[i] & ring[i + 1]).astype(np.uint8)
-
-            base = img & (B >= 2) & (B <= 6) & (A == 1)
-            if step == 0:
-                cond = base & ~(P2 & P4 & P6) & ~(P4 & P6 & P8)
-            else:
-                cond = base & ~(P2 & P4 & P8) & ~(P2 & P6 & P8)
-
-            if cond.any():
-                img &= ~cond
-                changed = True
-        if not changed:
-            break
-    return img
-
-
-def set_stroke_width(mask: np.ndarray, width: int) -> np.ndarray:
-    """Skelett wieder auf eine gleichmäßige Strichstärke aufdicken."""
-    if width <= 1:
-        return mask
-    ink = Image.fromarray(np.where(mask, 255, 0).astype(np.uint8))
-    size = width if width % 2 == 1 else width + 1
-    ink = ink.filter(ImageFilter.MaxFilter(size))
-    return np.asarray(ink) > 127
-
-
-def cap_size(img: Image.Image) -> Image.Image:
-    w, h = img.size
-    if max(w, h) <= MAX_SIDE:
-        return img
-    s = MAX_SIDE / max(w, h)
-    return img.resize((max(1, int(w * s)), max(1, int(h * s))), Image.LANCZOS)
-
-
-# --------------------------------------------------------------------------
-# SVG-Nachbearbeitung
-# --------------------------------------------------------------------------
-def strip_background(svg: str) -> str:
-    """Entfernt fast-weiße Füllflächen (typisch: der Hintergrund im Farbmodus)."""
-    def is_light(hexcol: str) -> bool:
-        r, g, b = (int(hexcol[i:i + 2], 16) for i in (1, 3, 5))
-        return r > 243 and g > 243 and b > 243
-
-    return re.sub(
-        r'<path[^>]*fill="(#[0-9a-fA-F]{6})"[^>]*/>\s*',
-        lambda m: "" if is_light(m.group(1)) else m.group(0),
-        svg,
-    )
-
-
-def recolor(svg: str, color: str) -> str:
-    return re.sub(r'fill="#000000"', f'fill="{color}"', svg)
-
-
-def rescale_root(svg: str, out_w: int, out_h: int) -> str:
-    """viewBox ergänzen und die Anzeigegröße auf die Originalmaße setzen."""
-    m = re.search(r'<svg([^>]*)width="(\d+)"\s+height="(\d+)"', svg)
-    if not m:
-        return svg
-    vw, vh = m.group(2), m.group(3)
-    new_tag = (
-        f'<svg{m.group(1)}width="{out_w}" height="{out_h}" '
-        f'viewBox="0 0 {vw} {vh}"'
-    )
-    return svg[: m.start()] + new_tag + svg[m.end():]
-
-
-def preview_html(svg: str, label: str) -> str:
-    if len(svg) > 4_000_000:
-        return (
-            f"<div class='vs-note'>{label}: Die Datei ist sehr groß "
-            f"({len(svg) // 1024} KB) — bitte herunterladen statt hier ansehen. "
-            "Tipp: „Kleine Flecken filtern“ erhöhen.</div>"
-        )
-    b64 = base64.b64encode(svg.encode("utf-8")).decode("ascii")
-    return (
-        "<div class='vs-stage'>"
-        f"<img src='data:image/svg+xml;base64,{b64}' alt='{label}'/>"
-        "</div>"
-    )
-
-
-# --------------------------------------------------------------------------
-# Hauptfunktion
-# --------------------------------------------------------------------------
-def vectorize(
-    image,
-    mode,
-    invert,
-    thr_method,
-    thr_level,
-    block,
-    offset,
-    denoise,
-    upscale,
-    uniform,
-    stroke_w,
-    curve_mode,
-    speckle,
-    corner,
-    length_thr,
-    splice,
-    precision,
-    colors,
-    layer_diff,
-    hierarchical,
-    drop_bg,
-    line_color,
-    progress=gr.Progress(),
-):
-    if image is None:
-        raise gr.Error("Lade zuerst ein PNG oder JPG hoch.")
-
-    progress(0.1, desc="Bild vorbereiten")
-    src = flatten(image)
-    orig_w, orig_h = src.size
-
-    work = src
-    if upscale > 1:
-        work = work.resize(
-            (int(orig_w * upscale), int(orig_h * upscale)), Image.LANCZOS
-        )
-    work = cap_size(work)
-
-    line_mode = mode.startswith("Strich")
-
-    if line_mode:
-        progress(0.3, desc="Linien freistellen")
-        gray = ImageOps.autocontrast(work.convert("L"), cutoff=1)
-        if invert:
-            gray = ImageOps.invert(gray)
-        if denoise > 0:
-            gray = gray.filter(ImageFilter.MedianFilter(int(denoise) * 2 + 1))
-
-        mask = binarize(gray, thr_method, thr_level, block, offset)
-
-        if uniform:
-            progress(0.45, desc="Mittellinien berechnen")
-            mask = set_stroke_width(zhang_suen(mask), int(stroke_w))
-
-        prepped = Image.fromarray(np.where(mask, 0, 255).astype(np.uint8)).convert("RGB")
-    else:
-        progress(0.35, desc="Farbflächen reduzieren")
-        prepped = work
-        if denoise > 0:
-            prepped = prepped.filter(ImageFilter.MedianFilter(int(denoise) * 2 + 1))
-
-    stem = uuid.uuid4().hex[:10]
-    tmp_png = os.path.join(OUT_DIR, f"{stem}.png")
-    out_svg = os.path.join(OUT_DIR, "vektor.svg" if line_mode else "vektor-farbe.svg")
-    prepped.save(tmp_png)
-
-    progress(0.6, desc="Pfade tracen")
-    vtracer.convert_image_to_svg_py(
-        tmp_png,
-        out_svg,
-        colormode="binary" if line_mode else "color",
-        hierarchical="cutout" if hierarchical == "Ausgeschnitten" else "stacked",
-        mode="polygon" if curve_mode.startswith("Polygon") else "spline",
-        filter_speckle=int(speckle),
-        color_precision=int(colors),
-        layer_difference=int(layer_diff),
-        corner_threshold=int(corner),
-        length_threshold=float(length_thr),
-        max_iterations=10,
-        splice_threshold=int(splice),
-        path_precision=int(precision),
-    )
-
-    progress(0.85, desc="SVG aufräumen")
-    svg = open(out_svg, "r", encoding="utf-8").read()
-    if drop_bg:
-        svg = strip_background(svg)
-    if line_mode:
-        svg = recolor(svg, line_color)
-    svg = rescale_root(svg, orig_w, orig_h)
-
-    with open(out_svg, "w", encoding="utf-8") as f:
-        f.write(svg)
-    try:
-        os.remove(tmp_png)
-    except OSError:
-        pass
-
-    n_paths = svg.count("<path")
-    stats = (
-        f"**{n_paths} Pfade** · {len(svg) / 1024:.1f} KB · "
-        f"Zeichenfläche {orig_w}×{orig_h} px · getract bei {prepped.size[0]}×{prepped.size[1]} px"
-    )
-    return preview_html(svg, "Vektorergebnis"), out_svg, stats
-
-
-# --------------------------------------------------------------------------
-# Oberfläche
-# --------------------------------------------------------------------------
-CSS = """
-.vs-stage {
-  background-color: #f7f5f2;
-  background-image:
-    linear-gradient(45deg, #e6e2dc 25%, transparent 25%, transparent 75%, #e6e2dc 75%),
-    linear-gradient(45deg, #e6e2dc 25%, transparent 25%, transparent 75%, #e6e2dc 75%);
-  background-size: 18px 18px;
-  background-position: 0 0, 9px 9px;
-  border-radius: 10px; padding: 14px; min-height: 240px;
-  display: flex; align-items: center; justify-content: center;
-}
-.vs-stage img { max-width: 100%; max-height: 62vh; }
-.vs-note { padding: 18px; font-size: 0.9rem; line-height: 1.5; }
-footer { display: none !important; }
-"""
-
-# Gradio 6 erwartet theme/css in launch(), Gradio 5 im Blocks-Konstruktor.
-_MAJOR = int(gr.__version__.split(".")[0])
-_STYLE = {"theme": gr.themes.Soft(), "css": CSS}
-_BLOCKS_KW = {} if _MAJOR >= 6 else _STYLE
-_LAUNCH_KW = _STYLE if _MAJOR >= 6 else {}
-
-with gr.Blocks(title="PNG/JPG → SVG", **_BLOCKS_KW) as demo:
-    gr.Markdown(
-        "## PNG / JPG → SVG\n"
-        "Vektorisiert Bitmaps zu sauberen, skalierbaren Pfaden. "
-        "Für KI-generierte Zeichnungen, Logos und Skizzen."
-    )
-
-    with gr.Row():
-        # ---------------- linke Spalte: Eingabe + Regler ----------------
-        with gr.Column(scale=4):
-            image = gr.Image(label="Bild", type="pil", sources=["upload", "clipboard"],
-                             image_mode="RGBA", height=300)
-            mode = gr.Radio(
-                ["Strichzeichnung (Schwarzweiß)", "Farbig (Flächen)"],
-                value="Strichzeichnung (Schwarzweiß)",
-                label="Modus",
-            )
-            run = gr.Button("Vektorisieren", variant="primary")
-
-            with gr.Accordion("Linien freistellen", open=True) as line_box:
-                thr_method = gr.Radio(
-                    ["Otsu (automatisch)", "Global", "Adaptiv (ungleiche Beleuchtung)"],
-                    value="Otsu (automatisch)",
-                    label="Schwellenwert",
-                )
-                thr_level = gr.Slider(0, 255, 128, step=1, label="Grenzwert (nur Global)")
-                block = gr.Slider(5, 151, 41, step=2, label="Fensterbreite (nur Adaptiv)")
-                offset = gr.Slider(0, 40, 8, step=1, label="Empfindlichkeit (nur Adaptiv)")
-                invert = gr.Checkbox(False, label="Invertieren (helle Linien auf dunklem Grund)")
-                denoise = gr.Slider(0, 3, 1, step=1, label="Rauschen glätten")
-                upscale = gr.Slider(1, 4, 2, step=1,
-                                    label="Vorher hochskalieren (glattere Kurven)")
-                uniform = gr.Checkbox(
-                    False, label="Gleichmäßige Strichstärke (Mittellinie berechnen)"
-                )
-                stroke_w = gr.Slider(1, 9, 3, step=2, label="Strichstärke in px")
-
-            with gr.Accordion("Pfadqualität", open=False):
-                curve_mode = gr.Radio(
-                    ["Spline (weiche Kurven)", "Polygon (harte Kanten)"],
-                    value="Spline (weiche Kurven)", label="Kurventyp",
-                )
-                speckle = gr.Slider(0, 40, 6, step=1, label="Kleine Flecken filtern")
-                corner = gr.Slider(0, 180, 60, step=1, label="Eckenschwelle")
-                length_thr = gr.Slider(0.5, 10, 4, step=0.5, label="Kürzeste Segmentlänge")
-                splice = gr.Slider(0, 180, 45, step=1, label="Kurven verbinden")
-                precision = gr.Slider(1, 8, 4, step=1, label="Koordinatengenauigkeit")
-
-            with gr.Accordion("Farbe & Ausgabe", open=False):
-                colors = gr.Slider(1, 8, 6, step=1, label="Farbtiefe (nur Farbmodus)")
-                layer_diff = gr.Slider(0, 64, 16, step=1, label="Ebenenabstand (nur Farbmodus)")
-                hierarchical = gr.Radio(
-                    ["Gestapelt", "Ausgeschnitten"], value="Gestapelt", label="Ebenenaufbau"
-                )
-                drop_bg = gr.Checkbox(True, label="Weißen Hintergrund entfernen")
-                line_color = gr.ColorPicker("#111111", label="Linienfarbe")
-
-        # ---------------- rechte Spalte: Ergebnis ----------------
-        with gr.Column(scale=6):
-            preview = gr.HTML("<div class='vs-stage'><span class='vs-note'>"
-                              "Das Ergebnis erscheint hier.</span></div>",
-                              label="Vorschau")
-            stats = gr.Markdown("")
-            download = gr.File(label="SVG herunterladen", height=90)
-
-    gr.Markdown(
-        "**Für saubere Linien:** hochskalieren auf 2–3×, Spline-Kurven, Flecken-Filter "
-        "auf 6–12. Wirkt eine Zeichnung ausgefranst, hilft „Gleichmäßige Strichstärke“ — "
-        "das zieht jede Linie auf eine Mittelachse und zeichnet sie mit konstanter Breite neu."
-    )
-
-    def toggle(m):
-        return gr.update(open=m.startswith("Strich"))
-
-    mode.change(toggle, mode, line_box)
-
-    inputs = [image, mode, invert, thr_method, thr_level, block, offset, denoise,
-              upscale, uniform, stroke_w, curve_mode, speckle, corner, length_thr,
-              splice, precision, colors, layer_diff, hierarchical, drop_bg, line_color]
-
-    run.click(vectorize, inputs, [preview, download, stats])
-
-if __name__ == "__main__":
-    demo.queue(max_size=20).launch(**_LAUNCH_KW)