Smooth lines (2x supersample) + updated HUD in reel generator

Render at 2160×3840 and downsample with Lanczos for anti-aliased
strokes. HUD now shows labeled PROGRESS / INK / PLOT TIME / POSITION
columns instead of BED 01 header.

https://claude.ai/code/session_01VhWRYXbuqapZ9YkvksroaS

Author: claude

tools/gen_reel.py

@@ -30,11 +30,13 @@
 
 # ---------- config ----------
 W, H = 1080, 1920
+SS = 2                        # supersample factor (render at SSx, downsample for AA)
+SW, SH = W*SS, H*SS
 PAPER = (246, 243, 236)
 INK_HEX = {'black': (23, 21, 15), 'red': (216, 52, 42), 'blue': (31, 74, 160)}
 HUD = (21, 22, 15)
 FEED = 1100
-ART = (60, 280, 960, 1300)  # x,y,w,h
+ART = (60, 280, 960, 1300)  # x,y,w,h at 1x (scaled up internally)
 
 BOLD = '/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf'
 REG  = '/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf'
@@ -90,9 +92,10 @@ def render(key, color, dur=15, fps=30, out=None):
     segs, total_len = seg_lengths(subpaths)
 
     ax, ay, aw, ah = ART
-    sc = min(aw/vbw, ah/vbh)
-    ox = ax + (aw - vbw*sc)/2
-    oy = ay + (ah - vbh*sc)/2
+    s = SS
+    sc = min(aw/vbw, ah/vbh) * s
+    ox = (ax * s) + (aw * s - vbw * sc) / 2
+    oy = (ay * s) + (ah * s - vbh * sc) / 2
     def mx(x): return ox + (x-vbx)*sc
     def my(y): return oy + (y-vby)*sc
 
@@ -104,17 +107,20 @@ def my(y): return oy + (y-vby)*sc
     plot_end = int(total_frames * 0.80)
     hold_end = int(total_frames * 0.92)
 
