Fix Devanagari font URL, add auto-fit text safeguard, add vignette

render_invitation.py

@@ -21,7 +21,7 @@ SOFT = (244, 229, 203)
 # ----------------------------------------------------------------- event text
 EV = dict(
     name="Mamta",
-    hindi="\u0936\u0941\u092d \u0938\u0947\u0935\u093e\u0928\u093f\u0935\u0943\u0924\u094d\u0924\u093f",  # शुभ सेवानिवृत्ति
+    hindi="\u0936\u0941\u092d \u0938\u0947\u0935\u093e\u0928\u093f\u0935\u0943\u0924\u094d\u0924\u093f",  # shubh sevanivrutti
     kicker1_en="WITH GREAT JOY",
     script1="You\u2019re Invited",
     sub1="a celebration of a beautiful journey",
@@ -46,16 +46,13 @@ EV = dict(
 )
 
 # ----------------------------------------------------------------- fonts
+GH = "https://raw.githubusercontent.com/google/fonts/main/ofl/"
 FONT_URLS = {
-    "script": ["https://raw.githubusercontent.com/google/fonts/main/ofl/greatvibes/GreatVibes-Regular.ttf"],
-    "serif": ["https://raw.githubusercontent.com/google/fonts/main/ofl/playfairdisplay/PlayfairDisplay%5Bwght%5D.ttf",
-              "https://raw.githubusercontent.com/google/fonts/main/ofl/playfairdisplay/static/PlayfairDisplay-Regular.ttf"],
-    "body": ["https://raw.githubusercontent.com/google/fonts/main/ofl/cormorantgaramond/CormorantGaramond%5Bwght%5D.ttf",
-             "https://raw.githubusercontent.com/google/fonts/main/ofl/cormorantgaramond/static/CormorantGaramond-Regular.ttf"],
-    "bodyi": ["https://raw.githubusercontent.com/google/fonts/main/ofl/cormorantgaramond/CormorantGaramond-Italic%5Bwght%5D.ttf",
-              "https://raw.githubusercontent.com/google/fonts/main/ofl/cormorantgaramond/static/CormorantGaramond-Italic.ttf"],
-    "hindi": ["https://raw.githubusercontent.com/google/fonts/main/ofl/notoserifdevanagari/NotoSerifDevanagari%5Bwght%5D.ttf",
-              "https://raw.githubusercontent.com/google/fonts/main/ofl/notoserifdevanagari/static/NotoSerifDevanagari-Regular.ttf"],
+    "script": [GH + "greatvibes/GreatVibes-Regular.ttf"],
+    "serif": [GH + "playfairdisplay/PlayfairDisplay%5Bwght%5D.ttf"],
+    "body": [GH + "cormorantgaramond/CormorantGaramond%5Bwght%5D.ttf"],
+    "bodyi": [GH + "cormorantgaramond/CormorantGaramond-Italic%5Bwght%5D.ttf"],
+    "hindi": [GH + "notoserifdevanagari/NotoSerifDevanagari%5Bwdth%2Cwght%5D.ttf"],
 }
 FPATH = {}
 for key, urls in FONT_URLS.items():
@@ -63,7 +60,7 @@ for key, urls in FONT_URLS.items():
         dest = os.path.join(FDIR, "%s_%d.ttf" % (key, i))
         try:
             req = urllib.request.Request(u, headers={"User-Agent": "Mozilla/5.0"})
-            with urllib.request.urlopen(req, timeout=60) as r, open(dest, "wb") as fh:
+            with urllib.request.urlopen(req, timeout=90) as r, open(dest, "wb") as fh:
                 fh.write(r.read())
             FPATH[key] = dest
             print("FONT OK  %-7s %8d  %s" % (key, os.path.getsize(dest), u.split("/")[-1]))
@@ -71,22 +68,31 @@ for key, urls in FONT_URLS.items():
         except Exception as e:
             print("FONT FAIL %-7s %s" % (key, repr(e)[:90]))
 HAS_RAQM = bool(features.check("raqm"))
-print("RAQM (complex text shaping):", HAS_RAQM)
+HAS_HINDI = HAS_RAQM and "hindi" in FPATH
+print("RAQM:", HAS_RAQM, "| Devanagari usable:", HAS_HINDI)
 
 _fc = {}
-def F(kind, size):
-    key = (kind, size)
+def F(kind, size, weight=None):
+    key = (kind, size, weight)
     if key in _fc:
         return _fc[key]
     path = FPATH.get(kind) or FPATH.get("serif") or FPATH.get("body")
     f = ImageFont.truetype(path, size)
+    if weight and hasattr(f, "set_variation_by_name"):
+        try:
+            f.set_variation_by_name(str(weight))
+        except Exception:
+            try:
+                f.set_variation_by_axes([weight] * len(f.get_variation_axes()))
+            except Exception:
+                pass
     _fc[key] = f
     return f
 
 # ----------------------------------------------------------------- text helper
-def text_layer(lines, kind, size, color, tracking=0, line_h=None):
-    """Render ink-cropped RGBA layer of centred text."""
-    f = F(kind, size)
+def text_layer(lines, kind, size, color, tracking=0, line_h=None, weight=None):
+    """Ink-cropped RGBA layer of centred text."""
+    f = F(kind, size, weight)
     tmp = Image.new("RGBA", (8, 8)); td = ImageDraw.Draw(tmp)
     lh = line_h or int(size * 1.30)
     widths = []
@@ -98,20 +104,30 @@ def text_layer(lines, kind, size, color, tracking=0, line_h=None):
     pad = int(size * 0.9) + 14
     lw = int(max(widths)) + 2 * pad
     lht = int(lh * len(lines)) + 2 * pad
-    lay = Image.new("RGBA", (lw, lht), (0, 0, 0, 0))
+    lay = Image.new("RGBA", (max(8, lw), max(8, lht)), (0, 0, 0, 0))
     d = ImageDraw.Draw(lay)
     for i, ln in enumerate(lines):
-        base = pad + lh * i + lh * 0.80
         if tracking:
             x = (lw - widths[i]) / 2.0
             for ch in ln:
-                d.text((x, base), ch, font=f, fill=color + (255,), anchor="ls")
+                d.text((x, pad + lh * i + lh * 0.80), ch, font=f, fill=color + (255,), anchor="ls")
                 x += td.textlength(ch, font=f) + tracking
         else:
             d.text((lw / 2.0, pad + lh * i + lh / 2.0), ln, font=f, fill=color + (255,), anchor="mm")
     bb = lay.getbbox()
     return lay.crop(bb) if bb else lay
 
+def fit_layer(lines, kind, size, color, max_w, tracking=0, line_h=None, weight=None):
+    """Shrink the point size until the rendered ink fits inside max_w pixels."""
+    s = size
+    lay = None
+    while s > 18:
+        lay = text_layer(lines, kind, s, color, tracking=tracking, line_h=line_h, weight=weight)
+        if lay.size[0] <= max_w:
+            return lay
+        s = int(s * 0.94)
+    return lay
+
 def alpha_scale(sprite, a):
     if a >= 0.999:
         return sprite
@@ -128,22 +144,20 @@ def alpha_variants(sprite, n=12):
         out.append(Image.fromarray(arr.astype(np.uint8), "RGBA"))
     return out
 
-def paste(dst, lay, cx, cy, alpha, dx=0.0, dy=0.0, anchor="c"):
-    if alpha <= 0.004:
+def paste(dst, lay, cx, cy, alpha, dy=0.0):
+    if lay is None or alpha <= 0.004:
         return
     im = alpha_scale(lay, alpha) if alpha < 0.999 else lay
-    if anchor == "c":
-        x = int(cx - lay.size[0] / 2 + dx); y = int(cy - lay.size[1] / 2 + dy)
-    else:  # top-left
-        x = int(cx + dx); y = int(cy + dy)
-    if x + im.size[0] < 0 or y + im.size[1] < 0 or x > W or y > H:
+    x = int(cx - lay.size[0] / 2.0); y = int(cy - lay.size[1] / 2.0 + dy)
+    if x >= W or y >= H or x + im.size[0] <= 0 or y + im.size[1] <= 0:
         return
     dst.alpha_composite(im, (x, y))
 
 def rule_strip(w, alpha, thickness=2):
-    ramp = np.linspace(0.0, 1.0, max(2, w))
+    w = max(2, int(w))
+    ramp = np.linspace(0.0, 1.0, w)
     a = (np.sin(np.pi * ramp) ** 1.4 * 255 * alpha).astype(np.uint8)
-    st = np.zeros((thickness, max(2, w), 4), dtype=np.uint8)
+    st = np.zeros((thickness, w, 4), dtype=np.uint8)
     st[..., 0], st[..., 1], st[..., 2] = GOLD[0], GOLD[1], GOLD[2]
     st[..., 3] = a
     return Image.fromarray(st, "RGBA")
@@ -155,8 +169,9 @@ def build_bg():
     bg = np.repeat(bg, W, axis=1).astype(np.float32)
     yy, xx = np.mgrid[0:H, 0:W].astype(np.float32)
     d = np.sqrt(((xx - W * 0.5) / (W * 0.80)) ** 2 + ((yy - H * 0.40) / (H * 0.52)) ** 2)
-    glow = np.clip(1 - d, 0, 1) ** 2.3
-    bg += glow[..., None] * np.array([118, 58, 18], dtype=np.float32)[None, None, :]
+    bg += (np.clip(1 - d, 0, 1) ** 2.3)[..., None] * np.array([118, 58, 18], dtype=np.float32)[None, None, :]
+    v = np.sqrt(((xx - W * 0.5) / (W * 0.56)) ** 2 + ((yy - H * 0.5) / (H * 0.60)) ** 2)
+    bg *= (1.0 - 0.42 * np.clip(v, 0, 1) ** 2.4)[..., None]
     return Image.fromarray(np.clip(bg, 0, 255).astype(np.uint8), "RGB")
 
 def build_frame():
@@ -188,8 +203,8 @@ def build_toran(height=210):
             col = MARIGOLD if i % 2 == 0 else ORANGE
             d.ellipse([x - r, yy - r, x + r, yy + r], fill=col + (238,))
             d.ellipse([x - r * 0.34, yy - r * 0.55, x + r * 0.18, yy - r * 0.12], fill=(255, 236, 196, 130))
-        jx = x1 if k < 3 else None
-        if jx:
+        if k < 3:
+            jx = x1
             d.polygon([(jx, 108), (jx - 13, 92), (jx, 74), (jx + 13, 92)], fill=(58, 122, 74, 210))
     for x in (W * 0.25, W * 0.5, W * 0.75):
         d.line([x, 118, x, 176], fill=GOLD_L + (170,), width=2)
@@ -211,9 +226,8 @@ def build_mandala(size=1040):
         ImageDraw.Draw(p).ellipse([0, 0, pw - 1, ph - 1], outline=GOLD_L + (85,), width=int(1.5 * S))
         p = p.rotate(-ang, expand=True, resample=Image.BICUBIC)
         r = s * 0.368 / 2.0
-        x = c + r * math.cos(math.radians(ang)) - p.size[0] / 2.0
-        y = c + r * math.sin(math.radians(ang)) - p.size[1] / 2.0
-        im.alpha_composite(p, (int(x), int(y)))
+        im.alpha_composite(p, (int(c + r * math.cos(math.radians(ang)) - p.size[0] / 2),
+                               int(c + r * math.sin(math.radians(ang)) - p.size[1] / 2)))
     for i in range(48):
         ang = 360.0 * i / 48
         r = s * 0.248 / 2.0
@@ -233,11 +247,10 @@ def build_diya(size=200):
     d.polygon([(fx, fy - s * 0.175), (fx - s * 0.033, fy - s * 0.005), (fx + s * 0.033, fy - s * 0.005)], fill=(255, 250, 226, 255))
     return im.resize((size, size), Image.LANCZOS)
 
-def build_glow(size=420, radius=170.0):
+def build_glow(size=430, radius=175.0):
     yy, xx = np.mgrid[0:size, 0:size]
     c = (size - 1) / 2.0
-    d = np.sqrt((xx - c) ** 2 + (yy - c) ** 2) / radius
-    g = np.clip(1 - d, 0, 1) ** 2.4
+    g = np.clip(1 - np.sqrt((xx - c) ** 2 + (yy - c) ** 2) / radius, 0, 1) ** 2.4
     arr = np.zeros((size, size, 4), dtype=np.uint8)
     arr[..., 0], arr[..., 1], arr[..., 2] = 255, 176, 70
     arr[..., 3] = (g * 195).astype(np.uint8)
@@ -246,8 +259,7 @@ def build_glow(size=420, radius=170.0):
 def build_mote(size=26):
     yy, xx = np.mgrid[0:size, 0:size]
     c = (size - 1) / 2.0
-    r = np.sqrt((xx - c) ** 2 + (yy - c) ** 2) / c
-    g = np.clip(1 - r, 0, 1) ** 2.0
+    g = np.clip(1 - np.sqrt((xx - c) ** 2 + (yy - c) ** 2) / c, 0, 1) ** 2.0
     arr = np.zeros((size, size, 4), dtype=np.uint8)
     arr[..., 0], arr[..., 1], arr[..., 2] = 244, 214, 150
     arr[..., 3] = (g * 210).astype(np.uint8)
@@ -261,8 +273,7 @@ def build_lotus(size=124):
         ImageDraw.Draw(p).ellipse([0, 0, pw - 1, ph - 1], outline=GOLD_L + (215,), width=3)
         p = p.rotate(-(i * 30), expand=True, resample=Image.BICUBIC)
         im.alpha_composite(p, (size // 2 - p.size[0] // 2, size // 2 - p.size[1] // 2))
-    d = ImageDraw.Draw(im)
-    d.ellipse([size / 2 - 8, size / 2 - 8, size / 2 + 8, size / 2 + 8], fill=MARIGOLD + (235,))
+    ImageDraw.Draw(im).ellipse([size / 2 - 8, size / 2 - 8, size / 2 + 8, size / 2 + 8], fill=MARIGOLD + (235,))
     return im
 
 def build_monogram(D=600):
@@ -273,20 +284,18 @@ def build_monogram(D=600):
     d.ellipse([34, 34, D - 34, D - 34], outline=GOLD_L + (70,), width=1)
     for i in range(14):
         ang = 360.0 * i / 14
-        pw, ph = int(D * 0.19), int(D * 0.075)
-        p = Image.new("RGBA", (pw, ph), (0, 0, 0, 0))
-        ImageDraw.Draw(p).ellipse([0, 0, pw - 1, ph - 1], outline=GOLD_L + (120,), width=2)
+        p = Image.new("RGBA", (int(D * 0.19), int(D * 0.075)), (0, 0, 0, 0))
+        ImageDraw.Draw(p).ellipse([0, 0, p.size[0] - 1, p.size[1] - 1], outline=GOLD_L + (120,), width=2)
         p = p.rotate(-ang, expand=True, resample=Image.BICUBIC)
         r = D * 0.415
-        x = c + r * math.cos(math.radians(ang)) - p.size[0] / 2.0
-        y = c + r * math.sin(math.radians(ang)) - p.size[1] / 2.0
-        im.alpha_composite(p, (int(x), int(y)))
+        im.alpha_composite(p, (int(c + r * math.cos(math.radians(ang)) - p.size[0] / 2),
+                               int(c + r * math.sin(math.radians(ang)) - p.size[1] / 2)))
     lay = text_layer([EV["name"][0].upper()], "script", int(D * 0.60), CREAM)
     im.alpha_composite(lay, (int(c - lay.size[0] / 2), int(c - lay.size[1] / 2)))
     return im
 
 def make_card(width, title, sections, title_size=66, label_size=26, value_size=46, alpha=205):
-    Hc = 1400
+    Hc = 1500
     card = Image.new("RGBA", (width, Hc), (0, 0, 0, 0))
     S = 2
     tmp = Image.new("RGBA", (width * S, Hc * S), (0, 0, 0, 0))
@@ -295,7 +304,7 @@ def make_card(width, title, sections, title_size=66, label_size=26, value_size=4
     card.alpha_composite(tmp.resize((width, Hc), Image.LANCZOS), (0, 0))
     y = 74
     if title:
-        tl = text_layer([title], "script", title_size, GOLD)
+        tl = fit_layer([title], "script", title_size, GOLD, width - 110)
         card.alpha_composite(tl, (int(width / 2 - tl.size[0] / 2), int(y)))
         y += tl.size[1] + 30
         rw = int(width * 0.44)
@@ -310,13 +319,12 @@ def make_card(width, title, sections, title_size=66, label_size=26, value_size=4
         card.alpha_composite(ll, (int(width / 2 - ll.size[0] / 2), int(y)))
         y += ll.size[1] + 22
         for v in sec["values"]:
-            vl = text_layer([v], "body", value_size, CREAM)
+            vl = fit_layer([v], "body", value_size, CREAM, width - 96)
             card.alpha_composite(vl, (int(width / 2 - vl.size[0] / 2), int(y)))
             y += vl.size[1] + 12
         y += 18
     used = y + 40
-    tl2 = build_lotus(64)
-    card.alpha_composite(tl2, (int(width / 2 - 32), int(used - 20)))
+    card.alpha_composite(build_lotus(64), (int(width / 2 - 32), int(used - 20)))
     return card.crop((0, 0, width, min(Hc, used + 54)))
 
 # ----------------------------------------------------------------- build assets
@@ -337,52 +345,49 @@ MOTES = [dict(x=random.uniform(70, W - 70), y=random.uniform(0, H), sp=random.un
               sw=random.uniform(0.25, 0.7), ph=random.uniform(0, 6.28), big=random.random() < 0.45)
          for _ in range(16)]
 
-kicker1 = text_layer([EV["hindi"]], "hindi", 44, GOLD) if HAS_RAQM else \
+MAXW = 880  # keep clear of the gold frame
+kicker1 = text_layer([EV["hindi"]], "hindi", 46, GOLD) if HAS_HINDI else \
           text_layer([EV["kicker1_en"]], "serif", 34, GOLD, tracking=13)
-if HAS_RAQM:
-    k1_extra = text_layer([EV["kicker1_en"]], "serif", 26, GOLD, tracking=11)
-else:
-    k1_extra = None
+k1_extra = text_layer([EV["kicker1_en"]], "serif", 26, GOLD, tracking=11) if HAS_HINDI else None
 
-L_script1 = text_layer([EV["script1"]], "script", 158, GOLD)
-L_sub1 = text_layer([EV["sub1"]], "bodyi", 46, SOFT)
+L_script1 = fit_layer([EV["script1"]], "script", 158, GOLD, MAXW)
+L_sub1 = fit_layer([EV["sub1"]], "bodyi", 46, SOFT, MAXW)
 L_kick2 = text_layer([EV["kicker2"]], "serif", 32, GOLD, tracking=15)
-L_name = text_layer([EV["name"]], "script", 248, CREAM)
-L_name_glow = alpha_scale(text_layer([EV["name"]], "script", 248, GOLD).filter(ImageFilter.GaussianBlur(16)), 0.55)
-L_body2 = text_layer([EV["body2"]], "bodyi", 47, SOFT)
+L_name = fit_layer([EV["name"]], "script", 250, CREAM, MAXW)
+L_name_glow = alpha_scale(fit_layer([EV["name"]], "script", 250, GOLD, MAXW).filter(ImageFilter.GaussianBlur(16)), 0.55)
+L_body2 = fit_layer([EV["body2"]], "bodyi", 47, SOFT, MAXW)
 L_small2 = text_layer([EV["small2"]], "serif", 28, GOLD, tracking=10)
 CARD_D = make_card(832, EV["card_title"], [
     dict(label=EV["when_label"], values=[EV["when_1"], EV["when_2"]]),
     dict(label=EV["where_label"], values=[EV["where_1"]]),
 ])
-L_sub3 = text_layer([EV["sub3"]], "bodyi", 42, SOFT)
+L_sub3 = fit_layer([EV["sub3"]], "bodyi", 42, SOFT, MAXW)
 MONO = build_monogram(600)
-L_quote = text_layer(EV["quote"], "bodyi", 47, SOFT, line_h=76)
+L_quote = fit_layer(EV["quote"], "bodyi", 47, SOFT, MAXW - 60, line_h=76)
 L_kick3 = text_layer(["THE CELEBRATION"], "serif", 32, GOLD, tracking=15)
-L_script5 = text_layer([EV["script5"]], "script", 104, GOLD)
-L_body5 = text_layer([EV["body5"]], "bodyi", 43, SOFT)
-L_name5 = text_layer([EV["name"]], "script", 152, CREAM)
+L_script5 = fit_layer([EV["script5"]], "script", 104, GOLD, MAXW)
+L_body5 = fit_layer([EV["body5"]], "bodyi", 43, SOFT, MAXW)
+L_name5 = fit_layer([EV["name"]], "script", 152, CREAM, MAXW)
 CARD_R = make_card(700, None, [dict(label=EV["rsvp_label"], values=[EV["rsvp_value"]])],
                    label_size=28, value_size=44)
 L_kick6 = text_layer([EV["kicker6"]], "serif", 32, GOLD, tracking=15)
-L_script6 = text_layer([EV["script6"]], "script", 136, GOLD)
-L_sig = text_layer([EV["sig"]], "script", 80, CREAM)
+L_script6 = fit_layer([EV["script6"]], "script", 136, GOLD, MAXW)
+L_sig = fit_layer([EV["sig"]], "script", 80, CREAM, MAXW)
 
 # ----------------------------------------------------------------- timeline
 DUR = [4.0, 5.0, 6.5, 5.5, 5.5, 5.5]
-OV, HOLD = 0.55, 2.0
-start = []
-acc = 0.0
+OV, HOLD, FADES = 0.55, 2.0, 0.75
+start, acc = [], 0.0
 for d in DUR:
     start.append(acc); acc += d - OV
 LAST_END = start[-1] + DUR[-1]
 TOTAL = LAST_END + HOLD
-FADES = 0.75
 NF = int(round(TOTAL * FPS))
-print("timeline:", [round(s, 2) for s in start], "last end", round(LAST_END, 2), "total", round(TOTAL, 2), "frames", NF)
+print("timeline start:", [round(s, 2) for s in start], "total %.2fs %d frames" % (TOTAL, NF))
 
 def scene_alpha(i, t):
-    s, e = start[i], (TOTAL if i == len(DUR) - 1 else start[i] + DUR[i])
+    s = start[i]
+    e = TOTAL if i == len(DUR) - 1 else start[i] + DUR[i]
     if t < s or t > e:
         return 0.0
     if i + 1 < len(DUR) and t >= start[i + 1]:
@@ -397,44 +402,21 @@ def ease(t, delay, dur=0.95):
         return 1.0
     return 1.0 - (1.0 - x) ** 3
 
-# item = (layer, xf, yf, delay, dy, dur, anchor)
 ITEMS = [
-    [(kicker1, 0.5, 0.278, 0.10, 40, 0.9, "c"),
-     (k1_extra, 0.5, 0.325, 0.28, 34, 0.9, "c"),
-     (L_script1, 0.5, 0.408, 0.48, 62, 1.05, "c"),
-     (LOTUS, 0.5, 0.497, 0.88, 18, 0.8, "c"),
-     (L_sub1, 0.5, 0.556, 1.05, 40, 0.9, "c")],
-
-    [(L_kick2, 0.5, 0.297, 0.10, 38, 0.9, "c"),
-     (L_name_glow, 0.5, 0.415, 0.42, 58, 1.1, "c"),
-     (L_name, 0.5, 0.415, 0.42, 58, 1.1, "c"),
-     (LOTUS, 0.5, 0.525, 0.88, 18, 0.8, "c"),
-     (L_body2, 0.5, 0.588, 1.00, 40, 0.9, "c"),
-     (L_small2, 0.5, 0.650, 1.20, 30, 0.9, "c")],
-
-    [(L_kick3, 0.5, 0.252, 0.10, 38, 0.9, "c"),
-     (CARD_D, 0.5, 0.488, 0.40, 56, 1.05, "c"),
-     (L_sub3, 0.5, 0.732, 1.05, 40, 0.9, "c")],
-
-    [(MONO, 0.5, 0.400, 0.20, 50, 1.05, "c"),
-     (LOTUS_S, 0.5, 0.548, 0.90, 18, 0.8, "c"),
-     (L_quote, 0.5, 0.648, 1.05, 44, 1.0, "c")],
-
-    [(L_script5, 0.5, 0.286, 0.15, 50, 1.0, "c"),
-     (L_body5, 0.5, 0.362, 0.52, 40, 0.9, "c"),
-     (L_name5, 0.5, 0.441, 0.80, 56, 1.05, "c"),
-     (CARD_R, 0.5, 0.615, 1.10, 50, 1.0, "c")],
-
-    [(L_kick6, 0.5, 0.336, 0.15, 36, 0.9, "c"),
-     (L_script6, 0.5, 0.428, 0.45, 58, 1.05, "c"),
-     (LOTUS, 0.5, 0.515, 0.88, 18, 0.8, "c"),
-     (L_sig, 0.5, 0.578, 1.08, 44, 0.95, "c")],
+    [(kicker1, 0.278, 0.10, 40, 0.9), (k1_extra, 0.325, 0.28, 34, 0.9),
+     (L_script1, 0.408, 0.48, 62, 1.05), (LOTUS, 0.497, 0.88, 18, 0.8),
+     (L_sub1, 0.556, 1.05, 40, 0.9)],
+    [(L_kick2, 0.297, 0.10, 38, 0.9), (L_name_glow, 0.415, 0.42, 58, 1.1), (L_name, 0.415, 0.42, 58, 1.1),
+     (LOTUS, 0.525, 0.88, 18, 0.8), (L_body2, 0.588, 1.00, 40, 0.9), (L_small2, 0.650, 1.20, 30, 0.9)],
+    [(L_kick3, 0.252, 0.10, 38, 0.9), (CARD_D, 0.488, 0.40, 56, 1.05), (L_sub3, 0.732, 1.05, 40, 0.9)],
+    [(MONO, 0.400, 0.20, 50, 1.05), (LOTUS_S, 0.548, 0.90, 18, 0.8), (L_quote, 0.648, 1.05, 44, 1.0)],
+    [(L_script5, 0.286, 0.15, 50, 1.0), (L_body5, 0.362, 0.52, 40, 0.9), (L_name5, 0.441, 0.80, 56, 1.05),
+     (CARD_R, 0.615, 1.10, 50, 1.0)],
+    [(L_kick6, 0.336, 0.15, 36, 0.9), (L_script6, 0.428, 0.45, 58, 1.05), (LOTUS, 0.515, 0.88, 18, 0.8),
+     (L_sig, 0.578, 1.08, 44, 0.95)],
 ]
 
-def rgba_layer_to_box(lay):
-    return lay
-
-def render(t, poster=False):
+def render(t):
     img = BG.copy()
     mand = MANDALA.rotate((t * 7.5) % 360.0, resample=Image.BICUBIC)
     img.alpha_composite(mand, (int(W / 2 - mand.size[0] / 2), int(H * 0.455 - mand.size[1] / 2)))
@@ -442,63 +424,55 @@ def render(t, poster=False):
     img.alpha_composite(FRAME, (0, 0))
     for ph_i, cx in enumerate((148, W - 148)):
         fl = 0.68 + 0.24 * math.sin(t * 7.2 + ph_i * 1.9) + 0.10 * math.sin(t * 16.7 + ph_i * 2.4)
-        fl = max(0.30, min(1.0, fl))
-        g = GLOWS[int(fl * 11)]
-        cy = H - 168
-        img.alpha_composite(g, (int(cx - g.size[0] / 2), int(cy - g.size[1] / 2 - 46)))
-        img.alpha_composite(DIYA, (int(cx - DIYA.size[0] / 2), int(cy - DIYA.size[1] / 2 - 46)))
+        g = GLOWS[int(max(0.30, min(1.0, fl)) * 11)]
+        cy = H - 214
+        img.alpha_composite(g, (int(cx - g.size[0] / 2), int(cy - g.size[1] / 2)))
+        img.alpha_composite(DIYA, (int(cx - DIYA.size[0] / 2), int(cy - DIYA.size[1] / 2)))
     for m in MOTES:
         yy = (m["y"] - m["sp"] * t) % (H + 240) - 120
         xx = m["x"] + 26 * math.sin(t * m["sw"] + m["ph"])
         al = 0.22 + 0.62 * max(0.0, math.sin(t * 0.85 + m["ph"]))
-        idx = max(0, min(11, int(al * 11)))
-        sp = MOTE_V[idx] if m["big"] else MOTE_S[idx]
+        sp = (MOTE_V if m["big"] else MOTE_S)[max(0, min(11, int(al * 11)))]
         px, py = int(xx - sp.size[0] / 2), int(yy - sp.size[1] / 2)
-        if -sp.size[0] < px < W and -sp.size[1] < py < H:
-            img.alpha_composite(sp, (max(0, px), max(0, py)) if (px >= 0 and py >= 0) else (px, py))
+        if px >= 0 and py >= 0 and px < W and py < H:
+            img.alpha_composite(sp, (px, py))
     for i in range(len(DUR)):
         sa = scene_alpha(i, t)
         if sa <= 0.004:
             continue
         tl = t - start[i]
-        for (lay, xf, yf, delay, dy, dur, an) in ITEMS[i]:
-            a = ease(tl, delay, dur) * sa
-            if an == "c":
-                paste(img, lay, W * xf, H * yf, a, dy=(1 - ease(tl, delay, dur)) * dy)
-            else:
-                paste(img, lay, W * xf, H * yf, a, dy=(1 - ease(tl, delay, dur)) * dy, anchor="tl")
-    if poster:
-        return img.convert("RGB")
+        for (lay, yf, delay, dy, dur) in ITEMS[i]:
+            if lay is None:
+                continue
+            e = ease(tl, delay, dur)
+            paste(img, lay, W / 2.0, H * yf, e * sa, dy=(1.0 - e) * dy)
+    rgb = img.convert("RGB")
+    k = 1.0
     if t < FADES:
         k = t / FADES
     elif t > TOTAL - FADES:
         k = max(0.0, (TOTAL - t) / FADES)
-    else:
-        k = 1.0
-    rgb = img.convert("RGB")
     if k < 1.0:
-        arr = np.asarray(rgb, dtype=np.float32) * k
-        return Image.fromarray(arr.astype(np.uint8), "RGB")
+        return Image.fromarray((np.asarray(rgb, dtype=np.float32) * k).astype(np.uint8), "RGB")
     return rgb
 
 # ----------------------------------------------------------------- encode
 from imageio_ffmpeg import get_ffmpeg_exe
 FFMPEG = get_ffmpeg_exe()
 print("ffmpeg:", FFMPEG)
-cmd = [FFMPEG, "-y", "-loglevel", "error", "-f", "rawvideo", "-pix_fmt", "rgb24",
-       "-s", "%dx%d" % (W, H), "-r", str(FPS), "-i", "-",
-       "-c:v", "libx264", "-preset", "medium", "-crf", "20", "-pix_fmt", "yuv420p",
-       "-movflags", "+faststart", "-an", OUT]
-proc = subprocess.Popen(cmd, stdin=subprocess.PIPE)
+proc = subprocess.Popen([FFMPEG, "-y", "-loglevel", "error", "-f", "rawvideo", "-pix_fmt", "rgb24",
+                         "-s", "%dx%d" % (W, H), "-r", str(FPS), "-i", "-",
+                         "-c:v", "libx264", "-preset", "medium", "-crf", "20", "-pix_fmt", "yuv420p",
+                         "-movflags", "+faststart", "-an", OUT], stdin=subprocess.PIPE)
 
 poster_t = start[1] + 2.6
 for n in range(NF):
     t = n / float(FPS)
-    fr = render(t, poster=(abs(t - poster_t) < 0.5 / FPS))
+    fr = render(t)
     if abs(t - poster_t) < 0.5 / FPS:
         fr.save(POSTER, quality=92)
     proc.stdin.write(np.asarray(fr, dtype=np.uint8).tobytes())
-    if n % 120 == 0:
+    if n % 100 == 0:
         print("frame %4d / %d  (t=%.1fs)" % (n, NF, t), flush=True)
 proc.stdin.close()
 proc.wait()
@@ -507,11 +481,9 @@ print("encoded:", OUT, os.path.getsize(OUT), "bytes")
 # ----------------------------------------------------------------- upload
 from huggingface_hub import HfApi
 REPO = os.environ.get("REPO_ID", "coderdecoder01/retirement-invitation-mamta")
-tok = os.environ.get("HF_TOKEN")
-api = HfApi(token=tok)
+api = HfApi(token=os.environ.get("HF_TOKEN"))
 api.create_repo(repo_id=REPO, repo_type="dataset", private=False, exist_ok=True)
-api.upload_file(path_or_fileobj=OUT, path_in_repo="mamta-retirement-invitation.mp4",
-                repo_id=REPO, repo_type="dataset")
+api.upload_file(path_or_fileobj=OUT, path_in_repo="mamta-retirement-invitation.mp4", repo_id=REPO, repo_type="dataset")
 api.upload_file(path_or_fileobj=POSTER, path_in_repo="poster.jpg", repo_id=REPO, repo_type="dataset")
-print("UPLOADED https://huggingface.co/datasets/%s/resolve/main/mamta-retirement-invitation.mp4" % REPO)
-print("POSTER   https://huggingface.co/datasets/%s/resolve/main/poster.jpg" % REPO)
+print("VIDEO  https://huggingface.co/datasets/%s/resolve/main/mamta-retirement-invitation.mp4" % REPO)
+print("POSTER https://huggingface.co/datasets/%s/resolve/main/poster.jpg" % REPO)