Update app.py

app.py

@@ -1,7 +1,6 @@
 import os, re, io
 import xml.etree.ElementTree as ET
 import gradio as gr
-
 from hand import Hand  # your model
 
 # -----------------------------------------------------------------------------
@@ -11,14 +10,50 @@ os.makedirs("img", exist_ok=True)
 hand = Hand()
 
 # -----------------------------------------------------------------------------
-# Small helpers
+# Helpers
 # -----------------------------------------------------------------------------
 def _parse_viewbox(root):
+    """
+    Parse SVG viewBox robustly:
+    - accepts "0 0 600 160" or "0,0,600,160"
+    - falls back to width/height attributes
+    - strips 'px'
+    """
     vb = root.get("viewBox")
-    if not vb:
-        return (0.0, 0.0, 1200.0, 400.0)
-    x, y, w, h = map(float, vb.split())
-    return (x, y, w, h)
+    if vb:
+        s = re.sub(r"[,\s]+", " ", vb.strip())
+        parts = [p for p in s.split(" ") if p]
+        if len(parts) == 4:
+            try:
+                x, y, w, h = map(float, parts)
+                if w <= 0: w = 1200.0
+                if h <= 0: h = 400.0
+                return (x, y, w, h)
+            except ValueError:
+                pass
+    # fallback: width/height attributes
+    def _num(v, default):
+        if not v:
+            return float(default)
+        v = v.strip().lower().replace("px", "")
+        v = v.replace(",", ".")
+        try:
+            return float(v)
+        except ValueError:
+            return float(default)
+    w = _num(root.get("width"), 1200.0)
+    h = _num(root.get("height"), 400.0)
+    return (0.0, 0.0, w, h)
+
+def _px_to_svg_x(x_px, img_w, vb):
+    vx, vy, vw, vh = vb
+    if img_w <= 0: return vx
+    return vx + (x_px / float(img_w)) * vw
+
+def _px_to_svg_y(y_px, img_h, vb):
+    vx, vy, vw, vh = vb
+    if img_h <= 0: return vy
+    return vy + (y_px / float(img_h)) * vh
 
 def _extract_paths(elem):
     return [e for e in elem.iter() if e.tag.endswith("path")]
@@ -27,15 +62,16 @@ def _translate_group(elem, dx, dy):
     prev = elem.get("transform", "")
     elem.set("transform", (prev + f" translate({dx},{dy})").strip())
 
-# Tokenize a line into runs of text / spaces / underscores (order matters)
+# -----------------------------------------------------------------------------
+# Tokenizer
+# -----------------------------------------------------------------------------
 def _tokenize_line(line):
-    tokens = []
-    i, n = 0, len(line)
+    tokens, i, n = [], 0, len(line)
     while i < n:
         ch = line[i]
-        if ch == '_':
+        if ch == "_":
             j = i
-            while j < n and line[j] == '_': j += 1
+            while j < n and line[j] == "_": j += 1
             tokens.append(("sep_underscore", line[i:j]))
             i = j
         elif ch.isspace():
@@ -45,46 +81,35 @@ def _tokenize_line(line):
             i = j
         else:
             j = i
-            while j < n and (line[j] != '_' and not line[j].isspace()):
+            while j < n and (line[j] != "_" and not line[j].isspace()):
                 j += 1
             tokens.append(("text", line[i:j]))
             i = j
     return tokens
 
-# Build the text that the model will actually render (underscores & spaces -> space)
 def _display_text_from_tokens(tokens):
-    out = []
-    for t, v in tokens:
-        if t == "text":
-            out.append(v)
-        else:
-            out.append(" ")  # normalize separators
-    return "".join(out)
+    return "".join([v if t == "text" else " " for t, v in tokens])
 
-# Rasterize an SVG string to RGBA PIL.Image and return (img, vw, vh, vx, vy)
+# -----------------------------------------------------------------------------
+# Rasterize and analyze gaps
+# -----------------------------------------------------------------------------
 def _rasterize_svg(svg_str, scale=2.0):
     import cairosvg
     from PIL import Image
     png = cairosvg.svg2png(bytestring=svg_str.encode("utf-8"), scale=scale, background_color="none")
