Update app.py

app.py

@@ -1,21 +1,15 @@
-# app.py
 import os, re, io
 import xml.etree.ElementTree as ET
 import gradio as gr
 
 from hand import Hand  # your handwriting model wrapper
 
-# -----------------------------------------------------------------------------
-# Setup
-# -----------------------------------------------------------------------------
+# ---------------------------------- Setup ------------------------------------
 os.makedirs("img", exist_ok=True)
 hand = Hand()
 
-# -----------------------------------------------------------------------------
-# SVG / coord helpers
-# -----------------------------------------------------------------------------
+# ------------------------------ SVG / coords ---------------------------------
 def _parse_viewbox(root):
-    """Robust viewBox parser: handles commas/spaces, falls back to width/height."""
     vb = root.get("viewBox")
     if vb:
         s = re.sub(r"[,\s]+", " ", vb.strip())
@@ -28,11 +22,11 @@ def _parse_viewbox(root):
                 return (x, y, w, h)
             except ValueError:
                 pass
-    def _num(v, default):
-        if not v: return float(default)
+    def _num(v, d):
+        if not v: return float(d)
         v = v.strip().lower().replace("px", "").replace(",", ".")
         try: return float(v)
-        except ValueError: return float(default)
+        except: return float(d)
     w = _num(root.get("width"), 1200.0)
     h = _num(root.get("height"), 400.0)
     return (0.0, 0.0, w, h)
@@ -54,14 +48,8 @@ def _translate_group(elem, dx, dy):
     prev = elem.get("transform", "")
     elem.set("transform", (prev + f" translate({dx},{dy})").strip())
 
-# -----------------------------------------------------------------------------
-# Tokenization
-# -----------------------------------------------------------------------------
+# ----------------------------- Tokenization ----------------------------------
 def _tokenize_line(line):
-    """
-    Split into [('text'|'sep_space'|'sep_underscore', value), ...]
-    Preserves exact underscore counts and spaces.
-    """
     tokens, i, n = [], 0, len(line)
     while i < n:
         ch = line[i]
@@ -84,24 +72,16 @@ def _tokenize_line(line):
     return tokens
 
 def _display_text_from_tokens(tokens):
-    """What we actually render with the model (underscores & spaces -> single spaces)."""
     return "".join([v if t == "text" else " " for t, v in tokens])
 
-# -----------------------------------------------------------------------------
-# Rasterization & analysis
-# -----------------------------------------------------------------------------
+# ------------------------ Rasterization & analysis ---------------------------
 def _rasterize_svg(svg_str, scale=3.0):
-    """Rasterize SVG string to RGBA image (higher scale = finer gap detection)."""
     import cairosvg
     from PIL import Image
     png = cairosvg.svg2png(bytestring=svg_str.encode("utf-8"), scale=scale, background_color="none")
     return Image.open(io.BytesIO(png)).convert("RGBA")
 
 def _find_blobs_and_gaps(alpha_img):
-    """
-    Return (blobs, gaps, content_bbox) using per-column alpha.
-    blobs/gaps are lists of x-intervals [start, end) in pixels.
-    """
     w, h = alpha_img.size
     bbox = alpha_img.getbbox()
     if not bbox:
@@ -128,12 +108,10 @@ def _find_blobs_and_gaps(alpha_img):
     if in_blob: blobs.append((start, right))
     else: gaps.append((start, right))
 
-    # Only interior gaps (exclude margins)
     core_gaps = [(blobs[i][1], blobs[i + 1][0]) for i in range(len(blobs) - 1)]
     return blobs, core_gaps, (left, top, right, bottom)
 
 def _column_profile(alpha_img, top, bottom):
-    """Ink count per column."""
     w, h = alpha_img.size
     prof = [0] * w
     for x in range(w):
@@ -145,22 +123,16 @@ def _column_profile(alpha_img, top, bottom):
     return prof
 
 def _synthesize_gap_near(alpha_img, content_bbox, target_x_px, min_w_px=14, search_pct=0.18):
-    """
-    Create a gap near target_x_px by finding a local 'valley' (min ink column).
-    Ensures at least min_w_px width.
-    """
     left, top, right, bottom = content_bbox
     prof = _column_profile(alpha_img, top, bottom)
     half = max(6, int((right - left) * search_pct))
     x0 = max(left + 1, int(target_x_px - half))
     x1 = min(right - 1, int(target_x_px + half))
