| |
| """ |
| Indian-style animated retirement invitation for Mamta: 1080x1920, 30fps, H.264 + AAC MP4. |
| Maroon/gold palette, rotating mandala, marigold toran, flickering diyas, colour emoji. |
| v5: her exact quote wording + original synthesised soundtrack (tanpura, sitar melody, bells). |
| """ |
| import os, math, subprocess, urllib.request, random, wave |
| import numpy as np |
| from PIL import Image, ImageDraw, ImageFont, ImageFilter, features |
|
|
| W, H, FPS = 1080, 1920, 30 |
| SR = 44100 |
| OUT = "/tmp/mamta_retirement_invitation.mp4" |
| WAV = "/tmp/soundtrack.wav" |
| POSTER = "/tmp/poster.jpg" |
| FDIR = "/tmp/fonts" |
| os.makedirs(FDIR, exist_ok=True) |
|
|
| BG_TOP, BG_BOT = (78, 15, 36), (44, 7, 20) |
| GOLD, GOLD_D, GOLD_L = (232, 193, 115), (201, 150, 47), (245, 222, 166) |
| CREAM, MARIGOLD, ORANGE = (253, 243, 224), (240, 160, 42), (226, 112, 28) |
| SOFT = (246, 234, 212) |
|
|
| |
| EV = dict( |
| name="Mamta", |
| hindi="\u0936\u0941\u092d \u0938\u0947\u0935\u093e\u0928\u093f\u0935\u0943\u0924\u094d\u0924\u093f", |
| kicker1_en="WITH GREAT JOY", |
| script1="You\u2019re Invited", |
| sub1="a celebration of a beautiful journey", |
| kicker2="IN HONOUR OF", |
| body2="on the joyous occasion of her retirement", |
| small2="30 SEPTEMBER 2026", |
| message=[ |
| dict(kind="bodyi", size=54, color=CREAM, weight=600, |
| lines=["\u201cThe bell is ringing one last time\u2026\u201d"]), |
| dict(kind="serif", size=48, color=CREAM, weight=500, |
| lines=["It is now time to say goodbye", "to my teaching profession."]), |
| dict(kind="serif", size=46, color=CREAM, weight=500, |
| lines=["To seek your good wishes & blessings,", "a party has been organised."]), |
| ], |
| msg_sig="\u2014 Mamta", |
| msg_foot="A LIFETIME OF TEACHING", |
| card_title="Celebratory Lunch", |
| when_label="WHEN", |
| when_1="Wednesday, 30 September 2026", |
| time_label="TIME", |
| time_1="13.30 hrs (1:30 pm)", |
| where_label="WHERE", |
| where_1="New Ros Common, Kasauli", |
| sub3="Your presence will make it complete", |
| quote=["The bell has rung,", "but the lessons will echo on."], |
| kicker6="WITH LOVE AND BLESSINGS", |
| script6="Celebrate With You", |
| sig="Mamta & family", |
| ) |
|
|
| |
| GH = "https://raw.githubusercontent.com/google/fonts/main/ofl/" |
| EMOJI_URLS = [ |
| "https://raw.githubusercontent.com/googlefonts/noto-emoji/main/fonts/NotoColorEmoji.ttf", |
| "https://raw.githubusercontent.com/googlefonts/noto-emoji/main/fonts/Noto-COLRv1-emojicompat.ttf", |
| ] |
| FONT_URLS = { |
| "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"], |
| } |
|
|
| def fetch(url, dest): |
| req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"}) |
| with urllib.request.urlopen(req, timeout=120) as r, open(dest, "wb") as fh: |
| fh.write(r.read()) |
| return os.path.getsize(dest) |
|
|
| FPATH = {} |
| for key, urls in FONT_URLS.items(): |
| for i, u in enumerate(urls): |
| dest = os.path.join(FDIR, "%s_%d.ttf" % (key, i)) |
| try: |
| print("FONT OK %-7s %8d %s" % (key, fetch(u, dest), u.split("/")[-1]), flush=True) |
| FPATH[key] = dest |
| break |
| except Exception as e: |
| print("FONT FAIL %-7s %s" % (key, repr(e)[:90]), flush=True) |
|
|
| HAS_RAQM = bool(features.check("raqm")) |
| HAS_HINDI = HAS_RAQM and "hindi" in FPATH |
| print("RAQM:", HAS_RAQM, "| Devanagari usable:", HAS_HINDI, flush=True) |
|
|
| def _set_weight(f, weight): |
| if not weight: |
| return |
| try: |
| axes = f.get_variation_axes() |
| except Exception: |
| return |
| vals = [] |
| for ax in axes: |
| name = ax.get("name", "") if isinstance(ax, dict) else getattr(ax, "name", "") |
| dflt = ax.get("default", 0) if isinstance(ax, dict) else getattr(ax, "default", 0) |
| vals.append(weight if "eight" in str(name) else dflt) |
| try: |
| f.set_variation_by_axes(vals) |
| except Exception as e: |
| print(" weight FAIL %s" % repr(e)[:80], flush=True) |
|
|
| _fc = {} |
| 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) |
| _set_weight(f, weight) |
| _fc[key] = f |
| return f |
|
|
| |
| EMOJI_PATH, EMOJI_SIZE = None, 109 |
| for i, u in enumerate(EMOJI_URLS): |
| dest = os.path.join(FDIR, "emoji_%d.ttf" % i) |
| try: |
| fetch(u, dest) |
| except Exception as e: |
| print("EMOJI download failed: %s" % repr(e)[:80], flush=True) |
| continue |
| for size in (109, 137, 128, 96, 160, 72, 48): |
| ok = False |
| try: |
| f = ImageFont.truetype(dest, size) |
| probe = Image.new("RGBA", (size * 2, size * 2), (0, 0, 0, 0)) |
| ImageDraw.Draw(probe).text((size, size), "\U0001F339", font=f, |
| embedded_color=True, anchor="mm") |
| bb = probe.getbbox() |
| cov = float((np.array(probe.crop(bb))[..., 3] > 30).mean()) if bb else 0.0 |
| if bb and cov > 0.25: |
| EMOJI_PATH, EMOJI_SIZE, ok = dest, size, True |
| print("EMOJI OK %s size=%d coverage=%.2f" % (u.split("/")[-1], size, cov), flush=True) |
| except Exception as e: |
| print("EMOJI size %d failed: %s" % (size, repr(e)[:70]), flush=True) |
| if ok: |
| break |
| if EMOJI_PATH: |
| break |
|
|
| def emoji_layer(chars, height, spacing=16): |
| if EMOJI_PATH is None: |
| return None |
| try: |
| f = ImageFont.truetype(EMOJI_PATH, EMOJI_SIZE) |
| except Exception: |
| return None |
| imgs = [] |
| for ch in chars: |
| canvas = Image.new("RGBA", (EMOJI_SIZE * 2, EMOJI_SIZE * 2), (0, 0, 0, 0)) |
| try: |
| ImageDraw.Draw(canvas).text((EMOJI_SIZE, EMOJI_SIZE), ch, font=f, |
| embedded_color=True, anchor="mm") |
| except Exception: |
| return None |
| bb = canvas.getbbox() |
| if not bb: |
| return None |
| imgs.append(canvas.crop(bb)) |
| out = [] |
| for g in imgs: |
| s = height / float(g.size[1]) |
| out.append(g.resize((max(1, int(g.size[0] * s)), height), Image.LANCZOS)) |
| tw = sum(g.size[0] for g in out) + spacing * (len(out) - 1) |
| lay = Image.new("RGBA", (tw, height), (0, 0, 0, 0)) |
| x = 0 |
| for g in out: |
| lay.alpha_composite(g, (x, 0)); x += g.size[0] + spacing |
| return lay |
|
|
| |
| def text_layer(lines, kind, size, color, tracking=0, line_h=None, weight=None): |
| f = F(kind, size, weight) |
| tmp = Image.new("RGBA", (8, 8)); td = ImageDraw.Draw(tmp) |
| lh = line_h or int(size * 1.32) |
| widths = [] |
| for ln in lines: |
| if tracking: |
| widths.append(sum(td.textlength(c, font=f) for c in ln) + tracking * max(0, len(ln) - 1)) |
| else: |
| widths.append(td.textlength(ln, font=f)) |
| pad = int(size * 0.9) + 14 |
| lw = int(max(widths)) + 2 * pad |
| lht = int(lh * len(lines)) + 2 * pad |
| lay = Image.new("RGBA", (max(8, lw), max(8, lht)), (0, 0, 0, 0)) |
| d = ImageDraw.Draw(lay) |
| for i, ln in enumerate(lines): |
| if tracking: |
| x = (lw - widths[i]) / 2.0 |
| for ch in ln: |
| 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): |
| s, lay = size, 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 |
| arr = np.array(sprite, dtype=np.uint16) |
| arr[..., 3] = (arr[..., 3] * a).astype(np.uint16) |
| return Image.fromarray(arr.astype(np.uint8), "RGBA") |
|
|
| def alpha_variants(sprite, n=12): |
| base = np.array(sprite, dtype=np.uint16) |
| out = [] |
| for i in range(n): |
| arr = base.copy() |
| arr[..., 3] = (arr[..., 3] * (i / float(n - 1))).astype(np.uint16) |
| out.append(Image.fromarray(arr.astype(np.uint8), "RGBA")) |
| return out |
|
|
| 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 |
| 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): |
| w = max(2, int(w)) |
| a = (np.sin(np.pi * np.linspace(0.0, 1.0, w)) ** 1.4 * 255 * alpha).astype(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") |
|
|
| |
| def build_bg(): |
| y = np.linspace(0, 1, H)[:, None] |
| bg = np.array(BG_TOP)[None, None, :] * (1 - y[..., None]) + np.array(BG_BOT)[None, None, :] * y[..., None] |
| 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) |
| 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.34 * np.clip(v, 0, 1) ** 2.4)[..., None] |
| return Image.fromarray(np.clip(bg, 0, 255).astype(np.uint8), "RGB") |
|
|
| def build_frame(): |
| S = 2 |
| im = Image.new("RGBA", (W * S, H * S), (0, 0, 0, 0)); d = ImageDraw.Draw(im) |
| for m, col, a, wd in ((38, GOLD, 215, 2.2), (54, GOLD_L, 105, 1.0)): |
| d.rectangle([m * S, m * S, (W - m) * S, (H - m) * S], outline=col + (a,), width=int(wd * S)) |
| for cx, cy, sx, sy in ((72, 72, 1, 1), (W - 72, 72, -1, 1), (72, H - 72, 1, -1), (W - 72, H - 72, -1, -1)): |
| L = 44 |
| d.line([cx * S, cy * S, (cx + L * sx) * S, cy * S], fill=GOLD_L + (170,), width=int(1.5 * S)) |
| d.line([cx * S, cy * S, cx * S, (cy + L * sy) * S], fill=GOLD_L + (170,), width=int(1.5 * S)) |
| for k in (1, 2, 3): |
| px, py = cx + 11 * k * sx, cy + 11 * k * sy |
| d.ellipse([(px - 3) * S, (py - 3) * S, (px + 3) * S, (py + 3) * S], fill=MARIGOLD + (150,)) |
| return im.resize((W, H), Image.LANCZOS) |
|
|
| def build_toran(height=210): |
| im = Image.new("RGBA", (W, height), (0, 0, 0, 0)); d = ImageDraw.Draw(im) |
| d.rectangle([0, 0, W, 14], fill=(28, 5, 14, 255)) |
| for i in range(0, W, 22): |
| d.ellipse([i + 3, 10, i + 19, 26], fill=GOLD_D + (230,)) |
| for k in range(4): |
| x0, x1 = W * k / 4.0, W * (k + 1) / 4.0 |
| for i in range(48): |
| t = i / 47.0 |
| x = x0 + (x1 - x0) * t |
| yy = 52 + math.sin(math.pi * t) * 74 |
| r = 12.5 |
| d.ellipse([x - r, yy - r, x + r, yy + r], fill=(MARIGOLD if i % 2 == 0 else ORANGE) + (238,)) |
| d.ellipse([x - r * 0.34, yy - r * 0.55, x + r * 0.18, yy - r * 0.12], fill=(255, 236, 196, 130)) |
| 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) |
| d.ellipse([x - 11, 172, x + 11, 194], fill=ORANGE + (238,)) |
| d.ellipse([x - 4, 177, x + 2, 183], fill=(255, 236, 196, 150)) |
| return im |
|
|
| def build_mandala(size=1040): |
| S = 2; s = size * S |
| im = Image.new("RGBA", (s, s), (0, 0, 0, 0)); d = ImageDraw.Draw(im) |
| c = s / 2.0 |
| for rf, wd, a in ((0.480, 2.4, 90), (0.452, 1.1, 55), (0.300, 1.1, 45), (0.196, 2.0, 70), (0.120, 1.1, 45)): |
| r = s * rf / 2.0 |
| d.ellipse([c - r, c - r, c + r, c + r], outline=GOLD_L + (a,), width=int(wd * S)) |
| for i in range(24): |
| ang = 360.0 * i / 24 |
| p = Image.new("RGBA", (int(s * 0.115), int(s * 0.038)), (0, 0, 0, 0)) |
| ImageDraw.Draw(p).ellipse([0, 0, p.size[0] - 1, p.size[1] - 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 |
| 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 |
| x, y = c + r * math.cos(math.radians(ang)), c + r * math.sin(math.radians(ang)) |
| d.ellipse([x - 3.2 * S, y - 3.2 * S, x + 3.2 * S, y + 3.2 * S], fill=MARIGOLD + (105,)) |
| return im.resize((size, size), Image.LANCZOS) |
|
|
| def build_diya(size=200): |
| S = 2; s = size * S |
| im = Image.new("RGBA", (s, s), (0, 0, 0, 0)); d = ImageDraw.Draw(im) |
| d.chord([s * 0.10, s * 0.50, s * 0.90, s * 0.98], start=0, end=180, fill=GOLD_D + (255,)) |
| d.chord([s * 0.10, s * 0.50, s * 0.90, s * 0.98], start=0, end=180, outline=GOLD_L + (255,), width=int(3 * S)) |
| d.arc([s * 0.10, s * 0.50, s * 0.90, s * 0.98], start=180, end=360, fill=GOLD_L + (220,), width=int(3 * S)) |
| fx, fy = s * 0.5, s * 0.50 |
| d.polygon([(fx, fy - s * 0.30), (fx - s * 0.070, fy), (fx + s * 0.070, fy)], fill=(255, 206, 108, 255)) |
| d.ellipse([fx - s * 0.070, fy - s * 0.085, fx + s * 0.070, fy + s * 0.085], fill=(255, 206, 108, 255)) |
| 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=430, radius=175.0): |
| yy, xx = np.mgrid[0:size, 0:size] |
| c = (size - 1) / 2.0 |
| 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) |
| return Image.fromarray(arr, "RGBA") |
|
|
| def build_mote(size=26): |
| yy, xx = np.mgrid[0:size, 0:size] |
| c = (size - 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) |
| return Image.fromarray(arr, "RGBA") |
|
|
| def build_lotus(size=124): |
| im = Image.new("RGBA", (size, size), (0, 0, 0, 0)) |
| for i in range(6): |
| p = Image.new("RGBA", (int(size * 0.86), int(size * 0.26)), (0, 0, 0, 0)) |
| ImageDraw.Draw(p).ellipse([0, 0, p.size[0] - 1, p.size[1] - 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)) |
| 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): |
| im = Image.new("RGBA", (D, D), (0, 0, 0, 0)); d = ImageDraw.Draw(im) |
| c = D / 2.0 |
| d.ellipse([5, 5, D - 5, D - 5], outline=GOLD + (215,), width=3) |
| d.ellipse([21, 21, D - 21, D - 21], outline=GOLD_L + (120,), width=2) |
| d.ellipse([34, 34, D - 34, D - 34], outline=GOLD_L + (70,), width=1) |
| for i in range(14): |
| ang = 360.0 * i / 14 |
| 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 |
| 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 card_base(width, height, radius=16, fill=(60, 11, 28, 215)): |
| card = Image.new("RGBA", (width, height), (0, 0, 0, 0)) |
| S = 2 |
| tmp = Image.new("RGBA", (width * S, height * S), (0, 0, 0, 0)) |
| ImageDraw.Draw(tmp).rounded_rectangle([0, 0, width * S - 1, height * S - 1], radius=int(radius * S), |
| fill=fill, outline=GOLD + (235,), width=int(2.2 * S)) |
| card.alpha_composite(tmp.resize((width, height), Image.LANCZOS), (0, 0)) |
| return card |
|
|
| def make_card(width, title, sections, title_size=66, label_size=28, value_size=48): |
| Hc = 1700 |
| card = card_base(width, Hc) |
| y = 74 |
| if title: |
| 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) |
| card.alpha_composite(rule_strip(rw, 0.9, 2), (int(width / 2 - rw / 2), int(y))) |
| y += 46 |
| for si, sec in enumerate(sections): |
| if si: |
| rw = int(width * 0.34) |
| card.alpha_composite(rule_strip(rw, 0.55, 1), (int(width / 2 - rw / 2), int(y))) |
| y += 42 |
| ll = text_layer([sec["label"]], "serif", label_size, GOLD_L, tracking=12, weight=500) |
| card.alpha_composite(ll, (int(width / 2 - ll.size[0] / 2), int(y))) |
| y += ll.size[1] + 24 |
| for v in sec["values"]: |
| vl = fit_layer([v], "serif", value_size, CREAM, width - 96, weight=500) |
| card.alpha_composite(vl, (int(width / 2 - vl.size[0] / 2), int(y))) |
| y += vl.size[1] + 12 |
| y += 20 |
| used = y + 40 |
| card.alpha_composite(build_lotus(64), (int(width / 2 - 32), int(used - 20))) |
| return card.crop((0, 0, width, min(Hc, used + 54))) |
|
|
| def make_message_card(width=900, sig=None, sig_size=64): |
| Hc = 1700 |
| card = card_base(width, Hc) |
| y = 90 |
| paras = EV["message"] |
| for pi, p in enumerate(paras): |
| lay = fit_layer(p["lines"], p["kind"], p["size"], p["color"], width - 100, |
| line_h=int(p["size"] * 1.34), weight=p.get("weight")) |
| card.alpha_composite(lay, (int(width / 2 - lay.size[0] / 2), int(y))) |
| y += lay.size[1] + (48 if pi < len(paras) - 1 else 32) |
| if sig: |
| sl = fit_layer([sig], "script", sig_size, GOLD_L, width - 160) |
| card.alpha_composite(sl, (int(width / 2 - sl.size[0] / 2), int(y))) |
| y += sl.size[1] |
| return card.crop((0, 0, width, min(Hc, y + 76))) |
|
|
| |
| def ks_pluck(freq, dur, damp=0.9965, bright=0.42, seed=0): |
| """Karplus-Strong plucked string (sitar/tanpura-like).""" |
| rng = np.random.default_rng(seed) |
| N = max(2, int(round(SR / float(freq)))) |
| buf = rng.uniform(-1.0, 1.0, N).astype(np.float32) |
| for _ in range(2): |
| buf = 0.5 * (buf + np.roll(buf, 1)) |
| buf /= (np.abs(buf).max() + 1e-9) |
| n = int(dur * SR) |
| out = np.empty(n, dtype=np.float32) |
| a, b = 0.5 * (1.0 + bright), 0.5 * (1.0 - bright) |
| idx = 0 |
| for i in range(n): |
| cur = buf[idx] |
| out[i] = cur |
| buf[idx] = damp * (a * cur + b * buf[(idx + 1) % N]) |
| idx = (idx + 1) % N |
| return out |
|
|
| def make_bell(dur, base=587.33, decay=1.9): |
| t = np.arange(int(dur * SR), dtype=np.float32) / SR |
| out = np.zeros_like(t) |
| for mult, amp in ((1.0, 1.0), (2.0, 0.34), (2.76, 0.42), (4.07, 0.16), (5.43, 0.09)): |
| out += amp * np.sin(2 * np.pi * base * mult * t) * np.exp(-t * (1.6 / decay) * (mult ** 0.4)) |
| return out / (np.abs(out).max() + 1e-9) |
|
|
| def make_pad(dur, chord=(146.83, 220.0, 293.66), amp=1.0): |
| t = np.arange(int(dur * SR), dtype=np.float32) / SR |
| out = np.zeros_like(t) |
| for i, f in enumerate(chord): |
| vib = 1.0 + 0.0016 * np.sin(2 * np.pi * (0.16 + 0.05 * i) * t) |
| out += np.sin(2 * np.pi * f * vib * t) / (i + 2.0) |
| swell = np.minimum(1.0, t / 4.0) |
| return amp * swell * out / (np.abs(out).max() + 1e-9) |
|
|
| def reverb(x, seed, mix=0.34, decay=1.7, sr=SR): |
| rng = np.random.default_rng(seed) |
| n = int(decay * sr) |
| ir = (rng.standard_normal(n) * np.exp(-np.arange(n) / (0.30 * sr))).astype(np.float32) |
| ir[0] = 1.0 |
| ir /= np.abs(ir).sum() ** 0.5 |
| L = 1 |
| while L < len(x) + n: |
| L *= 2 |
| y = np.fft.irfft(np.fft.rfft(x, L) * np.fft.rfft(ir, L), L)[:len(x)].astype(np.float32) |
| pk = np.abs(x).max() + 1e-9 |
| y = y / (np.abs(y).max() + 1e-9) * pk |
| return (1.0 - mix) * x + mix * y |
|
|
| def build_soundtrack(total): |
| S = int((total + 1.2) * SR) |
| bus = {k: np.zeros(S, dtype=np.float32) for k in ("drone", "mel", "bell", "pad")} |
|
|
| def add(which, t0, sig, amp): |
| i = int(t0 * SR) |
| if i >= S: |
| return |
| j = min(S, i + len(sig)) |
| bus[which][i:j] += sig[:j - i] * amp |
|
|
| SA = 146.83 |
| def nf(semi): |
| return SA * (2.0 ** (semi / 12.0)) |
|
|
| |
| cycle = [(7, 0.90), (0, 0.85), (12, 0.72), (12, 0.66)] |
| t0, k = 0.0, 0 |
| while t0 < total: |
| semi, amp = cycle[k % len(cycle)] |
| add("drone", t0, ks_pluck(nf(semi), 3.4, damp=0.9975, bright=0.30, seed=k * 7 + 1), 0.15 * amp) |
| t0 += 2.15 |
| k += 1 |
|
|
| |
| melody = [(0.80, 0, 3.0, 0.20), (2.30, 4, 2.6, 0.17), (3.70, 7, 2.8, 0.17), |
| (5.30, 9, 2.6, 0.17), (6.90, 12, 3.2, 0.18), |
| (9.20, 14, 3.0, 0.15), (11.20, 12, 2.8, 0.14), (13.40, 9, 3.0, 0.14), |
| (15.20, 7, 3.0, 0.15), |
| (17.40, 12, 2.6, 0.17), (19.00, 9, 2.6, 0.16), (20.60, 12, 2.8, 0.16), |
| (22.40, 16, 3.2, 0.17), (24.40, 19, 3.2, 0.18), (26.60, 21, 3.4, 0.18), |
| (28.60, 24, 3.6, 0.19), (30.80, 19, 3.6, 0.16), (32.20, 12, 4.6, 0.16)] |
| for i, (t0, semi, dur, amp) in enumerate(melody): |
| if t0 > total: |
| continue |
| add("mel", t0, ks_pluck(nf(semi), dur, damp=0.9982, bright=0.46, seed=100 + i * 13), amp) |
|
|
| |
| for i, st in enumerate([0.0, 3.95, 8.4, 16.35, 22.8, 26.75]): |
| big = i in (0, 5) |
| add("bell", st, make_bell(5.0, base=587.33 if big else 493.88, decay=2.2 if big else 1.7), |
| 0.16 if big else 0.095) |
|
|
| |
| add("pad", 0.4, make_pad(total + 1.0, amp=1.0), 0.085) |
|
|
| |
| kernel = np.hanning(9) |
| kernel /= kernel.sum() |
| def lp(x): |
| return np.convolve(x, kernel, mode="same").astype(np.float32) |
| for k in bus: |
| bus[k] = lp(bus[k]) |
|
|
| L = reverb(bus["drone"] * 0.95 + bus["mel"] + bus["bell"] + bus["pad"], seed=5) |
| R = reverb(bus["drone"] * 1.00 + bus["mel"] * 0.94 + bus["bell"] * 0.98 + bus["pad"], seed=9) |
| st = np.stack([L, R], axis=1) |
|
|
| n = st.shape[0] |
| fade_in = int(1.2 * SR) |
| fade_out = int(3.0 * SR) |
| env = np.ones(n, dtype=np.float32) |
| env[:fade_in] = np.linspace(0.0, 1.0, fade_in) ** 0.7 |
| env[n - fade_out:] = np.linspace(1.0, 0.0, fade_out) ** 1.1 |
| st *= env[:, None] |
|
|
| peak = np.abs(st).max() + 1e-9 |
| st = np.tanh(st / peak * 1.15) * 0.72 |
| st = st[:int(total * SR)] |
| data = np.clip(st, -1.0, 1.0) |
| with wave.open(WAV, "wb") as w: |
| w.setnchannels(2); w.setsampwidth(2); w.setframerate(SR) |
| w.writeframes((data * 32767.0).astype("<i2").tobytes()) |
| print("soundtrack: %s %.2fs peak=%.2f" % (WAV, st.shape[0] / float(SR), np.abs(st).max()), flush=True) |
|
|
| |
| print("building assets ...", flush=True) |
| BG = build_bg().convert("RGBA") |
| FRAME = build_frame() |
| TORAN = build_toran() |
| MANDALA = alpha_scale(build_mandala(1040), 0.19) |
| DIYA = build_diya(200) |
| LOTUS = build_lotus(120) |
| LOTUS_S = build_lotus(64) |
| GLOWS = alpha_variants(build_glow(430, 175.0), 12) |
| MOTE_V = alpha_variants(build_mote(26), 12) |
| MOTE_S = alpha_variants(build_mote(15), 12) |
|
|
| random.seed(11) |
| MOTES = [dict(x=random.uniform(70, W - 70), y=random.uniform(0, H), sp=random.uniform(58, 132), |
| sw=random.uniform(0.25, 0.7), ph=random.uniform(0, 6.28), big=random.random() < 0.45) |
| for _ in range(16)] |
|
|
| MAXW = 880 |
| kicker1 = text_layer([EV["hindi"]], "hindi", 48, GOLD_L, weight=500) if HAS_HINDI else \ |
| text_layer([EV["kicker1_en"]], "serif", 34, GOLD_L, tracking=13, weight=500) |
| k1_extra = text_layer([EV["kicker1_en"]], "serif", 26, GOLD_L, tracking=11, weight=500) if HAS_HINDI else None |
|
|
| L_script1 = fit_layer([EV["script1"]], "script", 158, GOLD, MAXW) |
| L_sub1 = fit_layer([EV["sub1"]], "serif", 42, SOFT, MAXW, weight=500) |
| L_kick2 = text_layer([EV["kicker2"]], "serif", 32, GOLD_L, tracking=15, weight=500) |
| 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"]], "serif", 44, SOFT, MAXW, weight=500) |
| L_small2 = text_layer([EV["small2"]], "serif", 30, GOLD_L, tracking=10, weight=500) |
|
|
| EMOJI_ROSE = emoji_layer(["\U0001F339"], 62) |
| EMOJI_ROW = emoji_layer(["\U0001F339", "\U0001F64F", "\U0001F389", "\U0001F38A"], 62) |
| if EMOJI_ROW is None: |
| print("emoji unavailable - falling back to drawn ornaments", flush=True) |
| EMOJI_ROW = build_lotus(62) |
|
|
| CARD_MSG = make_message_card(sig=EV["msg_sig"]) |
| L_foot3 = text_layer([EV["msg_foot"]], "serif", 28, GOLD_L, tracking=12, weight=500) |
| CARD_D = make_card(848, EV["card_title"], [ |
| dict(label=EV["when_label"], values=[EV["when_1"]]), |
| dict(label=EV["time_label"], values=[EV["time_1"]]), |
| dict(label=EV["where_label"], values=[EV["where_1"]]), |
| ]) |
| L_sub3 = fit_layer([EV["sub3"]], "serif", 42, SOFT, MAXW, weight=500) |
| L_kick3 = text_layer(["THE CELEBRATION"], "serif", 32, GOLD_L, tracking=15, weight=500) |
| MONO = build_monogram(600) |
| L_quote = fit_layer(EV["quote"], "bodyi", 54, SOFT, MAXW - 60, line_h=82, weight=600) |
| L_kick6 = text_layer([EV["kicker6"]], "serif", 30, GOLD_L, tracking=13, weight=500) |
| L_script6 = fit_layer([EV["script6"]], "script", 136, GOLD, MAXW) |
| L_sig = fit_layer([EV["sig"]], "script", 84, CREAM, MAXW) |
| print("card sizes: message=%s details=%s emoji=%s" % (CARD_MSG.size, CARD_D.size, EMOJI_PATH is not None), flush=True) |
|
|
| |
| DUR = [4.5, 5.0, 8.5, 7.0, 4.5, 5.5] |
| 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 |
| NF = int(round(TOTAL * FPS)) |
| print("timeline start:", [round(s, 2) for s in start], "total %.2fs %d frames" % (TOTAL, NF), flush=True) |
|
|
| build_soundtrack(TOTAL) |
|
|
| def scene_alpha(i, t): |
| 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]: |
| return max(0.0, 1.0 - (t - start[i + 1]) / OV) |
| return 1.0 |
|
|
| def ease(t, delay, dur=0.95): |
| x = (t - delay) / dur |
| if x <= 0: |
| return 0.0 |
| if x >= 1: |
| return 1.0 |
| return 1.0 - (1.0 - x) ** 3 |
|
|
| ITEMS = [ |
| [(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)], |
| [(EMOJI_ROSE, 0.170, 0.15, 30, 0.8), (CARD_MSG, 0.455, 0.45, 54, 1.05), |
| (L_foot3, 0.712, 1.10, 34, 0.9)], |
| [(L_kick3, 0.246, 0.10, 38, 0.9), (CARD_D, 0.505, 0.40, 56, 1.05), (L_sub3, 0.760, 1.05, 40, 0.9)], |
| [(MONO, 0.395, 0.20, 50, 1.05), (LOTUS_S, 0.545, 0.90, 18, 0.8), (L_quote, 0.645, 1.05, 44, 1.0)], |
| [(L_kick6, 0.330, 0.15, 36, 0.9), (EMOJI_ROW, 0.392, 0.45, 34, 0.85), |
| (L_script6, 0.468, 0.65, 58, 1.05), (LOTUS, 0.545, 0.95, 18, 0.8), (L_sig, 0.612, 1.10, 44, 0.95)], |
| ] |
|
|
| 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))) |
| img.alpha_composite(TORAN, (0, 0)) |
| 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) |
| 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"])) |
| 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 0 <= px < W and 0 <= 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, 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) |
| if k < 1.0: |
| return Image.fromarray((np.asarray(rgb, dtype=np.float32) * k).astype(np.uint8), "RGB") |
| return rgb |
|
|
| |
| from imageio_ffmpeg import get_ffmpeg_exe |
| FFMPEG = get_ffmpeg_exe() |
| print("ffmpeg:", FFMPEG, flush=True) |
| proc = subprocess.Popen([FFMPEG, "-y", "-loglevel", "error", |
| "-f", "rawvideo", "-pix_fmt", "rgb24", "-s", "%dx%d" % (W, H), |
| "-r", str(FPS), "-i", "-", |
| "-i", WAV, |
| "-map", "0:v:0", "-map", "1:a:0", |
| "-c:v", "libx264", "-preset", "slow", "-crf", "18", "-pix_fmt", "yuv420p", |
| "-c:a", "aac", "-b:a", "192k", "-ar", str(SR), |
| "-shortest", "-movflags", "+faststart", OUT], stdin=subprocess.PIPE) |
|
|
| poster_t = start[1] + 2.6 |
| for n in range(NF): |
| t = n / float(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 % 100 == 0: |
| print("frame %4d / %d (t=%.1fs)" % (n, NF, t), flush=True) |
| proc.stdin.close() |
| proc.wait() |
| print("encoded:", OUT, os.path.getsize(OUT), "bytes", flush=True) |
|
|
| PREVIEW_DIR = "/tmp/previews" |
| os.makedirs(PREVIEW_DIR, exist_ok=True) |
| checks = [("s1", start[0] + 3.4), ("s2", start[1] + 3.2), ("s3", start[2] + 5.8), |
| ("s4", start[3] + 5.2), ("s5", start[4] + 3.0), ("s6", start[5] + 3.9)] |
| previews = [] |
| for name, tt in checks: |
| fp = os.path.join(PREVIEW_DIR, "preview_%s.jpg" % name) |
| render(tt).save(fp, quality=92) |
| previews.append(fp) |
| print("preview", name, "t=%.2f" % tt, flush=True) |
|
|
| |
| from huggingface_hub import HfApi |
| REPO = os.environ.get("REPO_ID", "coderdecoder01/retirement-invitation-mamta") |
| api = HfApi(token=os.environ["HF_TOKEN"]) |
| api.create_repo(repo_id=REPO, repo_type="dataset", private=False, exist_ok=True) |
| try: |
| api.update_repo_settings(repo_id=REPO, repo_type="dataset", private=False) |
| except Exception as e: |
| print("visibility:", repr(e)[:120], flush=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=WAV, path_in_repo="soundtrack.wav", repo_id=REPO, repo_type="dataset") |
| api.upload_file(path_or_fileobj=POSTER, path_in_repo="poster.jpg", repo_id=REPO, repo_type="dataset") |
| for fp in previews: |
| api.upload_file(path_or_fileobj=fp, path_in_repo="previews/" + os.path.basename(fp), repo_id=REPO, repo_type="dataset") |
| 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) |
|
|
