Update app.py

app.py

@@ -1,20 +1,22 @@
-# app.py
+# app.py (v2)
 # Neurale netwerken als tekenaars — ControlNet (scribble) demo
-# UI: teken links, AI maakt rechts de tekening af o.b.v. je prompt.
-# Tip: kies in Hugging Face Spaces een T4 GPU voor prettige snelheid.
+# Fixes:
+# - Gebruik gr.Image(tool="sketch", type="pil") i.p.v. Sketchpad (betere compatibiliteit met Gradio 4)
+# - Robuuste conversie van numpy/PIL naar RGBA
+# - Testknop "Voorbeeld-schets" om pipeline te verifiëren
+# - Kleinere default-steps voor snellere eerste run
 
 import os
 import random
 import numpy as np
-from typing import Optional, Tuple
+from typing import Optional
 
-from PIL import Image, ImageOps
+from PIL import Image, ImageDraw
 
 import gradio as gr
 
 import torch
 from diffusers import ControlNetModel, StableDiffusionControlNetPipeline
-from diffusers.utils import load_image
 
 
 MODEL_BASE = os.environ.get("SD_BASE_MODEL", "runwayml/stable-diffusion-v1-5")
@@ -23,7 +25,6 @@ MODEL_CN = os.environ.get("CN_SCRIBBLE_MODEL", "lllyasviel/sd-controlnet-scribbl
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 DTYPE = torch.float16 if DEVICE == "cuda" else torch.float32
 
-
 pipe: Optional[StableDiffusionControlNetPipeline] = None
 
 
@@ -36,7 +37,7 @@ def _lazy_load_pipeline():
         MODEL_BASE,
         controlnet=controlnet,
         torch_dtype=DTYPE,
-        safety_checker=None,  # Gradio heeft eigen NSFW waarschuwingen; demo is voor schetsen
+        safety_checker=None,
     )
     if DEVICE == "cuda":
         pipe.enable_model_cpu_offload()
@@ -45,78 +46,86 @@ def _lazy_load_pipeline():
     return pipe
 
 
-def rgba_to_scribble(img: Image.Image, stroke_color=(0, 0, 0)) -> Image.Image:
-    """
-    Zet een RGBA canvas om naar een wit canvas met zwarte lijnen (scribble) voor ControlNet.
-    - Converteer transparantie naar wit.
-    - Normaliseer naar 1024 x 1024 (vierkant) met padding, zodat aspect netjes blijft.
-    """
-    if img.mode != "RGBA":
-        img = img.convert("RGBA")
-
-    # Op transparante achtergrond tekenen → naar wit compositen
+def to_rgba(img):
+    """Accepteer PIL of numpy; geef RGBA terug."""
+    if img is None:
+        return None
+    if isinstance(img, np.ndarray):
+        # Gradio kan np.uint8 HxWxC teruggeven
+        if img.ndim == 2:
+            pil = Image.fromarray(img).convert("RGBA")
+        else:
+            pil = Image.fromarray(img.astype(np.uint8))
+            if pil.mode != "RGBA":
+                pil = pil.convert("RGBA")
+        return pil
+    if isinstance(img, Image.Image):
+        return img.convert("RGBA")
+    # Defensief: probeer te openen als pad/bytes
+    try:
+        return Image.open(img).convert("RGBA")
+    except Exception:
+        return None
+
+
+def rgba_to_scribble(img: Image.Image) -> Image.Image:
+    """Zet RGBA schets om naar zwart-op-wit scribble, vierkant 768x768."""
+    img = to_rgba(img)
+    if img is None:
+        return None
+
+    # Witte achtergrond + compositing (zodat transparant wit wordt)
     bg = Image.new("RGBA", img.size, (255, 255, 255, 255))
     img = Image.alpha_composite(bg, img)
 
-    # Naar L (grijs), dan binair threshold voor heldere lijnen
-    gray = img.convert("L")
-    # Auto-threshold: Otsu benadering (simple) via numpy
-    arr = np.array(gray).astype(np.uint8)
-    thr = max(20, int(arr.mean() * 0.9))
-    bin_img = (arr < thr).astype(np.uint8) * 0  # donkere pixels → 0 (zwart)
-    # We willen echte lijnen behouden; maak binaire inversie (zwart op wit)
-    # Gebruik originele gray met punt-bij-punt: onder drempel → zwart, anders wit
-    mask = arr < thr
+    # Grijswaarden en drempel
+    arr = np.array(img.convert("L"))
+    thr = max(25, int(arr.mean() * 0.9))
+    # Donkerder dan thr -> lijn
+    lines = arr < thr
     out = np.full((*arr.shape, 3), 255, dtype=np.uint8)