-
     best_x, best_v = x0, prof[x0]
     for x in range(x0, x1):
         v = prof[x]
         if v < best_v:
             best_x, best_v = x, v
-
     half_w = max(7, min_w_px // 2)
     g0 = max(left + 1, best_x - half_w)
     g1 = min(right - 1, best_x + half_w)
@@ -170,7 +142,6 @@ def _synthesize_gap_near(alpha_img, content_bbox, target_x_px, min_w_px=14, sear
         g1 = min(right - 1, g1 + pad)
     return (g0, g1)
 
-# Draw N underscores into a specific gap (pixel coords → SVG coords)
 def _draw_underscores_in_gap(root, gap_px, baseline_px, img_w, img_h, vb,
                              color, stroke_width, n, between_px=3.0,
                              min_len=10.0, max_len=48.0, frac_of_gap=0.60):
@@ -183,8 +154,7 @@ def _draw_underscores_in_gap(root, gap_px, baseline_px, img_w, img_h, vb,
         scale = gap_w / max(1.0, total_needed)
         u_len *= scale
     block_w = n * u_len + (n - 1) * between_px
-    x0_px = gap_px[0] + (gap_w - block_w) / 2.0  # centered in gap
-
+    x0_px = gap_px[0] + (gap_w - block_w) / 2.0  # center in gap
     for i in range(n):
         xs = x0_px + i * (u_len + between_px)
         xe = xs + u_len
@@ -201,7 +171,6 @@ def _draw_underscores_in_gap(root, gap_px, baseline_px, img_w, img_h, vb,
 
 def _draw_margin_underscores(root, edge_px, side, baseline_px, img_w, img_h, vb,
                              color, stroke_width, n, between_px=4.0, len_px=22.0, pad_px=6.0):
-    """Leading/trailing underscores: draw left of first blob or right of last blob."""
     if n <= 0: return
     for i in range(n):
         if side == "left":
@@ -221,18 +190,14 @@ def _draw_margin_underscores(root, edge_px, side, baseline_px, img_w, img_h, vb,
         p.set("stroke-linecap", "round")
         root.append(p)
 
-# -----------------------------------------------------------------------------
-# Core: render one line with underscores drawn *in the model's real gaps*
-# -----------------------------------------------------------------------------
-def render_line_svg_with_underscores(line, style, bias, color, stroke_width):
-    """
-    Keep the model's spacing. Draw underscores inside the actual gaps.
-    No added padding or reflow.
-    """
+# ----------------------- Core: one line w/ underscores -----------------------
+def render_line_svg_with_underscores(line, style, bias, color, stroke_width,
+                                     force_in_largest_gap=False):
+    # Tokenize original; render with underscores->spaces
     tokens = _tokenize_line(line)
     display_line = _display_text_from_tokens(tokens).replace("/", "-").replace("\\", "-")
 
-    # Render the line once (spacing from model remains)
+    # Render the full line once (keeps model spacing intact)
     hand.write(
         filename="img/line.tmp.svg",
         lines=[display_line if display_line.strip() else " "],
@@ -242,7 +207,7 @@ def render_line_svg_with_underscores(line, style, bias, color, stroke_width):
     root = ET.parse("img/line.tmp.svg").getroot()
     vb = _parse_viewbox(root)
 
-    # Put model paths into a group we will augment
+    # Put model paths into a group we'll augment
     g = ET.Element("g")
     for p in _extract_paths(root):
         g.append(p)
@@ -256,7 +221,7 @@ def render_line_svg_with_underscores(line, style, bias, color, stroke_width):
     line_h_px = max(20, bottom - top)
     baseline_px = bottom - int(0.18 * line_h_px)
 
-    # Count leading/trailing underscores (for margins)
+    # Count leading/trailing underscores
     leading_us = 0
     i = 0
     while i < len(tokens) and tokens[i][0] != "text":
@@ -270,7 +235,7 @@ def render_line_svg_with_underscores(line, style, bias, color, stroke_width):
             trailing_us += len(tokens[j][1])
         j -= 1
 
-    # Build clusters (positions between text runs) with underscore counts
+    # Build clusters (positions between text runs) + underscore counts
     clusters = []
     i = 0
     while i < len(tokens):
@@ -289,46 +254,44 @@ def render_line_svg_with_underscores(line, style, bias, color, stroke_width):
         else:
             i += 1
 
-    # Choose gaps: exact-order when available, else reuse widest remaining, else synthesize
+    words = [v for (t, v) in tokens if t == "text" and len(v) > 0]
     gaps_sorted_by_width = sorted(gaps, key=lambda ab: (ab[1] - ab[0]), reverse=True)
     used_gaps = [False] * len(gaps)
 
-    def _take_gap_for_idx(idx, words, left, right):
-        # same-index gap if free
+    def _take_gap_for_idx(idx):
+        # 1) same index gap if available
         if 0 <= idx < len(gaps) and not used_gaps[idx]:
-            used_gaps[idx] = True
-            return gaps[idx]
-        # else widest unused
+            used_gaps[idx] = True; return gaps[idx]
+        # 2) widest unused real gap
         for gp in gaps_sorted_by_width:
             try:
                 real_idx = gaps.index(gp)
             except ValueError:
                 continue
             if not used_gaps[real_idx]:
-                used_gaps[real_idx] = True
-                return gp
-        # else synthesize near expected split
+                used_gaps[real_idx] = True; return gp
+        # 3) synthesize near expected split
         seen_chars = sum(len(w) for w in words[:idx + 1]) if words else 1
         total_chars = sum(len(w) for w in words) or 1
         ratio = min(0.95, max(0.05, seen_chars / float(total_chars)))
         target_x_px = left + ratio * (right - left)
         return _synthesize_gap_near(alpha, content_bbox, target_x_px)
 
-    words = [v for (t, v) in tokens if t == "text" and len(v) > 0]
-
-    # Draw interior underscores cluster-by-cluster
+    # Draw interior underscores
+    drew_any = False
     for idx, cluster in enumerate(clusters):
         n = int(cluster["underscores"])
         if n <= 0:
-            continue  # spaces only → draw nothing
-        gap_px = _take_gap_for_idx(idx, words, left, right)
+            continue
+        gap_px = _take_gap_for_idx(idx)
         _draw_underscores_in_gap(
             g, gap_px, baseline_px, img_w, img_h, vb,
             color, stroke_width, n,
             between_px=3.0, min_len=10.0, max_len=48.0, frac_of_gap=0.60
         )
+        drew_any = True
 
-    # Draw leading/trailing underscores at margins
+    # Leading/trailing
     if blobs:
         first_left = blobs[0][0]
         last_right = blobs[-1][1]
@@ -337,19 +300,29 @@ def render_line_svg_with_underscores(line, style, bias, color, stroke_width):
                 g, first_left, "left", baseline_px, img_w, img_h, vb,
                 color, stroke_width, leading_us
             )
+            drew_any = True
         if trailing_us:
             _draw_margin_underscores(
                 g, last_right, "right", baseline_px, img_w, img_h, vb,
                 color, stroke_width, trailing_us
             )
+            drew_any = True
+
+    # Optional: force-draw one underscore in widest gap if user asked and none drawn
+    if force_in_largest_gap and not drew_any and gaps:
+        widest = max(gaps, key=lambda ab: (ab[1] - ab[0]))
+        _draw_underscores_in_gap(
+            g, widest, baseline_px, img_w, img_h, vb,
+            color, stroke_width, n=1,
+            between_px=0.0, min_len=12.0, max_len=48.0, frac_of_gap=0.70
+        )
 
     width_estimate = right - left if right > left else img_w // 2
     return g, width_estimate
 
-# -----------------------------------------------------------------------------
-# Public: Generate SVG (multi-line, keep model spacing)
-# -----------------------------------------------------------------------------
-def generate_handwriting(text, style, bias=0.75, color="#000000", stroke_width=2, multiline=True):
+# -------------------------- Multi-line compositor ----------------------------
+def generate_handwriting(text, style, bias=0.75, color="#000000", stroke_width=2,
+                         multiline=True, force=False):
     try:
         lines = text.split("\n") if multiline else [text]
         for idx, ln in enumerate(lines):
@@ -362,9 +335,10 @@ def generate_handwriting(text, style, bias=0.75, color="#000000", stroke_width=2
         for i, line in enumerate(lines):
             g, w = render_line_svg_with_underscores(
                 line.replace("/", "-").replace("\\", "-"),
-                style, bias, color, stroke_width
+                style, bias, color, stroke_width,
+                force_in_largest_gap=force
             )
-            _translate_group(g, dx=40, dy=y0 + i * line_gap)  # vertical stacking only
+            _translate_group(g, dx=40, dy=y0 + i * line_gap)
             svg_root.append(g)
             max_right = max(max_right, 40 + w)
 
@@ -373,36 +347,25 @@ def generate_handwriting(text, style, bias=0.75, color="#000000", stroke_width=2
         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)
-# -----------------------------------------------------------------------------
+# ------------------------------- PNG export ----------------------------------
 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.2, background_color="none")
         img = Image.open("img/output_temp.png")
         if img.mode != "RGBA": img = img.convert("RGBA")
-
-        # Make near-white fully transparent (safety)
         data = 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 data])
-
+        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 data])
         out_path = "img/output.png"
         img.save(out_path, "PNG")
         try: os.remove("img/output_temp.png")
@@ -412,11 +375,9 @@ def export_to_png(svg_content):
         print(f"Error converting to PNG: {str(e)}")
         return None
 
-# -----------------------------------------------------------------------------
-# Gradio UI
-# -----------------------------------------------------------------------------
-def generate_handwriting_wrapper(text, style, bias, color, stroke_width, multiline=True):
-    svg = generate_handwriting(text, style, bias, color, stroke_width, multiline)
+# --------------------------------- UI ----------------------------------------
+def generate_handwriting_wrapper(text, style, bias, color, stroke_width, force):
+    svg = generate_handwriting(text, style, bias, color, stroke_width, multiline=True, force=force)
     png = export_to_png(svg)
     return svg, png, "img/output.svg"
 
@@ -426,8 +387,8 @@ css = """
 """
 
 with gr.Blocks(css=css) as demo:
-    gr.Markdown("# 🖋️ Handwriting Synthesis (Underscore-in-gaps)")
-    gr.Markdown("Keeps model spacing. Paints `_` exactly in the real gaps (no padding). Handles merged words and __edges__.")
+    gr.Markdown("# 🖋️ Handwriting Synthesis — Underscores in Real Gaps")
+    gr.Markdown("Spacing is the model’s own. We paint `_` *inside* the actual gaps. If needed, toggle force to drop one underscore into the widest gap.")
 
     with gr.Row():
         with gr.Column(scale=2):
@@ -442,6 +403,7 @@ with gr.Blocks(css=css) as demo:
             with gr.Row():
                 color_picker = gr.ColorPicker(label="Ink Color", value="#000000")
                 stroke_width = gr.Slider(1, 4, step=0.5, value=2, label="Stroke Width")
+            force_toggle = gr.Checkbox(label="Force underscore in largest gap if none drawn", value=False)
             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"])
@@ -451,7 +413,7 @@ with gr.Blocks(css=css) as demo:
 
     generate_btn.click(
         fn=generate_handwriting_wrapper,
-        inputs=[text_input, style_select, bias_slider, color_picker, stroke_width],
+        inputs=[text_input, style_select, bias_slider, color_picker, stroke_width, force_toggle],
         outputs=[output_svg, output_png, download_svg_file]
     ).then(
         fn=lambda p: p,
@@ -459,11 +421,8 @@ with gr.Blocks(css=css) as demo:
         outputs=[download_png_file]
     )
 
-# -----------------------------------------------------------------------------
-# Main
-# -----------------------------------------------------------------------------
+# -------------------------------- main ---------------------------------------
 if __name__ == "__main__":
-    # Ensure deps for rasterization/export are available
     missing = []
     try:
         import cairosvg  # noqa
@@ -475,5 +434,4 @@ if __name__ == "__main__":
         missing.append("pillow")
     if missing:
         print("Install:", " ".join(missing))
-    port = int(os.environ.get("PORT", 7860))
-    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)))