-    # fonts
-    f_logo = ImageFont.truetype(BOLD, 56)
-    f_bed  = ImageFont.truetype(BOLD, 26)
-    f_name = ImageFont.truetype(REG, 22)
-    f_jp   = ImageFont.truetype(JP, 26)
-    f_stat = ImageFont.truetype(BOLD, 22)
-    f_small= ImageFont.truetype(REG, 17)
-    f_end_logo = ImageFont.truetype(BOLD, 88)
-    f_end_name = ImageFont.truetype(BOLD, 32)
-    f_end_jp   = ImageFont.truetype(JP, 30)
-    f_end_tag  = ImageFont.truetype(REG, 20)
+    # fonts (at SS scale)
+    f_code = ImageFont.truetype(BOLD, 26*s)
+    f_name = ImageFont.truetype(REG, 22*s)
+    f_jp   = ImageFont.truetype(JP, 26*s)
+    f_stat = ImageFont.truetype(BOLD, 20*s)
+    f_label= ImageFont.truetype(REG, 15*s)
+    f_end_logo = ImageFont.truetype(BOLD, 88*s)
+    f_end_name = ImageFont.truetype(BOLD, 32*s)
+    f_end_jp   = ImageFont.truetype(JP, 30*s)
+    f_end_tag  = ImageFont.truetype(REG, 20*s)
+
+    LM = 60*s   # left margin
+    RM = 60*s   # right margin
+    line_w = max(2, 2*s)
 
     out = out or f'/tmp/{key}-{color}-reel.mp4'
     ff = imageio_ffmpeg.write_frames(
@@ -136,7 +142,7 @@ def hud_rgba(a=0.30): return HUD + (int(255*a),)
             prog = 1.0; phase='end'
             alpha = (f-hold_end)/(total_frames-hold_end)
 
-        img = Image.new('RGB', (W,H), PAPER)
+        img = Image.new('RGB', (SW,SH), PAPER)
         d = ImageDraw.Draw(img, 'RGBA')
 
         # ---- strokes up to prog ----
@@ -145,58 +151,86 @@ def hud_rgba(a=0.30): return HUD + (int(255*a),)
         for (x0,y0,x1,y1,cs,L) in segs:
             if cs >= target: break
             if cs+L <= target:
-                d.line([(mx(x0),my(y0)),(mx(x1),my(y1))], fill=ink, width=2)
+                d.line([(mx(x0),my(y0)),(mx(x1),my(y1))], fill=ink, width=line_w)
                 pen = (x1,y1)
             else:
                 frac = (target-cs)/L
                 xe = x0+(x1-x0)*frac; ye=y0+(y1-y0)*frac
-                d.line([(mx(x0),my(y0)),(mx(xe),my(ye))], fill=ink, width=2)
+                d.line([(mx(x0),my(y0)),(mx(xe),my(ye))], fill=ink, width=line_w)
                 pen = (xe,ye)
                 break
 
         # ---- HUD ----
         hc = hud_rgba(0.30)
-        d.text((60,60), f'BED 01 · {suit["code"]}', font=f_bed, fill=hc)
-        lw = d.textlength('PLOTFLOW*', font=f_bed)
-        d.text((W-60-lw,60), 'PLOTFLOW*', font=f_bed, fill=hc)
-        d.text((60,96), suit['name'], font=f_name, fill=hc)
-        d.text((60,122), suit.get('jp',''), font=f_jp, fill=hc)
-        fr = f'F{FEED} mm/min'
-        d.text((W-60-d.textlength(fr,font=f_small),98), fr, font=f_small, fill=hc)
-
-        bar_y = H-160
-        d.rectangle([60,bar_y,W-60,bar_y+3], fill=HUD+(26,))
-        d.rectangle([60,bar_y,60+(W-120)*prog,bar_y+3], fill=ink)
-        ink_drawn = (target*mm_per_unit)/1000
-        elapsed = total_sec*prog
-        d.text((60,bar_y+16), f'{fmt(elapsed)} / {fmt(total_sec)}', font=f_stat, fill=hc)
-        pct = f'{round(prog*100)}%'
-        d.text((W/2-d.textlength(pct,font=f_stat)/2,bar_y+16), pct, font=f_stat, fill=hc)
-        inkstr = f'{ink_drawn:.1f}m / {ink_total_m:.1f}m ink'
-        d.text((W-60-d.textlength(inkstr,font=f_stat),bar_y+16), inkstr, font=f_stat, fill=hc)
 
+        # top-left: code + name + jp
+        d.text((LM, 60*s), suit['code'], font=f_code, fill=hc)
+        d.text((LM, 96*s), suit['name'], font=f_name, fill=hc)
+        d.text((LM, 124*s), suit.get('jp',''), font=f_jp, fill=hc)
+
+        # top-right: PLOTFLOW*
+        lw = d.textlength('PLOTFLOW*', font=f_code)
+        d.text((SW-RM-lw, 60*s), 'PLOTFLOW*', font=f_code, fill=hc)
+
+        # ---- bottom stats ----
+        bar_y = SH - 180*s
+        d.rectangle([LM, bar_y, SW-RM, bar_y + 3*s], fill=HUD+(26,))
+        d.rectangle([LM, bar_y, LM + (SW-LM-RM)*prog, bar_y + 3*s], fill=ink)
+
+        ink_drawn = (target * mm_per_unit) / 1000
+        elapsed = total_sec * prog
+
+        # row 1: labels
+        r1y = bar_y + 18*s
+        d.text((LM, r1y), 'PROGRESS', font=f_label, fill=hud_rgba(0.20))
+        col2x = LM + 220*s
+        d.text((col2x, r1y), 'INK', font=f_label, fill=hud_rgba(0.20))
+        col3x = LM + 440*s
+        d.text((col3x, r1y), 'PLOT TIME', font=f_label, fill=hud_rgba(0.20))
+        col4x = LM + 700*s
+        d.text((col4x, r1y), 'POSITION', font=f_label, fill=hud_rgba(0.20))
+
+        # row 2: values
+        r2y = r1y + 22*s
+        d.text((LM, r2y), f'{round(prog*100)}%', font=f_stat, fill=hc)
+        d.text((col2x, r2y), f'{ink_drawn:.1f} / {ink_total_m:.1f}m', font=f_stat, fill=hc)
+        d.text((col3x, r2y), f'{fmt(elapsed)} / {fmt(total_sec)}', font=f_stat, fill=hc)
+        if pen:
+            d.text((col4x, r2y), f'X {round(pen[0]*mm_per_unit)}  Y {round(pen[1]*mm_per_unit)}', font=f_stat, fill=hc)
+        else:
+            d.text((col4x, r2y), '— —', font=f_stat, fill=hud_rgba(0.15))
+
+        # pen head crosshair
         if pen and 0 < prog < 1:
-            px,py = mx(pen[0]),my(pen[1]); r=14
-            d.ellipse([px-r,py-r,px+r,py+r], outline=(232,53,31,160), width=2)
-            d.line([px-r*1.8,py,px+r*1.8,py], fill=(232,53,31,160), width=2)
-            d.line([px,py-r*1.8,px,py+r*1.8], fill=(232,53,31,160), width=2)
-            d.text((60,bar_y+44), f'X {round(pen[0]*mm_per_unit)}  Y {round(pen[1]*mm_per_unit)}', font=f_small, fill=hc)
-
-        # ---- end card crossfade ----
-        if phase=='end':
-            ov = Image.new('RGBA',(W,H),(246,243,236,int(255*min(1,alpha))))
-            img = Image.alpha_composite(img.convert('RGBA'), ov).convert('RGB')
-            if alpha>0.15:
-                a2 = min(1,(alpha-0.15)/0.6)
-                d2 = ImageDraw.Draw(img,'RGBA')
+            px, py = mx(pen[0]), my(pen[1])
+            r = 14*s
+            d.ellipse([px-r,py-r,px+r,py+r], outline=(232,53,31,153), width=max(2,2*s))
+            d.line([px-r*1.8,py,px+r*1.8,py], fill=(232,53,31,153), width=max(1,s))
+            d.line([px,py-r*1.8,px,py+r*1.8], fill=(232,53,31,153), width=max(1,s))
+
+        # ---- downsample from SSx to 1x ----
+        out_img = img.resize((W, H), Image.LANCZOS)
+
+        # ---- end card crossfade (at 1x to avoid resizing text) ----
+        if phase == 'end':
+            ov = Image.new('RGBA', (W,H), (246,243,236, int(255*min(1,alpha))))
+            out_img = Image.alpha_composite(out_img.convert('RGBA'), ov).convert('RGB')
+            if alpha > 0.15:
+                a2 = min(1, (alpha-0.15)/0.6)
+                d2 = ImageDraw.Draw(out_img, 'RGBA')
+                f1_logo = ImageFont.truetype(BOLD, 88)
+                f1_name = ImageFont.truetype(BOLD, 32)
+                f1_jp   = ImageFont.truetype(JP, 30)
+                f1_tag  = ImageFont.truetype(REG, 20)
                 def ctext(y,txt,fnt,col):
-                    w=d2.textlength(txt,font=fnt); d2.text((W/2-w/2,y),txt,font=fnt,fill=col+(int(255*a2),))
-                ctext(H/2-90,'PLOTFLOW*',f_end_logo,(21,22,15))
-                ctext(H/2+10,f'{suit["code"]}  {suit["name"]}',f_end_name,(21,22,15))
-                ctext(H/2+60,suit.get('jp',''),f_end_jp,(91,94,84))
-                ctext(H-110,'DRAWN BY MACHINE · マシンドロー',f_end_tag,(143,145,132))
-
-        ff.send(np.asarray(img))
+                    tw = d2.textlength(txt,font=fnt)
+                    d2.text((W/2-tw/2, y), txt, font=fnt, fill=col+(int(255*a2),))
+                ctext(H//2-90, 'PLOTFLOW*', f1_logo, (21,22,15))
+                ctext(H//2+10, f'{suit["code"]}  {suit["name"]}', f1_name, (21,22,15))
+                ctext(H//2+60, suit.get('jp',''), f1_jp, (91,94,84))
+                ctext(H-110, 'DRAWN BY MACHINE · マシンドロー', f1_tag, (143,145,132))
+
+        ff.send(np.asarray(out_img))
 
     ff.close()
     sz = os.path.getsize(out)/1024/1024