-    out[mask] = np.array(stroke_color, dtype=np.uint8)
-
+    out[lines] = (0, 0, 0)
     scribble = Image.fromarray(out, mode="RGB")
 
-    # Maak vierkant canvas met padding
+    # Vierkant maken met padding
     max_side = max(scribble.width, scribble.height)
     sq = Image.new("RGB", (max_side, max_side), (255, 255, 255))
     ox = (max_side - scribble.width) // 2
     oy = (max_side - scribble.height) // 2
     sq.paste(scribble, (ox, oy))
 
-    # Resize naar 768 of 512 (sneller). 768 geeft betere details op T4.
-    target = 768
-    sq = sq.resize((target, target), Image.BICUBIC)
-    return sq
+    # Resize naar 768 (kwaliteit) — maak 512 als je CPU gebruikt
+    return sq.resize((768, 768), Image.BICUBIC)
 
 
 def run(
-    drawing: Image.Image,
+    drawing,
     prompt: str,
     negative_prompt: str,
     guidance_scale: float = 8.0,
     controlnet_conditioning_scale: float = 1.2,
-    num_inference_steps: int = 25,
+    num_inference_steps: int = 18,
     seed: int = -1,
-    strength_fill: float = 1.0,
 ):
     if drawing is None:
         raise gr.Error("Teken eerst iets links of laad een schetsbestand.")
-    if not prompt.strip():
-        prompt = "clean line-art, detailed sketch, shaded, high quality, coherent completion"
 
     cn_image = rgba_to_scribble(drawing)
+    if cn_image is None:
+        raise gr.Error("Kon de schets niet lezen. Probeer opnieuw te tekenen of upload een PNG/JPG.")
 
-    gen = None
-    if seed is not None and seed >= 0:
-        gen = torch.Generator(device=DEVICE).manual_seed(int(seed))
-    else:
-        seed = random.randint(0, 2**31 - 1)
-        gen = torch.Generator(device=DEVICE).manual_seed(seed)
+    if not prompt.strip():
+        prompt = "clean pencil sketch, coherent completion, subtle shading, high quality"
+    gen = torch.Generator(device=DEVICE).manual_seed(
+        int(seed) if (seed is not None and int(seed) >= 0) else random.randint(0, 2**31 - 1)
+    )
 
     p = _lazy_load_pipeline()
-
     full_prompt = (
         "black pencil sketch, clean lines, coherent shape completion, subtle shading, "
         "consistent with the input scribble, " + prompt
     )
