Upload 3 files

app.py

@@ -0,0 +1,635 @@
+# -*- coding: utf-8 -*-
+import os, io, re, random, string, tempfile
+import spaces
+import gradio as gr
+from PIL import Image
+
+# --- CONSTANTES ---
+POTRACE_BIN = 'potrace'
+UPM = 1000
+CROP = 8
+SIDEBEARING = 20
+GLYPH_SCALE = 0.112
+PRECISION = 1
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+DEFAULT_IMG_PROMPT = "Design a custom typeface that takes direct inspiration on the attached control image. The font should faithfully replicate the unique style of the reference."
+
+# --- MAPPINGS 6x6 ---
+MAP_UC = [['A','B','C','D','E','F'],['G','H','I','J','K','L'],['M','N','O','P','Q','R'],['S','T','U','V','W','X'],['Y','Z','Æ','Œ','Ø','ß'],['Ç','.',',',';','?','!']]
+MAP_LC = [['a','b','c','d','e','f'],['g','h','i','j','k','l'],['m','n','o','p','q','r'],['s','t','u','v','w','x'],['y','z','æ','œ','ø','Ð'],['ç',':',"'",'"','«','<']]
+MAP_PUNC = [['1','2','3','4','5','6'],['7','8','9','0','#','%'],['(','[','{','$','€','£'],['&','@','_','+','-','='],['*','/','^','°','→','—'],['`','´','ˆ','¨','˜','•']]
+
+# --- RÉFÉRENCES DE BASELINE PAR GRILLE ---
+BASELINE_REFS = {
+    0: ['H', 'I', 'E', 'A', 'B', 'D', 'F', 'L', 'M', 'N', 'P', 'R', 'T', 'U', 'V', 'X', 'Y', 'Z'],
+    1: ['n', 'm', 'u', 'x', 'h', 'i', 'l', 'k', 'r', 'v', 'w', 'z', 'a', 'e', 'o'],
+    2: ['1', '0', '2', '4', '7', '8', '9', '#', '%', '$', '£', '&', '@', '+', '='],
+}
+
+# --- TRAITEMENT SVG ---
+def simplify_svg_path(d):
+    from fontTools.pens.recordingPen import RecordingPen
+    from fontTools.pens.svgPathPen import SVGPathPen
+    from fontTools.svgLib.path import parse_path
+    rec = RecordingPen()
+    parse_path(d, rec)
+    svg = SVGPathPen(None)
+    rec.replay(svg)
+    return re.sub(r"(\d+\.\d+)", lambda m: f"{float(m.group(1)):.{PRECISION}f}", svg.getCommands())
+
+def get_char_path_rdp(pil_img, upscale=2):
+    import tempfile, subprocess
+    import cv2, numpy as np
+    rgb = np.array(pil_img.convert("RGB"))
+    black_mask = (
+        (rgb[:,:,0] < 80) &
+        (rgb[:,:,1] < 80) &
+        (rgb[:,:,2] < 80)
+    ).astype(np.uint8) * 255
+    h, w = black_mask.shape
+    up = cv2.resize(black_mask, (w*upscale, h*upscale), interpolation=cv2.INTER_NEAREST)
+    with tempfile.NamedTemporaryFile(suffix='.pbm', delete=False) as f:
+        pbm = f.name
+    with tempfile.NamedTemporaryFile(suffix='.svg', delete=False) as f:
+        svg = f.name
+    Image.fromarray(cv2.flip(255-up, 0)).convert('1').save(pbm)
+    try:
+        subprocess.run([POTRACE_BIN, pbm, '-s', '-o', svg, '--alphamax', '0.9', '--opttolerance', '0.5', '--turdsize', '30'], check=True, capture_output=True)
+    except:
+        return ""
+    finally:
+        if os.path.exists(pbm):
+            os.unlink(pbm)
+    if not os.path.exists(svg):
+        return ""
+    with open(svg) as f:
+        content = f.read()
+    os.unlink(svg)
+    paths = re.findall(r'd="([^"]+)"', content)
+    return ' '.join(simplify_svg_path(p) for p in paths).strip() if paths else ""
+
+# --- CONSTRUCTION OTF ---
+MIRROR_MAP = {')': '(', ']': '[', '}': '{'}
+
+ACCENT_MAP = {
+    'à':('a','`'),'è':('e','`'),'ì':('i','`'),'ò':('o','`'),'ù':('u','`'),
+    'À':('A','`'),'È':('E','`'),'Ì':('I','`'),'Ò':('O','`'),'Ù':('U','`'),
+    'á':('a','´'),'é':('e','´'),'í':('i','´'),'ó':('o','´'),'ú':('u','´'),
+    'Á':('A','´'),'É':('E','´'),'Í':('I','´'),'Ó':('O','´'),'Ú':('U','´'),
+    'â':('a','ˆ'),'ê':('e','ˆ'),'î':('i','ˆ'),'ô':('o','ˆ'),'û':('u','ˆ'),
+    'Â':('A','ˆ'),'Ê':('E','ˆ'),'Î':('I','ˆ'),'Ô':('O','ˆ'),'Û':('U','ˆ'),
+    'ä':('a','¨'),'ë':('e','¨'),'ï':('i','¨'),'ö':('o','¨'),'ü':('u','¨'),
+    'Ä':('A','¨'),'Ë':('E','¨'),'Ï':('I','¨'),'Ö':('O','¨'),'Ü':('U','¨'),
+    'ã':('a','˜'),'õ':('o','˜'),'ñ':('n','˜'),
+    'Ã':('A','˜'),'Õ':('O','˜'),'Ñ':('N','˜'),
+}
+
+def build_otf(images, font_name):
+    from fontTools.fontBuilder import FontBuilder
+    from fontTools.pens.t2CharStringPen import T2CharStringPen
+    from fontTools.pens.boundsPen import BoundsPen
+    from fontTools.pens.transformPen import TransformPen
+    from fontTools.pens.recordingPen import RecordingPen
+    from fontTools.misc.transform import Identity
+    from fontTools.svgLib.path import parse_path
+    from fontTools.cffLib import PrivateDict
+    from fontTools.ttLib import newTable
+    from fontTools.ttLib.tables import _k_e_r_n as _kern
+    import tempfile, subprocess, cv2, numpy as np
+    from PIL import Image, ImageDraw
+
+    all_maps = [MAP_UC, MAP_LC, MAP_PUNC]
+    glyph_data = {}
+
+    for idx, img in enumerate(images):
+        w, h = img.size
+        arr = np.array(img.convert("RGB"))
+        arr_up = cv2.resize(arr, (w*2, h*2), interpolation=cv2.INTER_CUBIC)
+        img_up = Image.fromarray(arr_up)
+        w2, h2 = img_up.size
+        cw, ch = w2//6, h2//6
+        scale = 800/ch
+        current_map = all_maps[idx]
+        for r in range(6):
+            for c in range(6):
+                char = current_map[r][c]
+                box = (c*cw, r*ch, (c+1)*cw, (r+1)*ch)
+                d = get_char_path_rdp(img_up.crop(box), upscale=1)
+                if not d:
+                    continue
+                bp = BoundsPen(None)
+                try:
+                    parse_path(d, bp)
+                except:
+                    continue
+                if bp.bounds:
+                    glyph_data[char] = {'d': d, 'b': bp.bounds, 'scale': scale, 'grid': idx}
+
+    # Baseline calculée
+    baseline_per_grid = {}
+    for grid_idx in range(len(all_maps)):
+        chosen_ref = None
+        for ref_char in BASELINE_REFS.get(grid_idx, []):
+            if ref_char in glyph_data and glyph_data[ref_char].get('grid') == grid_idx:
+                gd = glyph_data[ref_char]
+                baseline_per_grid[grid_idx] = gd['b'][3] * gd['scale'] * GLYPH_SCALE
+                chosen_ref = ref_char
+                break
+        if chosen_ref is None:
+            baseline_per_grid[grid_idx] = baseline_per_grid.get(0, 0)
+            print(f"⚠️  Grille {grid_idx} : aucun caractère de référence trouvé, fallback = {baseline_per_grid[grid_idx]:.1f}")
+        else:
+            print(f"📐 Grille {grid_idx} : baseline = {baseline_per_grid[grid_idx]:.1f} (réf '{chosen_ref}')")
+
+    def get_baseline(char):
+        if char in glyph_data:
+            return baseline_per_grid.get(glyph_data[char]['grid'], baseline_per_grid.get(0, 0))
+        return baseline_per_grid.get(0, 0)
+
+    dummy = PrivateDict()
+    dummy.nominalWidthX = 0
+    cs = {".notdef": T2CharStringPen(600, None).getCharString(private=dummy)}
+    metrics = {".notdef": (600, 0)}
+    cmap, order = {}, [".notdef"]
+    cs["space"] = T2CharStringPen(300, None).getCharString(private=dummy)
+    metrics["space"] = (300, 0)
+    order.append("space")
+    cmap[32] = "space"
+
+    font_recordings = {}
+    font_bounds = {}
+    font_widths = {}
+    font_centers = {}
+
+    for char, data in glyph_data.items():
+        if len(char) != 1:
+            continue
+        b, s = data['b'], data['scale']
+        width = round((b[2]-b[0]) * s * GLYPH_SCALE + SIDEBEARING * 2)
+        tx = SIDEBEARING - b[0] * s * GLYPH_SCALE
+        ty = get_baseline(char)
+        transform = Identity.translate(tx, ty).scale(s * GLYPH_SCALE, -s * GLYPH_SCALE)
+        rec = RecordingPen()
+        parse_path(data['d'], TransformPen(rec, transform))
+        font_recordings[char] = rec.value
+        font_widths[char] = width
+        bp2 = BoundsPen(None)
+        rec2 = RecordingPen()
+        rec2.value = rec.value
+        rec2.replay(bp2)
+        bounds = bp2.bounds or (0, 0, width, 800)
+        font_bounds[char] = bounds
+        font_centers[char] = ((bounds[0] + bounds[2]) / 2, (bounds[1] + bounds[3]) / 2)
+        pen = T2CharStringPen(width, None)
+        rec3 = RecordingPen()
+        rec3.value = rec.value
+        rec3.replay(pen)
+        glyph_name = f"glyph{ord(char)}"
+        cs[glyph_name] = pen.getCharString(private=dummy)
+        order.append(glyph_name)
+        cmap[ord(char)] = glyph_name
+        metrics[glyph_name] = (width, 0)
+
+    # Miroirs
+    for dst_char, src_char in MIRROR_MAP.items():
+        if src_char not in font_recordings:
+            continue
+        w = font_widths[src_char]
+        pen = T2CharStringPen(w, None)
+        flip = TransformPen(pen, (-1, 0, 0, 1, w, 0))
+        rec = RecordingPen()
+        rec.value = font_recordings[src_char]
+        rec.replay(flip)
+        gn = f"glyph{ord(dst_char)}"
+        cs[gn] = pen.getCharString(private=dummy)
+        order.append(gn)
+        cmap[ord(dst_char)] = gn
+        metrics[gn] = (w, 0)
+        if src_char in font_centers:
+            cx, cy = font_centers[src_char]
+            font_centers[dst_char] = (w - cx, cy)
+
+    # Accentués
+    for dst_char, (base_char, accent_char) in ACCENT_MAP.items():
+        if base_char not in font_recordings or accent_char not in font_recordings:
+            continue
+        w = font_widths[base_char]
+        bb = font_bounds[base_char]
+        ab = font_bounds[accent_char]
+        dx = ((bb[0]+bb[2]) - (ab[0]+ab[2])) / 2
+        dy = bb[3] - ab[1] + 40
+        pen = T2CharStringPen(w, None)
+        rec1 = RecordingPen()
+        rec1.value = font_recordings[base_char]
+        rec1.replay(pen)
+        rec2 = RecordingPen()
+        rec2.value = font_recordings[accent_char]
+        rec2.replay(TransformPen(pen, (1, 0, 0, 1, dx, dy)))
+        gn = f"glyph{ord(dst_char)}"
+        cs[gn] = pen.getCharString(private=dummy)
+        order.append(gn)
+        cmap[ord(dst_char)] = gn
+        metrics[gn] = (w, 0)
+        if base_char in font_centers and accent_char in font_centers:
+            bx, by = font_centers[base_char]
+            ax, ay = font_centers[accent_char]
+            font_centers[dst_char] = (bx + dx, by + dy)
+
+    # Miroirs bracket
+    MIRROR_PAIRS = {'(': ')', '[': ']', '{': '}'}
+    for src_char, dst_char in MIRROR_PAIRS.items():
+        if src_char not in glyph_data:
+            continue
+        data = glyph_data[src_char]
+        b, s = data['b'], data['scale']
+        width = round((b[2]-b[0]) * s * GLYPH_SCALE + SIDEBEARING * 2)
+        pen = T2CharStringPen(width, None)
+        tx = SIDEBEARING + b[2] * s * GLYPH_SCALE
+        ty = get_baseline(src_char)
+        transform = Identity.translate(tx, ty).scale(-s * GLYPH_SCALE, -s * GLYPH_SCALE)
+        parse_path(data['d'], TransformPen(pen, transform))
+        glyph_name = f"glyph{ord(dst_char)}"
+        if glyph_name not in cs:
+            cs[glyph_name] = pen.getCharString(private=dummy)
+            order.append(glyph_name)
+            cmap[ord(dst_char)] = glyph_name
+            metrics[glyph_name] = (width, 0)
+            if src_char in font_centers:
+                cx, cy = font_centers[src_char]
+                font_centers[dst_char] = (width - cx, cy)
+
+    # Alias accents combinants
+    ACCENT_ALIASES = {
+        '`': [0x0060, 0x0300], '´': [0x00B4, 0x0301],
+        'ˆ': [0x02C6, 0x0302], '¨': [0x00A8, 0x0308], '˜': [0x02DC, 0x0303],
+    }
+    for base_char, codepoints in ACCENT_ALIASES.items():
+        if base_char not in glyph_data:
+            continue
+        existing_glyph_name = f"glyph{ord(base_char)}"
+        if existing_glyph_name in cs:
+            for cp in codepoints[1:]:
+                if cp not in cmap:
+                    cmap[cp] = existing_glyph_name
+
+    fb = FontBuilder(UPM, isTTF=False)
+    fb.setupGlyphOrder(order)
+    fb.setupCharacterMap(cmap)
+    fb.setupCFF(
+        font_name,
+        {"FullName": font_name, "FamilyName": font_name, "Weight": "Regular"},
+        cs,
+        {font_name: dummy}
+    )
+    fb.setupHorizontalMetrics(metrics)
+    fb.setupHorizontalHeader(ascent=REF["asc"], descent=REF["dsc"])
+    fb.setupNameTable({
+        "familyName": font_name,
+        "styleName": "Regular",
+        "uniqueFontIdentifier": f"{font_name}:Version 1.000",
+        "fullName": font_name,
+        "version": "Version 1.000",
+        "psName": font_name
+    })
+    fb.setupOS2(
+        sTypoAscender=REF["tAsc"],
+        sTypoDescender=REF["tDsc"],
+        sTypoLineGap=REF["tGap"],
+        usWinAscent=REF["wAsc"],
+        usWinDescent=REF["wDsc"],
+        sxHeight=REF["xH"],
+        sCapHeight=REF["cH"],
+        fsType=4,
+        fsSelection=64
+    )
+    fb.setupPost(italicAngle=0, underlinePosition=REF["ulP"], underlineThickness=REF["ulT"])
+
+    # -------------------------------------------------------------------------
+    # BUBBLE KERNING — vectoriel pur, écrit en GPOS (pas de limite de paires)
+    # -------------------------------------------------------------------------
+    try:
+        import numpy as np
+        from fontTools.otlLib.builder import buildValue, buildPairPosGlyphs
+        from fontTools.ttLib import newTable
+        from fontTools.ttLib.tables import otTables
+
+        # --- Paramètres ---
+        BUBBLE_RADIUS  = 10   # rayon de la bulle en UPM, doit être < SIDEBEARING (20)
+        N_SAMPLES      = 300  # points échantillonnés par contour
+        KERN_THRESHOLD = -2   # paires dont kern ≥ seuil ignorées (bruit sub-UPM)
+        KERN_CAP       = -280 # plancher anti-collision
+
+        def sample_contour(recording, n=N_SAMPLES):
+            pts = []
+
+            def add_line(p0, p1):
+                d = ((p1[0]-p0[0])**2 + (p1[1]-p0[1])**2) ** 0.5
+                steps = max(1, int(d / 8))
+                for i in range(steps + 1):
+                    t = i / steps
+                    pts.append((p0[0] + t*(p1[0]-p0[0]),
+                                p0[1] + t*(p1[1]-p0[1])))
+
+            def add_cubic(p0, p1, p2, p3):
+                d = ((p3[0]-p0[0])**2 + (p3[1]-p0[1])**2) ** 0.5
+                steps = max(4, int(d * 1.5 / 8))
+                for i in range(steps + 1):
+                    t  = i / steps
+                    mt = 1.0 - t
+                    bx = mt**3*p0[0] + 3*mt**2*t*p1[0] + 3*mt*t**2*p2[0] + t**3*p3[0]
+                    by = mt**3*p0[1] + 3*mt**2*t*p1[1] + 3*mt*t**2*p2[1] + t**3*p3[1]
+                    pts.append((bx, by))
+
+            cur = (0.0, 0.0)
+            start = (0.0, 0.0)
+            for op, args in recording:
+                if op == 'moveTo':
+                    cur = args[0]; start = cur
+                elif op == 'lineTo':
+                    add_line(cur, args[0]); cur = args[0]
+                elif op == 'curveTo':
+                    add_cubic(cur, args[0], args[1], args[2]); cur = args[2]
+                elif op in ('endPath', 'closePath'):
+                    if cur != start:
+                        add_line(cur, start)
+                    cur = start
+
+            if not pts:
+                return None
+            arr = np.array(pts, dtype=np.float32)
+            if len(arr) > n:
+                idx = np.round(np.linspace(0, len(arr)-1, n)).astype(int)
+                arr = arr[idx]
+            return arr
+
+        # Échantillonnage
+        chars_available = [c for c in font_recordings if len(c) == 1]
+        contour_points  = {}
+        for char in chars_available:
+            pts = sample_contour(font_recordings[char])
+            if pts is not None and len(pts) >= 2:
+                contour_points[char] = pts
+
+        print(f"📐 Contours échantillonnés : {len(contour_points)} glyphes")
+
+        # Calcul all-to-all
+        diameter   = BUBBLE_RADIUS * 2.0
+        gpos_pairs = {}   # (glyph_name_L, glyph_name_R) → kern_upm
+
+        for l_char in contour_points:
+            pts_L = contour_points[l_char]
+            adv_L = float(font_widths[l_char])
+            lg    = f"glyph{ord(l_char)}"
+            if lg not in metrics:
+                continue
+
+            for r_char in contour_points:
+                rg = f"glyph{ord(r_char)}"
+                if rg not in metrics:
+                    continue
+
+                pts_R_shifted = contour_points[r_char] + np.array([adv_L, 0.0], dtype=np.float32)
+                diff     = pts_L[:, np.newaxis, :] - pts_R_shifted[np.newaxis, :, :]
+                min_dist = float(np.sqrt((diff**2).sum(axis=2)).min())
+                kern_upm = int(round(diameter - min_dist))
+
+                if l_char in ('A','V','W') and r_char in ('A','V','W'):
+                    print(f"  {l_char}→{r_char} : min_dist={min_dist:.1f}  kern={kern_upm}")
+
+                if kern_upm < KERN_THRESHOLD:
+                    gpos_pairs[(lg, rg)] = max(kern_upm, KERN_CAP)
+
+        print(f"✅ Bubble Kerning vectoriel : {len(gpos_pairs)} paires")
+
+        if gpos_pairs:
+            val0 = buildValue({})
+            pairs_for_builder = {
+                (lg, rg): (buildValue({"XAdvance": kern}), val0)
+                for (lg, rg), kern in gpos_pairs.items()
+            }
+
+            glyph_map = fb.font.getReverseGlyphMap()
+            subtables = buildPairPosGlyphs(pairs_for_builder, glyph_map)
+
+            lookup               = otTables.Lookup()
+            lookup.LookupType    = 2
+            lookup.LookupFlag    = 0
+            lookup.SubTableCount = len(subtables)
+            lookup.SubTable      = subtables
+
+            lookup_list               = otTables.LookupList()
+            lookup_list.Lookup        = [lookup]
+            lookup_list.LookupCount   = 1
+
+            feature_record            = otTables.FeatureRecord()
+            feature_record.FeatureTag = "kern"
+            feature                   = otTables.Feature()
+            feature.LookupListIndex   = [0]
+            feature.LookupCount       = 1
+            feature_record.Feature    = feature
+
+            lang_sys              = otTables.DefaultLangSys()
+            lang_sys.ReqFeatureIndex = 0xFFFF
+            lang_sys.FeatureIndex = [0]
+            lang_sys.FeatureCount = 1
+            lang_sys.LookupOrderOffset = 0
+
+            script               = otTables.Script()
+            script.DefaultLangSys = lang_sys
+            script.LangSysCount  = 0
+            script.LangSysRecord = []
+
+            script_record            = otTables.ScriptRecord()
+            script_record.ScriptTag  = "DFLT"
+            script_record.Script     = script
+
+            script_list              = otTables.ScriptList()
+            script_list.ScriptRecord = [script_record]
+            script_list.ScriptCount  = 1
+
+            feature_list                 = otTables.FeatureList()
+            feature_list.FeatureRecord   = [feature_record]
+            feature_list.FeatureCount    = 1
+
+            gpos_table          = otTables.GPOS()
+            gpos_table.Version  = 0x00010000
+            gpos_table.ScriptList  = script_list
+            gpos_table.FeatureList = feature_list
+            gpos_table.LookupList  = lookup_list
+
+            gpos                = newTable("GPOS")
+            gpos.table          = gpos_table
+            fb.font["GPOS"]     = gpos
+            print(f"✅ GPOS écrit : {len(gpos_pairs)} paires kern")
+
+    except Exception as e:
+        print(f"⚠️ Bubble Kerning failed: {e}")
+        import traceback
+        traceback.print_exc()
+
+    # --- Sauvegarde finale en OTF ---
+    tmp_otf = f"/tmp/{font_name}.otf"
+    fb.save(tmp_otf)
+    with open(tmp_otf, "rb") as f:
+        data = f.read()
+    os.remove(tmp_otf)
+    return data
+
+# --- MÉTRIQUES DE RÉFÉRENCE (Helvetica LT Std Regular) ---
+REF = {
+    "asc": 718, "dsc": -282, "tAsc": 718, "tDsc": -282, "tGap": 200,
+    "wAsc": 931, "wDsc": 225, "xH": 524, "cH": 718, "ulP": -75, "ulT": 50
+}
+
+# =============================================================================
+# CHARGEMENT DU MODÈLE (au scope module, une seule fois au démarrage du Space)
+# ZeroGPU : .to("cuda") ici est OK, l'init CUDA réelle est différée par `spaces`.
+# =============================================================================
+import torch
+from diffusers import Flux2KleinPipeline
+from huggingface_hub import login
+
+if HF_TOKEN:
+    login(token=HF_TOKEN)
+
+print("🚀 Loading Flux.2-klein + LoRAs ...")
+pipe = Flux2KleinPipeline.from_pretrained(
+    "black-forest-labs/FLUX.2-klein-base-4B",
+    torch_dtype=torch.bfloat16,
+)
+pipe.load_lora_weights("ChevalierJoseph/TYPOTOPIA_APP", weight_name="typotopiaMAJ.safetensors", adapter_name="uc")
+pipe.load_lora_weights("ChevalierJoseph/TYPOTOPIA_APP", weight_name="typotopiaMIN.safetensors", adapter_name="lc")
+pipe.load_lora_weights("ChevalierJoseph/TYPOTOPIA_APP", weight_name="typotopiaPONCT.safetensors", adapter_name="punc")
+pipe.to("cuda")
+print("✅ Modèle prêt !")
+
+
+# =============================================================================
+# INFÉRENCE GPU — uniquement les 3 passes FLUX sous @spaces.GPU
+# duration = temps max d'allocation GPU (compte sur le quota ZeroGPU).
+# =============================================================================
+@spaces.GPU(duration=180)
+def run_pipeline(enhanced, input_img, seed):
+    gen = torch.Generator("cuda").manual_seed(int(seed))
+
+    pipe.set_adapters("uc")
+    img1 = pipe(
+        prompt=f"[typotopiaMAJ], {enhanced}",
+        image=input_img,
+        num_inference_steps=15,
+        guidance_scale=7 if input_img else 3.5,
+        height=1536, width=1536,
+        generator=gen,
+    ).images[0]
+
+    pipe.set_adapters("lc")
+    img2 = pipe(
+        prompt="[typotopiaMIN], Design a custom lowercase typeface inspired by the attached control image.",
+        image=img1,
+        num_inference_steps=15,
+        guidance_scale=7,
+        height=1536, width=1536,
+        generator=gen,
+    ).images[0]
+
+    pipe.set_adapters("punc")
+    img3 = pipe(
+        prompt="[typotopiaPONCT], Design a custom punctuation typeface inspired by the attached control image.",
+        image=img1,
+        num_inference_steps=15,
+        guidance_scale=7,
+        height=1536, width=1536,
+        generator=gen,
+    ).images[0]
+
+    return img1, img2, img3
+
+
+# =============================================================================
+# ORCHESTRATEUR + UI GRADIO
+# =============================================================================
+def _render_preview(otf_path, font_name):
+    try:
+        from PIL import Image, ImageDraw, ImageFont
+        sample = f"{font_name}\nAa Bb Cc 123\nThe quick brown fox"
+        img = Image.new("RGB", (1100, 520), "white")
+        draw = ImageDraw.Draw(img)
+        font = ImageFont.truetype(otf_path, 90)
+        draw.multiline_text((40, 40), sample, font=font, fill="black", spacing=24)
+        return img
+    except Exception as e:
+        print(f"⚠️ Aperçu impossible: {e}")
+        return None
+
+
+def generate(prompt, control_image, seed, random_seed, progress=gr.Progress(track_tqdm=True)):
+    if random_seed or seed is None:
+        seed = random.randint(0, 2**32 - 1)
+    seed = int(seed)
+
+    input_img = None
+    prefixes = ["Vex","Aur","Kyr","Lux","Nox","Arc","Sol","Vel","Fen","Zor","Cal","Dex","Ora","Pax","Rux"]
+    suffixes = ["ra","is","on","us","ia","el","an","ix","em","or","al","en","ax","um","yr"]
+    font_name = random.choice(prefixes) + random.choice(suffixes)
+
+    if control_image is not None:
+        input_img = control_image.convert("RGB").resize((1536, 1536))
+        enhanced = DEFAULT_IMG_PROMPT
+    else:
+        if not (prompt and prompt.strip()):
+            raise gr.Error("Donne un prompt OU une image de contrôle.")
+        enhanced = prompt  # input utilisateur brut, aucun raffinement
+
+    # --- GPU : 3 passes FLUX ---
+    img1, img2, img3 = run_pipeline(enhanced, input_img, seed)
+
+    if not font_name:
+        font_name = "Font" + "".join(random.choices(string.ascii_uppercase, k=3))
+
+    # --- CPU : vectorisation potrace + build OTF ---
+    otf_bytes = build_otf([img1, img2, img3], font_name)
+
+    out_dir = tempfile.mkdtemp()
+    otf_path = os.path.join(out_dir, f"{font_name}.otf")
+    with open(otf_path, "wb") as f:
+        f.write(otf_bytes)
+
+    gallery = [(img1, "Majuscules"), (img2, "Minuscules"), (img3, "Ponctuation")]
+    preview = _render_preview(otf_path, font_name)
+    status = f"✅ **{font_name}** — seed `{seed}`"
+    return gallery, preview, otf_path, status
+
+
+with gr.Blocks(title="Typotopia", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        "# 🔤 Typotopia\n"
+        "Génère une police OpenType complète (.otf) depuis un **prompt** ou une "
+        "**image de contrôle**. FLUX.2-klein + LoRAs (ZeroGPU) → vectorisation potrace "
+        "→ fontTools avec kerning vectoriel."
+    )
+    with gr.Row():
+        with gr.Column(scale=1):
+            prompt = gr.Textbox(
+                label="Prompt",
+                placeholder="ex. a bold geometric sans inspired by brutalist concrete signage",
+                lines=3,
+            )
+            control_image = gr.Image(label="Image de contrôle (optionnelle)", type="pil")
+            with gr.Row():
+                seed = gr.Number(label="Seed", value=0, precision=0)
+                random_seed = gr.Checkbox(label="Seed aléatoire", value=True)
+            btn = gr.Button("Générer la police", variant="primary")
+        with gr.Column(scale=1):
+            status = gr.Markdown()
+            preview = gr.Image(label="Aperçu", type="pil")
+            gallery = gr.Gallery(label="Grilles générées", columns=3, height="auto")
+            otf_file = gr.File(label="Télécharger le .otf")
+
+    btn.click(
+        generate,
+        inputs=[prompt, control_image, seed, random_seed],
+        outputs=[gallery, preview, otf_file, status],
+    )
+
+if __name__ == "__main__":
+    demo.queue().launch()

packages.txt

@@ -0,0 +1,3 @@
+potrace
+libgl1
+libglib2.0-0

requirements.txt

@@ -0,0 +1,13 @@
+spaces
+gradio
+torch
+diffusers
+transformers
+accelerate
+sentencepiece
+huggingface_hub
+peft
+opencv-python-headless
+numpy
+Pillow
+fonttools