Upload 2 files

app.py

@@ -1,16 +1,8 @@
 """
-app.py — Fabrication Topologies: Pattern Ground Relief Generator
-Gradio web app per HuggingFace Spaces
-
-Deploy:
-  1. Crea un nuovo Space su huggingface.co/new-space
-  2. Scegli SDK: Gradio  |  Hardware: CPU Basic (gratuito)
-  3. Carica questi 3 file: app.py, relief_workshop.py, requirements.txt
-  4. Il deploy parte automaticamente in ~2 minuti
+app.py — Pattern Ground Relief Generator
+Gradio 5.x — compatibile Python 3.13 — HuggingFace Spaces
 """
 
-import io
-import struct
 import tempfile
 from pathlib import Path
 
@@ -19,134 +11,100 @@ import gradio as gr
 import numpy as np
 from PIL import Image
 
-# Importa le funzioni di processing da relief_workshop.py
 from relief_workshop import build_heightmap, heightmap_to_stl
 
 
 # ─────────────────────────────────────────────
-# CORE FUNCTION
+# CORE FUNCTIONS
 # ─────────────────────────────────────────────
 
-def generate_relief(
-    image,
-    tile_w: float,
-    tile_h_mode: str,
-    tile_h_custom: float,
-    relief_mm: float,
-    base_mm: float,
-    invert: bool,
-    quantize_levels: int,
-    tileable: bool,
-    blur: float,
-    resolution: int,
-):
+def preview_depthmap(image, invert, quantize_levels, tileable, blur):
     if image is None:
-        return None, None, "⚠️ Carica un'immagine per iniziare."
-
+        return None, "⚠️ Carica un'immagine."
     try:
-        # Salva immagine in temp
         with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
-            tmp_in = f.name
-        Image.fromarray(image).save(tmp_in)
-
-        # Calcola altezza tile
-        img_h, img_w = image.shape[:2]
-        if tile_h_mode == "Stessa larghezza (100×100)":
-            tile_h = tile_w
-        elif tile_h_mode == "Proporzioni originali":
-            tile_h = tile_w * img_h / img_w
-        else:
-            tile_h = tile_h_custom
+            tmp = f.name
+        Image.fromarray(image).save(tmp)
 
-        # Build heightmap
-        quantize = quantize_levels if quantize_levels >= 2 else 0
+        quantize = int(quantize_levels) if quantize_levels >= 2 else 0
         height_map, px_w, px_h = build_heightmap(
-            tmp_in,
-            max_px=resolution,
-            invert=invert,
-            blur=blur,
-            gamma=1.1,
-            quantize=quantize,
-            tileable=tileable,
-            fade_px=12,
+            tmp, max_px=300,
+            invert=invert, blur=blur, gamma=1.1,
+            quantize=quantize, tileable=tileable, fade_px=12,
         )
+        Path(tmp).unlink(missing_ok=True)
 
-        # Preview depth map
         preview = (height_map * 255).astype(np.uint8)
-        preview_rgb = np.stack([preview, preview, preview], axis=-1)
-
-        # Generate STL
-        stl_bytes = heightmap_to_stl(
-            height_map, px_w, px_h,
-            tile_w_mm=tile_w,
-            tile_h_mm=tile_h,
-            relief_mm=relief_mm,
-            base_mm=base_mm,
-        )
-
-        # Save STL to temp file
-        with tempfile.NamedTemporaryFile(suffix=".stl", delete=False) as f:
-            stl_path = f.name
-            f.write(stl_bytes)
-
-        size_kb = len(stl_bytes) / 1024
-        n_tri = (len(stl_bytes) - 84) // 50
-
-        info = f"""✓ Tile generata
-
-Dimensioni:  {tile_w:.0f} × {tile_h:.0f} mm
-Altezza:     base {base_mm:.1f} mm + rilievo {relief_mm:.1f} mm = {base_mm + relief_mm:.1f} mm totale
-Mesh:        {px_w} × {px_h} px — {n_tri:,} triangoli
-File STL:    {size_kb:.0f} KB
-
-Impostazioni slicer: layer 0.15 mm · infill 15% · no supports"""
-
-        Path(tmp_in).unlink(missing_ok=True)
-        return preview_rgb, stl_path, info
-
+        info = f"Depth map {px_w}×{px_h}px — bianco=alto, nero=basso"
+        if invert:
+            info += " (invertita)"
+        return preview, info
     except Exception as e:
-        return None, None, f"❌ Errore: {str(e)}"
+        return None, f"❌ {e}"
 
 
-def preview_only(
+def generate_stl(
     image,
     tile_w, tile_h_mode, tile_h_custom,
     relief_mm, base_mm,
     invert, quantize_levels, tileable, blur, resolution,
 ):
-    """Genera solo la depth map preview, più veloce."""
     if image is None:
-        return None, "⚠️ Carica un'immagine per iniziare."
-
+        return None, None, "⚠️ Carica un'immagine."
     try:
         with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
             tmp_in = f.name
         Image.fromarray(image).save(tmp_in)
 
-        quantize = quantize_levels if quantize_levels >= 2 else 0
+        img_h, img_w = image.shape[:2]
+        if tile_h_mode == "Quadrata (uguale alla larghezza)":
+            tile_h = tile_w
+        elif tile_h_mode == "Proporzioni originali":
+            tile_h = tile_w * img_h / img_w
+        else:
+            tile_h = tile_h_custom
+
+        quantize = int(quantize_levels) if quantize_levels >= 2 else 0
         height_map, px_w, px_h = build_heightmap(
-            tmp_in,
-            max_px=min(resolution, 300),  # preview più veloce
-            invert=invert,
-            blur=blur,
-            gamma=1.1,
-            quantize=quantize,
-            tileable=tileable,
-            fade_px=12,
+            tmp_in, max_px=int(resolution),
+            invert=invert, blur=blur, gamma=1.1,
+            quantize=quantize, tileable=tileable, fade_px=12,
         )
+        Path(tmp_in).unlink(missing_ok=True)
 
+        # Depth map preview
         preview = (height_map * 255).astype(np.uint8)
-        preview_rgb = np.stack([preview, preview, preview], axis=-1)
 
-        Path(tmp_in).unlink(missing_ok=True)
+        # Generate STL bytes
+        stl_bytes = heightmap_to_stl(
+            height_map, px_w, px_h,
+            tile_w_mm=float(tile_w),
+            tile_h_mm=float(tile_h),
+            relief_mm=float(relief_mm),
+            base_mm=float(base_mm),
+        )
 
-        msg = f"Depth map: {px_w}×{px_h}px · Bianco = alto · Nero = basso"
-        if invert:
-            msg += " (invertita)"
-        return preview_rgb, msg
+        # Write to named temp file (Gradio 5 needs a real path)
+        stl_tmp = tempfile.NamedTemporaryFile(
+            suffix=".stl", delete=False, prefix="tile_"
+        )
+        stl_tmp.write(stl_bytes)
+        stl_tmp.close()
+
+        n_tri = (len(stl_bytes) - 84) // 50
+        size_kb = len(stl_bytes) / 1024
+        info = (
+            f"✓ Tile generata\n\n"
+            f"Dimensioni:  {tile_w:.0f} × {tile_h:.0f} mm\n"
+            f"Altezza:     {base_mm:.1f} base + {relief_mm:.1f} rilievo = {base_mm+relief_mm:.1f} mm\n"
+            f"Mesh:        {px_w}×{px_h}px — {n_tri:,} triangoli\n"
+            f"File:        {size_kb:.0f} KB\n\n"
+            f"Slicer: layer 0.15 mm · infill 15% · no supports"
+        )
+        return preview, stl_tmp.name, info
 
     except Exception as e:
-        return None, f"❌ Errore: {str(e)}"
+        return None, None, f"❌ {e}"
 
 
 # ─────────────────────────────────────────────
@@ -156,239 +114,150 @@ def preview_only(
 CSS = """
 @import url('https://fonts.googleapis.com/css2?family=DM+Mono:wght@400;500&family=Instrument+Serif:ital@0;1&display=swap');
 
-:root {
-    --black: #0a0a0a;
-    --white: #f2efe8;
-    --yellow: #d4a912;
-    --grey: #333;
-    --mid: #888;
-}
+body { background: #0a0a0a !important; }
 
-body, .gradio-container {
-    background: var(--black) !important;
-    color: var(--white) !important;
+.gradio-container {
+    background: #0a0a0a !important;
     font-family: 'DM Mono', monospace !important;
+    max-width: 1100px !important;
 }
 
-.gr-block, .gr-box, .gr-panel {
-    background: #111 !important;
-    border: 1px solid #222 !important;
-    border-radius: 0 !important;
+h1 {
+    font-family: 'Instrument Serif', serif !important;
+    font-size: 2rem !important;
+    color: #f2efe8 !important;
+    font-weight: 400 !important;
+    letter-spacing: -0.02em !important;
+}
+
+h2 {
+    font-family: 'DM Mono', monospace !important;
+    font-size: 0.6rem !important;
+    letter-spacing: 0.2em !important;
+    color: #d4a912 !important;
+    text-transform: uppercase !important;
+    border-bottom: 1px solid #222 !important;
+    padding-bottom: 0.4rem !important;
+    margin-top: 1.2rem !important;
 }
 
 .gr-button {
-    border-radius: 0 !important;
     font-family: 'DM Mono', monospace !important;
-    letter-spacing: 0.05em !important;
     text-transform: uppercase !important;
-    font-size: 0.75rem !important;
+    letter-spacing: 0.08em !important;
+    font-size: 0.72rem !important;
+    border-radius: 0 !important;
 }
 
-.gr-button.primary {
-    background: var(--yellow) !important;
-    color: var(--black) !important;
+button.primary {
+    background: #d4a912 !important;
+    color: #0a0a0a !important;
     border: none !important;
 }
 
-.gr-button.secondary {
+button.secondary {
     background: transparent !important;
-    color: var(--mid) !important;
+    color: #888 !important;
     border: 1px solid #333 !important;
 }
+"""
 
-.gr-button:hover {
-    opacity: 0.85 !important;
-}
-
-label, .gr-label {
-    font-family: 'DM Mono', monospace !important;
-    font-size: 0.7rem !important;
-    letter-spacing: 0.08em !important;
-    color: var(--mid) !important;
-    text-transform: uppercase !important;
-}
+HEADER = """
+# Pattern Ground
+**Fabrication Topologies — Vectorealism × Dropcity · Design Week Milano 2026**
 
-.gr-textbox textarea, .gr-textbox input {
-    background: #0d0d0d !important;
-    border: 1px solid #222 !important;
-    color: var(--white) !important;
-    font-family: 'DM Mono', monospace !important;
-    border-radius: 0 !important;
-}
+Converti un'immagine in una tile di rilievo 3D pronta per la stampa.
+"""
 
-h1 {
-    font-family: 'Instrument Serif', serif !important;
-    font-size: 2.2rem !important;
-    color: var(--white) !important;
-    font-weight: 400 !important;
-    letter-spacing: -0.02em !important;
-    line-height: 1.1 !important;
-}
+GUIDE = """
+**Come funziona**
 
-h3 {
-    font-family: 'DM Mono', monospace !important;
-    font-size: 0.65rem !important;
-    letter-spacing: 0.15em !important;
-    color: var(--yellow) !important;
-    text-transform: uppercase !important;
-    margin-bottom: 0.5rem !important;
-    border-bottom: 1px solid #222 !important;
-    padding-bottom: 0.4rem !important;
-}
+Ogni pixel dell'immagine diventa un'altezza: **bianco = alto, nero = basso** (o inverso con Invert).
+Controlla sempre la depth map prima di generare l'STL.
 
-.info-box {
-    background: #111;
-    border: 1px solid #222;
-    padding: 1rem;
-    font-size: 0.75rem;
-    line-height: 1.7;
-    color: var(--mid);
-    white-space: pre-line;
-}
+**Quantize** — divide il rilievo in N livelli netti invece di un gradiente continuo.
+Ottimo per pattern urbani: sanpietrini, griglia, muratura. Prova 4–6 livelli.
 
-.accent { color: var(--yellow); }
+**Tileable** — sfuma i bordi così le tile si affiancano senza giunti visibili nella griglia.
 
-/* Slider */
-.gr-slider input[type=range] {
-    accent-color: var(--yellow) !important;
-}
+**Immagini che funzionano bene:** foto di pavimentazioni, mappe b/n di edifici, texture geometriche,
+pattern a contrasto alto. Evita foto a colori complesse senza preprocessarle in bianco/nero.
 
-/* Checkbox */
-input[type=checkbox] {
-    accent-color: var(--yellow) !important;
-}
+**Slicer:** layer height 0.15 mm · infill 15% · no supports · ironing on top surface.
 """
 
-HEADER = """
-# Pattern Ground
-### Fabrication Topologies — Vectorealism × Dropcity
 
-Converti un'immagine in una tile di rilievo 3D pronta per la stampa.  
-Regola i parametri, controlla la depth map, scarica l'STL.
-"""
+def toggle_custom(mode):
+    return gr.update(visible=(mode == "Personalizzata"))
 
-INSTRUCTIONS = """### Come funziona
-
-**Depth map preview** — bianco = alto, nero = basso. Controlla prima di generare l'STL.
-
-**Quantize** — crea gradini netti invece di un rilievo continuo. 4–6 livelli funziona bene per pattern urbani (sanpietrini, griglia, muratura).
-
-**Tileable** — sfuma i bordi della tile così le piastrelle si affiancano senza giunti visibili nella griglia condivisa.
-
-**Invert** — inverte l'altezza: utile se il pattern ha sfondo bianco e motivo scuro.
-
-**Impostazioni slicer consigliate:** layer height 0.15 mm · infill 15% · no supports · ironing on top surface"""
-
-def build_ui():
-    with gr.Blocks(css=CSS, title="Pattern Ground — Fabrication Topologies") as demo:
-
-        gr.Markdown(HEADER)
-
-        with gr.Row():
-
-            # ── Colonna sinistra: input + parametri ──
-            with gr.Column(scale=1):
-
-                gr.Markdown("### Immagine")
-                image_input = gr.Image(
-                    label="Carica immagine (PNG, JPG)",
-                    type="numpy",
-                    image_mode="RGB",
-                )
-
-                gr.Markdown("### Dimensioni tile")
-                with gr.Row():
-                    tile_w = gr.Slider(
-                        20, 200, value=100, step=5,
-                        label="Larghezza (mm)"
-                    )
-                tile_h_mode = gr.Radio(
-                    ["Stessa larghezza (100×100)", "Proporzioni originali", "Personalizzata"],
-                    value="Stessa larghezza (100×100)",
-                    label="Altezza tile"
-                )
-                tile_h_custom = gr.Slider(
-                    20, 200, value=100, step=5,
-                    label="Altezza personalizzata (mm)",
-                    visible=False
-                )
-
-                gr.Markdown("### Rilievo")
-                with gr.Row():
-                    relief_mm = gr.Slider(1, 10, value=4, step=0.5, label="Altezza rilievo (mm)")
-                    base_mm = gr.Slider(1, 5, value=2, step=0.5, label="Spessore base (mm)")
-
-                gr.Markdown("### Processing")
-                quantize_levels = gr.Slider(
-                    0, 12, value=0, step=1,
-                    label="Quantize — livelli di altezza (0 = continuo, 4–6 = gradini)"
-                )
-                blur = gr.Slider(
-                    0, 3, value=0.5, step=0.1,
-                    label="Smoothing (0 = nessuno)"
-                )
-                resolution = gr.Slider(
-                    100, 400, value=200, step=50,
-                    label="Risoluzione mesh (px per lato)"
-                )
-
-                gr.Markdown("### Opzioni")
-                with gr.Row():
-                    invert = gr.Checkbox(label="Invert depth (scuro=alto)", value=False)
-                    tileable = gr.Checkbox(label="Tileable (bordi sfumati)", value=False)
-
-                with gr.Row():
-                    preview_btn = gr.Button("Depth map preview", variant="secondary")
-                    generate_btn = gr.Button("Genera STL", variant="primary")
-
-            # ── Colonna destra: output ─��
-            with gr.Column(scale=1):
-                gr.Markdown("### Depth map")
-                depth_preview = gr.Image(
-                    label="Depth map — bianco = alto, nero = basso",
-                    type="numpy",
-                    interactive=False,
-                )
-
-                gr.Markdown("### Download")
-                stl_output = gr.File(label="File STL")
-
-                gr.Markdown("### Info")
-                info_output = gr.Textbox(
-                    label="",
-                    lines=8,
-                    interactive=False,
-                )
-
-                gr.Markdown(INSTRUCTIONS)
-
-        # ── Logica UI ──
-        def toggle_custom_height(mode):
-            return gr.update(visible=(mode == "Personalizzata"))
-
-        tile_h_mode.change(toggle_custom_height, tile_h_mode, tile_h_custom)
-
-        # Inputs condivisi
-        inputs = [
-            image_input, tile_w, tile_h_mode, tile_h_custom,
-            relief_mm, base_mm, invert, quantize_levels, tileable, blur, resolution
-        ]
-
-        preview_btn.click(
-            preview_only,
-            inputs=inputs,
-            outputs=[depth_preview, info_output],
-        )
 
-        generate_btn.click(
-            generate_relief,
-            inputs=inputs,
-            outputs=[depth_preview, stl_output, info_output],
-        )
+with gr.Blocks(css=CSS, title="Pattern Ground") as demo:
+    gr.Markdown(HEADER)
+
+    with gr.Row():
+        # ── Colonna sinistra ──
+        with gr.Column(scale=1):
+
+            gr.Markdown("## Immagine")
+            image_in = gr.Image(label="Carica immagine", type="numpy", image_mode="RGB")
+
+            gr.Markdown("## Dimensioni tile")
+            tile_w = gr.Slider(20, 200, value=100, step=5, label="Larghezza (mm)")
+            tile_h_mode = gr.Radio(
+                ["Quadrata (uguale alla larghezza)", "Proporzioni originali", "Personalizzata"],
+                value="Quadrata (uguale alla larghezza)",
+                label="Altezza",
+            )
+            tile_h_custom = gr.Slider(20, 200, value=100, step=5,
+                                      label="Altezza personalizzata (mm)", visible=False)
+
+            gr.Markdown("## Rilievo")
+            with gr.Row():
+                relief_mm = gr.Slider(1, 10, value=4, step=0.5, label="Altezza rilievo (mm)")
+                base_mm = gr.Slider(1, 5, value=2, step=0.5, label="Base (mm)")
+
+            gr.Markdown("## Processing")
+            quantize = gr.Slider(0, 12, value=0, step=1,
+                                 label="Quantize — livelli (0=continuo, 4–6=gradini)")
+            blur = gr.Slider(0, 3, value=0.5, step=0.1, label="Smoothing (0=nessuno)")
+            resolution = gr.Slider(100, 400, value=200, step=50,
+                                   label="Risoluzione mesh (px per lato)")
+
+            gr.Markdown("## Opzioni")
+            with gr.Row():
+                invert = gr.Checkbox(label="Invert (scuro=alto)", value=False)
+                tileable = gr.Checkbox(label="Tileable (bordi sfumati)", value=False)
+
+            with gr.Row():
+                preview_btn = gr.Button("Depth map preview", variant="secondary")
+                gen_btn = gr.Button("Genera STL", variant="primary")
+
+        # ── Colonna destra ──
+        with gr.Column(scale=1):
+            gr.Markdown("## Depth map")
+            depth_out = gr.Image(label="Bianco = alto · Nero = basso",
+                                 type="numpy", interactive=False)
+
+            gr.Markdown("## Download")
+            stl_out = gr.File(label="STL file")
+
+            gr.Markdown("## Info")
+            info_out = gr.Textbox(label="", lines=7, interactive=False)
+
+            gr.Markdown(GUIDE)
+
+    # ── Events ──
+    tile_h_mode.change(toggle_custom, tile_h_mode, tile_h_custom)
+
+    preview_inputs = [image_in, invert, quantize, tileable, blur]
+    gen_inputs = [
+        image_in, tile_w, tile_h_mode, tile_h_custom,
+        relief_mm, base_mm, invert, quantize, tileable, blur, resolution,
+    ]
 
-    return demo
+    preview_btn.click(preview_depthmap, preview_inputs, [depth_out, info_out])
+    gen_btn.click(generate_stl, gen_inputs, [depth_out, stl_out, info_out])
 
 
 if __name__ == "__main__":
-    app = build_ui()
-    app.launch()
+    demo.launch()

requirements.txt

@@ -1,4 +1,4 @@
-gradio>=4.0
+gradio>=5.29.1
 numpy
 pillow
 opencv-python-headless