-
-    image = p(
+    result = p(
         prompt=full_prompt,
         negative_prompt=negative_prompt or "text, watermark, extra limbs, low quality, distorted face, nsfw",
         image=cn_image,
@@ -126,37 +135,52 @@ def run(
         num_inference_steps=int(num_inference_steps),
         guidance_scale=float(guidance_scale),
         controlnet_conditioning_scale=float(controlnet_conditioning_scale),
-    ).images[0]
+    )
+    image = result.images[0]
 
-    # Combineer input en output naast elkaar voor een prettige vergelijking
+    # Combo (input vs output) naast elkaar
     pad = 16
     combo = Image.new("RGB", (cn_image.width * 2 + pad, cn_image.height), (245, 245, 245))
     combo.paste(cn_image, (0, 0))
     combo.paste(image, (cn_image.width + pad, 0))
 
-    return image, cn_image, combo, f"Seed: {seed}"
+    return image, cn_image, combo
+
+
+def make_example_scribble() -> Image.Image:
+    """Genereer een eenvoudige voorbeeldschets (appelvorm)."""
+    w, h = 400, 400
+    img = Image.new("RGBA", (w, h), (0, 0, 0, 0))
+    d = ImageDraw.Draw(img)
+    d.line([(120, 320), (100, 240), (110, 180), (160, 140), (240, 140),
+            (290, 180), (300, 240), (280, 320), (200, 340), (120, 320)], fill=(0, 0, 0, 255), width=14)
+    d.line([(200, 140), (210, 110)], fill=(0, 0, 0, 255), width=12)
+    d.line([(210, 110), (250, 120), (270, 150)], fill=(0, 0, 0, 255), width=10)
+    return img
 
 
 CSS = """
-#combo img { border-radius: 10px; }
 .gradio-container { max-width: 1100px !important; }
+#combo img { border-radius: 10px; }
 """
 
-with gr.Blocks(title="🖌️ Neurale netwerken als tekenaars", css=CSS) as demo:
+with gr.Blocks(title="🖌️ Neurale netwerken als tekenaars (v2)", css=CSS) as demo:
     gr.Markdown(
         """
 # 🖌️ Neurale netwerken als tekenaars
-Teken links een schets. Rechts **maakt een AI** (Stable Diffusion + ControlNet *scribble*) de tekening af op basis van jouw **prompt**.
-
-**Tip:** duidelijke contouren werken het best. Probeer bijvoorbeeld: *“een vliegende vis met vleugels, potloodschets”*.
+Teken links (of klik op **Voorbeeld-schets**) en laat AI de tekening aanvullen
+met **Stable Diffusion + ControlNet (scribble)**.
         """
     )
 
     with gr.Row():
         with gr.Column():
-            canvas = gr.Sketchpad(
-                label="Tekening (schets) — teken in zwart op wit",
-                brush=gr.Brush(default_color="#000000", color_mode="fixed"),
+            canvas = gr.Image(
+                label="Tekening (schets) — gebruik de penseel-tool",
+                sources=["upload", "clipboard"],
+                type="pil",
+                image_mode="RGBA",
+                tool="sketch",
                 height=480,
             )
 
@@ -175,30 +199,34 @@ Teken links een schets. Rechts **maakt een AI** (Stable Diffusion + ControlNet *
             with gr.Accordion("Geavanceerd", open=False):
                 guidance_scale = gr.Slider(4.0, 15.0, value=8.0, step=0.5, label="Guidance scale")
                 cn_strength = gr.Slider(0.1, 2.0, value=1.2, step=0.05, label="ControlNet conditioning scale")
-                steps = gr.Slider(10, 40, value=25, step=1, label="Aantal diffusion-steps")
+                steps = gr.Slider(10, 40, value=18, step=1, label="Aantal diffusion-steps")
                 seed = gr.Number(value=-1, precision=0, label="Seed (-1 = random)")
 
-            run_btn = gr.Button("Vervolledig ✨", variant="primary")
+            with gr.Row():
+                run_btn = gr.Button("Vervolledig ✨", variant="primary")
+                example_btn = gr.Button("Voorbeeld-schets", variant="secondary")
 
         with gr.Column():
             out_img = gr.Image(label="Vervolledigde tekening", interactive=False)
             cn_preview = gr.Image(label="Scribble (input voor AI)", interactive=False)
             combo = gr.Image(label="Vergelijking (links: input, rechts: AI)", elem_id="combo")
-            meta = gr.Markdown()
 
     run_btn.click(
         run,
         inputs=[canvas, prompt, negative_prompt, guidance_scale, cn_strength, steps, seed],
-        outputs=[out_img, cn_preview, combo, meta],
+        outputs=[out_img, cn_preview, combo],
     )
 
-    gr.Markdown(
-        """
-### Over deze demo
-- **Model:** Stable Diffusion v1.5 + ControlNet (scribble).  
-- **Hardware:** bij voorkeur **GPU (T4 small)** in Hugging Face Spaces. Op CPU werkt het ook maar trager.  
-- **Educatief doel:** laat zien hoe een **conditioned diffusion model** een schets omzet naar een coherente tekening.  
-"""
+    # Voorbeeld-schets vullen en direct runnen
+    def fill_and_run(p, n, gs, cs, st, sd):
+        img = make_example_scribble()
+        out, scrib, both = run(img, p, n, gs, cs, st, sd)
+        return img, out, scrib, both
+
+    example_btn.click(
+        fill_and_run,
+        inputs=[prompt, negative_prompt, guidance_scale, cn_strength, steps, seed],
+        outputs=[canvas, out_img, cn_preview, combo],
     )
 
 if __name__ == "__main__":