-    img = Image.open(io.BytesIO(png)).convert("RGBA")
-    return img
+    return Image.open(io.BytesIO(png)).convert("RGBA")
 
-# From alpha image, find left-to-right blobs & gaps within the content bbox
 def _find_blobs_and_gaps(alpha_img):
     w, h = alpha_img.size
     bbox = alpha_img.getbbox()
     if not bbox:
-        return [], [], (0, 0, w, h)  # nothing
+        return [], [], (0, 0, w, h)
     left, top, right, bottom = bbox
-
-    # columns with any ink
     def col_has_ink(x):
-        # check a cropped band to speed up
         for y in range(top, bottom):
             if alpha_img.getpixel((x, y)) > 0:
                 return True
         return False
-
     blobs, gaps = [], []
     x = left
     in_blob = col_has_ink(x)
@@ -92,56 +117,29 @@ def _find_blobs_and_gaps(alpha_img):
     while x < right:
         has = col_has_ink(x)
         if has != in_blob:
-            if in_blob:
-                blobs.append((start, x))  # [start, x)
-            else:
-                gaps.append((start, x))
-            start = x
-            in_blob = has
+            if in_blob: blobs.append((start, x))
+            else: gaps.append((start, x))
+            start, in_blob = x, has
         x += 1
-    # close last run
-    if in_blob:
-        blobs.append((start, right))
-    else:
-        gaps.append((start, right))
-
-    # We only want gaps **between** blobs, not leading/trailing margins:
-    core_gaps = []
-    for i in range(len(blobs) - 1):
-        core_gaps.append((blobs[i][1], blobs[i + 1][0]))
-
+    if in_blob: blobs.append((start, right))
+    else: gaps.append((start, right))
+    core_gaps = [(blobs[i][1], blobs[i + 1][0]) for i in range(len(blobs) - 1)]
     return blobs, core_gaps, (left, top, right, bottom)
 
-# Map pixel x/y to SVG coords via viewBox
-def _px_to_svg_x(x_px, img_w, vb):
-    vx, vy, vw, vh = vb
-    return vx + (x_px / float(img_w)) * vw
-
-def _px_to_svg_y(y_px, img_h, vb):
-    vx, vy, vw, vh = vb
-    return vy + (y_px / float(img_h)) * vh
-
-# Draw N underscores filling a gap (pixel coords -> converted to SVG coords)
 def _draw_underscores_in_gap(root, gap_px, baseline_px, img_w, img_h, vb,
                              color, stroke_width, n, pad_px=3, between_px=4):
     gap_w = max(0, gap_px[1] - gap_px[0] - 2 * pad_px)
-    if gap_w <= 6 or n <= 0:
-        return
-    # fit underscores nicely within the gap
-    # give each underscore ~85% of its slot
+    if gap_w <= 6 or n <= 0: return
     slot = gap_w / n
     line_len = max(8, int(slot * 0.85) - between_px)
     offset = (slot - line_len) / 2.0
-
     for i in range(n):
         x0_px = gap_px[0] + pad_px + i * slot + offset
         x1_px = x0_px + line_len
         y_px = baseline_px
-
         x0 = _px_to_svg_x(x0_px, img_w, vb)
         x1 = _px_to_svg_x(x1_px, img_w, vb)
-        y  = _px_to_svg_y(y_px,  img_h, vb)
-
+        y  = _px_to_svg_y(y_px, img_h, vb)
         p = ET.Element("path")
         p.set("d", f"M{x0},{y} L{x1},{y}")
         p.set("stroke", color)
@@ -151,65 +149,43 @@ def _draw_underscores_in_gap(root, gap_px, baseline_px, img_w, img_h, vb,
         root.append(p)
 
 # -----------------------------------------------------------------------------
-# Render ONE line with correct underscores by analyzing the full-line mask
+# Line renderer with underscores
 # -----------------------------------------------------------------------------
 def render_line_svg_with_underscores(line, style, bias, color, stroke_width):
-    """
-    Returns (line_group, width_estimate). The group contains model strokes + our underscores.
-    """
-    # 1) Tokenize and build the display line (underscores & spaces -> spaces)
     tokens = _tokenize_line(line)
     display_line = _display_text_from_tokens(tokens).replace("/", "-").replace("\\", "-")
-
-    # 2) Ask the model to render this single line to a temp SVG
     hand.write(
         filename="img/line.tmp.svg",
         lines=[display_line if display_line.strip() else " "],
-        biases=[bias],
-        styles=[style],
-        stroke_colors=[color],
-        stroke_widths=[stroke_width]
+        biases=[bias], styles=[style],
+        stroke_colors=[color], stroke_widths=[stroke_width]
     )
     root = ET.parse("img/line.tmp.svg").getroot()
     vb = _parse_viewbox(root)
-
-    # 3) Rasterize the exact SVG we will augment, then find blobs/gaps
-    from PIL import Image
     img = _rasterize_svg(ET.tostring(root, encoding="unicode"))
     alpha = img.split()[-1]
     blobs, gaps, content_bbox = _find_blobs_and_gaps(alpha)
     img_w, img_h = img.size
     left, top, right, bottom = content_bbox
     line_h_px = max(20, bottom - top)
-    baseline_px = bottom - int(0.18 * line_h_px)  # tuck slightly above bottom
-
-    # 4) Build a <g> that contains all original paths
+    baseline_px = bottom - int(0.18 * line_h_px)
     g = ET.Element("g")
-    for p in _extract_paths(root):
-        g.append(p)
-
-    # 5) Determine which gaps correspond to underscores (not regular spaces)
-    # Walk tokens: whenever we have TEXT then SEPs then TEXT, consume one gap.
+    for p in _extract_paths(root): g.append(p)
     gap_idx = 0
-    i = 0
     text_run_count = sum(1 for t, v in tokens if t == "text" and len(v) > 0)
-    # Defensive: if model merged two words, blobs may be fewer—clamp at min
-    max_gaps_we_can_use = max(0, min(len(gaps), max(0, text_run_count - 1)))
-
+    max_gaps = max(0, min(len(gaps), text_run_count - 1))
+    i = 0
     while i < len(tokens):
         t, v = tokens[i]
         if t == "text" and len(v) > 0:
-            # Count any following separators as one logical gap between this and the next text
             j = i + 1
-            underscore_count = 0
-            saw_sep = False
+            underscore_count, saw_sep = 0, False
             while j < len(tokens) and tokens[j][0].startswith("sep_"):
                 saw_sep = True
                 if tokens[j][0] == "sep_underscore":
                     underscore_count += len(tokens[j][1])
                 j += 1
-
-            if saw_sep and gap_idx < max_gaps_we_can_use:
+            if saw_sep and gap_idx < max_gaps:
                 if underscore_count > 0:
                     _draw_underscores_in_gap(
                         g, gaps[gap_idx], baseline_px, img_w, img_h, vb,
@@ -219,99 +195,56 @@ def render_line_svg_with_underscores(line, style, bias, color, stroke_width):
             i = j
         else:
             i += 1
-
-    # 6) Estimate width (use content bbox)
-    width_estimate = right - left
-    if width_estimate <= 0:
-        width_estimate = img_w // 2
-
+    width_estimate = right - left if right > left else img_w // 2
     return g, width_estimate
 
 # -----------------------------------------------------------------------------
-# Generate full SVG (multi-line stacking)
+# Generate handwriting (multi-line)
 # -----------------------------------------------------------------------------
-def generate_handwriting(
-    text,
-    style,
-    bias=0.75,
-    color="#000000",
-    stroke_width=2,
-    multiline=True
-):
+def generate_handwriting(text, style, bias=0.75, color="#000000", stroke_width=2, multiline=True):
     try:
         lines = text.split("\n") if multiline else [text]
-
         for idx, ln in enumerate(lines):
             if len(ln) > 75:
-                return f"Error: Line {idx+1} is too long (max 75 characters)"
-
-        # Compose final SVG
-        svg_root = ET.Element("svg", {
-            "xmlns": "http://www.w3.org/2000/svg",
-            "viewBox": "0 0 1200 800"
-        })
-
-        y0 = 80.0
-        line_gap = 110.0
-        max_right = 0.0
-
+                return f"Error: Line {idx+1} too long (max 75 chars)"
+        svg_root = ET.Element("svg", {"xmlns": "http://www.w3.org/2000/svg","viewBox": "0 0 1200 800"})
+        y0, line_gap, max_right = 80.0, 110.0, 0.0
         for i, line in enumerate(lines):
-            g, w = render_line_svg_with_underscores(
-                line, style, bias, color, stroke_width
-            )
-            # place this line group lower on the page
+            g, w = render_line_svg_with_underscores(line, style, bias, color, stroke_width)
             _translate_group(g, dx=40, dy=y0 + i * line_gap)
             svg_root.append(g)
             max_right = max(max_right, 40 + w)
-
         height = int(y0 + len(lines) * line_gap + 80)
         width = max(300, int(max_right + 40))
         svg_root.set("viewBox", f"0 0 {width} {height}")
-
         svg_content = ET.tostring(svg_root, encoding="unicode")
-        with open("img/output.svg", "w", encoding="utf-8") as f:
-            f.write(svg_content)
+        with open("img/output.svg", "w", encoding="utf-8") as f: f.write(svg_content)
         return svg_content
-
     except Exception as e:
         return f"Error: {str(e)}"
 
 # -----------------------------------------------------------------------------
-# PNG export (transparent)
+# Export to PNG
 # -----------------------------------------------------------------------------
 def export_to_png(svg_content):
     try:
         import cairosvg
         from PIL import Image
-
         if not svg_content or svg_content.startswith("Error:"):
             return None
-
         tmp_svg = "img/temp.svg"
-        with open(tmp_svg, "w", encoding="utf-8") as f:
-            f.write(svg_content)
-
+        with open(tmp_svg, "w", encoding="utf-8") as f: f.write(svg_content)
         cairosvg.svg2png(url=tmp_svg, write_to="img/output_temp.png", scale=2.0, background_color="none")
-
         img = Image.open("img/output_temp.png")
-        if img.mode != "RGBA":
-            img = img.convert("RGBA")
-
-        # Ensure any near-white is transparent (safety)
+        if img.mode != "RGBA": img = img.convert("RGBA")
         datas = img.getdata()
-        img.putdata([(255, 255, 255, 0) if r > 240 and g > 240 and b > 240 else (r, g, b, a)
-                     for (r, g, b, a) in datas])
-
+        img.putdata([(255,255,255,0) if r>240 and g>240 and b>240 else (r,g,b,a)
+                     for (r,g,b,a) in datas])
         out_path = "img/output.png"
         img.save(out_path, "PNG")
-
-        try:
-            os.remove("img/output_temp.png")
-        except:
-            pass
-
+        try: os.remove("img/output_temp.png")
+        except: pass
         return out_path
-
     except Exception as e:
         print(f"Error converting to PNG: {str(e)}")
         return None
@@ -324,81 +257,27 @@ def generate_handwriting_wrapper(text, style, bias, color, stroke_width, multili
     png = export_to_png(svg)
     return svg, png, "img/output.svg"
 
-css = """
-.container {max-width: 900px; margin: auto;}
-.output-container {min-height: 300px;}
-.gr-box {border-radius: 8px; box-shadow: 0 4px 6px rgba(0,0,0,0.1);}
-.footer {text-align: center; margin-top: 20px; font-size: 0.8em; color: #666;}
-"""
+css = ".container {max-width:900px;margin:auto;} .output-container{min-height:300px;}"
 
 with gr.Blocks(css=css) as demo:
     gr.Markdown("# 🖋️ Handwriting Synthesis (Underscore-aware)")
-    gr.Markdown("Underscores are placed only where typed, aligned to real gaps from the model output.")
-
     with gr.Row():
         with gr.Column(scale=2):
-            text_input = gr.Textbox(
-                label="Text Input",
-                placeholder="Try: user_name, zeb_3asba, or zeb aasba (no underscore should be drawn)",
-                lines=5, max_lines=10,
-            )
-            with gr.Row():
-                with gr.Column(scale=1):
-                    style_select = gr.Slider(0, 12, step=1, value=9, label="Handwriting Style")
-                with gr.Column(scale=1):
-                    bias_slider = gr.Slider(0.5, 1.0, step=0.05, value=0.75, label="Neatness (Higher = Neater)")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    color_picker = gr.ColorPicker(label="Ink Color", value="#000000")
-                with gr.Column(scale=1):
-                    stroke_width = gr.Slider(1, 4, step=0.5, value=2, label="Stroke Width")
-            with gr.Row():
-                generate_btn = gr.Button("Generate Handwriting", variant="primary")
-                clear_btn = gr.Button("Clear")
+            text_input = gr.Textbox(label="Text Input", placeholder="Try: user_name vs zeb aasba", lines=5)
+            style_select = gr.Slider(0, 12, step=1, value=9, label="Handwriting Style")
+            bias_slider = gr.Slider(0.5, 1.0, step=0.05, value=0.75, label="Neatness")
+            color_picker = gr.ColorPicker(label="Ink Color", value="#000000")
+            stroke_width = gr.Slider(1, 4, step=0.5, value=2, label="Stroke Width")
+            generate_btn = gr.Button("Generate Handwriting", variant="primary")
         with gr.Column(scale=3):
             output_svg = gr.HTML(label="Generated Handwriting (SVG)", elem_classes=["output-container"])
             output_png = gr.Image(type="filepath", label="Generated Handwriting (PNG)", elem_classes=["output-container"])
-            with gr.Row():
-                download_svg_file = gr.File(label="Download SVG")
-                download_png_file = gr.File(label="Download PNG")
+            download_svg_file = gr.File(label="Download SVG")
+            download_png_file = gr.File(label="Download PNG")
+    generate_btn.click(fn=generate_handwriting_wrapper,
+                       inputs=[text_input, style_select, bias_slider, color_picker, stroke_width],
+                       outputs=[output_svg, output_png, download_svg_file]
+    ).then(fn=lambda p: p, inputs=[output_png], outputs=[download_png_file])
 
-    gr.Markdown("""
-    ### Notes
-    - Only underscores you type are drawn; normal spaces remain spaces.
-    - Alignment uses the *actual gaps* between model-drawn word blobs.
-    - Lines ≤ 75 chars. Slashes (/ and \\) normalized to dashes (-).
-    """)
-
-    generate_btn.click(
-        fn=generate_handwriting_wrapper,
-        inputs=[text_input, style_select, bias_slider, color_picker, stroke_width],
-        outputs=[output_svg, output_png, download_svg_file]
-    ).then(
-        fn=lambda p: p,
-        inputs=[output_png],
-        outputs=[download_png_file]
-    )
-
-    clear_btn.click(
-        fn=lambda: ("", 9, 0.75, "#000000", 2),
-        inputs=None,
-        outputs=[text_input, style_select, bias_slider, color_picker, stroke_width]
-    )
-
-# -----------------------------------------------------------------------------
-# Main
-# -----------------------------------------------------------------------------
 if __name__ == "__main__":
-    port = int(os.environ.get("PORT", 7860))
-    missing = []
-    try:
-        import cairosvg  # noqa
-    except ImportError:
-        missing.append("cairosvg")
-    try:
-        from PIL import Image  # noqa
-    except ImportError:
-        missing.append("pillow")
-    if missing:
-        print("Install:", " ".join(missing))
-    demo.launch(server_name="0.0.0.0", server_port=port)
+    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))