249 lines
9.0 KiB
Python
249 lines
9.0 KiB
Python
#!/usr/bin/env python3
|
|
"""Regenerate every app icon from the vector source (src-tauri/icons/icon.svg).
|
|
|
|
The artwork is described once, in 512x512 units, and rasterised per target size
|
|
with 8x supersampling plus a little per-size hinting: the filmstrip sprocket
|
|
holes and the play-triangle knockout are dropped at the sizes where they
|
|
would be sub-pixel and only turn to mush.
|
|
|
|
Everything is produced with a real alpha channel - the rounded-square tile has
|
|
transparent corners, which is exactly what the old flattened .ico was missing.
|
|
|
|
python tools/make_icons.py
|
|
|
|
Requires: pillow, numpy.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import math
|
|
import re
|
|
import struct
|
|
from io import BytesIO
|
|
from pathlib import Path
|
|
|
|
import numpy as np
|
|
from PIL import Image, ImageDraw
|
|
|
|
ROOT = Path(__file__).resolve().parent.parent
|
|
ICONS = ROOT / "src-tauri" / "icons"
|
|
SVG = ICONS / "icon.svg"
|
|
|
|
CANVAS = 512.0
|
|
SS = 8 # supersampling factor
|
|
|
|
# --- tile -------------------------------------------------------------------
|
|
# The original raster left a 22px margin for a drop shadow. The vector version
|
|
# has no shadow, so the tile reclaims that space and reads larger in the taskbar.
|
|
TILE = (14.0, 14.0, 484.0, 484.0) # x, y, w, h
|
|
TILE_R = 99.0
|
|
GRAD_SPAN = (22.0, 468.0) # gradient is still fitted against the original tile
|
|
|
|
# --- filmstrips -------------------------------------------------------------
|
|
STRIPS = [(113.0, 147.0), (96.0, 226.0), (113.0, 305.0)]
|
|
STRIP_W, STRIP_H, STRIP_R = 79.0, 60.0, 12.0
|
|
HOLE_DX, HOLE_DY, HOLE_S, HOLE_R = 68.0, 4.0, 7.5, 1.8
|
|
HOLE_PITCH, HOLE_N = 11.25, 5
|
|
|
|
|
|
def parse_svg(svg_text):
|
|
"""Pull the gradient stops and the glyph path back out of the vector source."""
|
|
lin = re.search(r'id="tile".*?</linearGradient>', svg_text, re.S).group(0)
|
|
lin_stops = [
|
|
(float(o), tuple(int(h[i:i + 2], 16) for i in (0, 2, 4)))
|
|
for o, h in re.findall(r'offset="([\d.]+)" stop-color="#([0-9A-Fa-f]{6})"', lin)
|
|
]
|
|
rad = re.search(r'id="glow".*?</radialGradient>', svg_text, re.S).group(0)
|
|
gc = re.search(r'cx="([-\d.]+)" cy="([-\d.]+)" r="([\d.]+)"', rad)
|
|
glow_xy = (float(gc.group(1)), float(gc.group(2)))
|
|
glow_r = float(gc.group(3))
|
|
ghex = re.search(r'stop-color="#([0-9A-Fa-f]{6})"', rad).group(1)
|
|
glow_rgb = tuple(int(ghex[i:i + 2], 16) for i in (0, 2, 4))
|
|
rad_stops = [
|
|
(float(o), float(a))
|
|
for o, a in re.findall(
|
|
r'offset="([\d.]+)" stop-color="#[0-9A-Fa-f]{6}" stop-opacity="([\d.]+)"', rad
|
|
)
|
|
]
|
|
path_d = re.search(r'<path d="([^"]+)"', svg_text).group(1)
|
|
return lin_stops, glow_xy, glow_r, glow_rgb, rad_stops, path_d
|
|
|
|
|
|
def ramp(stops, t):
|
|
"""Piecewise-linear colour ramp over an array of positions in [0, 1]."""
|
|
offs = np.array([s[0] for s in stops])
|
|
cols = np.array([s[1] for s in stops], dtype=np.float64)
|
|
idx = np.clip(np.searchsorted(offs, t) - 1, 0, len(offs) - 2)
|
|
span = np.maximum(offs[idx + 1] - offs[idx], 1e-9)
|
|
f = ((t - offs[idx]) / span)[..., None]
|
|
return cols[idx] * (1 - f) + cols[idx + 1] * f
|
|
|
|
|
|
def ramp1(stops, t):
|
|
offs = np.array([s[0] for s in stops])
|
|
vals = np.array([s[1] for s in stops], dtype=np.float64)
|
|
idx = np.clip(np.searchsorted(offs, t) - 1, 0, len(offs) - 2)
|
|
span = np.maximum(offs[idx + 1] - offs[idx], 1e-9)
|
|
f = (t - offs[idx]) / span
|
|
return vals[idx] * (1 - f) + vals[idx + 1] * f
|
|
|
|
|
|
def flatten_path(d, scale):
|
|
"""Flatten the glyph path data into polygons, subdividing beziers."""
|
|
toks = re.findall(r"([MLCZ])([-\d.,e ]*)", d)
|
|
polys, cur, pos, start = [], [], (0.0, 0.0), (0.0, 0.0)
|
|
|
|
def nums(s):
|
|
return [float(v) for v in re.split(r"[, ]+", s.strip()) if v]
|
|
|
|
for cmd, args in toks:
|
|
a = nums(args)
|
|
if cmd == "M":
|
|
if len(cur) > 2:
|
|
polys.append(cur)
|
|
pos = start = (a[0], a[1])
|
|
cur = [pos]
|
|
elif cmd == "L":
|
|
pos = (a[0], a[1])
|
|
cur.append(pos)
|
|
elif cmd == "C":
|
|
p0, p1, p2, p3 = pos, (a[0], a[1]), (a[2], a[3]), (a[4], a[5])
|
|
span = math.dist(p0, p1) + math.dist(p1, p2) + math.dist(p2, p3)
|
|
n = max(4, min(96, int(span * scale / 2.5)))
|
|
for i in range(1, n + 1):
|
|
t = i / n
|
|
mt = 1 - t
|
|
x = mt ** 3 * p0[0] + 3 * mt * mt * t * p1[0] + 3 * mt * t * t * p2[0] + t ** 3 * p3[0]
|
|
y = mt ** 3 * p0[1] + 3 * mt * mt * t * p1[1] + 3 * mt * t * t * p2[1] + t ** 3 * p3[1]
|
|
cur.append((x, y))
|
|
pos = p3
|
|
elif cmd == "Z":
|
|
if len(cur) > 2:
|
|
polys.append(cur)
|
|
cur, pos = [], start
|
|
if len(cur) > 2:
|
|
polys.append(cur)
|
|
return polys
|
|
|
|
|
|
def render(size, lin_stops, glow_xy, glow_r, glow_rgb, rad_stops, path_d):
|
|
n = size * SS
|
|
k = n / CANVAS # 512-space -> device pixels
|
|
|
|
# per-size hinting: sub-pixel detail is dropped rather than smeared, and the
|
|
# glyph is nudged up a little where it would otherwise get lost
|
|
keep_holes = size >= 48 # sprocket holes are < 0.7px below this
|
|
keep_triangle = size >= 64 # the play knockout reads as a speck below this
|
|
gscale = 1.09 if size <= 32 else 1.0
|
|
|
|
def S(v):
|
|
return v * k
|
|
|
|
def G(v): # glyph coordinate, scaled about the tile centre
|
|
return (CANVAS / 2 + (v - CANVAS / 2) * gscale) * k
|
|
|
|
# the tile shape is the icon's whole alpha channel - corners stay transparent
|
|
tile = Image.new("L", (n, n), 0)
|
|
ImageDraw.Draw(tile).rounded_rectangle(
|
|
[S(TILE[0]), S(TILE[1]), S(TILE[0] + TILE[2]), S(TILE[1] + TILE[3])],
|
|
radius=S(TILE_R),
|
|
fill=255,
|
|
)
|
|
|
|
# background: diagonal purple-to-blue ramp with a soft highlight near the top
|
|
yy, xx = np.mgrid[0:n, 0:n]
|
|
ux = (xx + 0.5) / k
|
|
uy = (yy + 0.5) / k
|
|
t = np.clip(((ux + uy) - 2 * GRAD_SPAN[0]) / (2 * GRAD_SPAN[1]), 0, 1)
|
|
base = ramp(lin_stops, t)
|
|
g = np.clip(np.hypot(ux - glow_xy[0], uy - glow_xy[1]) / glow_r, 0, 1)
|
|
a = ramp1(rad_stops, g)[..., None]
|
|
rgb = base * (1 - a) + np.array(glow_rgb, dtype=np.float64) * a
|
|
|
|
glyph = Image.new("L", (n, n), 0)
|
|
gd = ImageDraw.Draw(glyph)
|
|
polys = flatten_path(path_d, k)
|
|
outer, holes = polys[0], polys[1:] # outline first, play-triangle knockout after
|
|
gd.polygon([(G(x), G(y)) for x, y in outer], fill=255)
|
|
if keep_triangle:
|
|
for hole in holes:
|
|
gd.polygon([(G(x), G(y)) for x, y in hole], fill=0)
|
|
|
|
for sx, sy in STRIPS:
|
|
gd.rounded_rectangle(
|
|
[G(sx), G(sy), G(sx + STRIP_W), G(sy + STRIP_H)], radius=S(STRIP_R * gscale), fill=255
|
|
)
|
|
if keep_holes:
|
|
for i in range(HOLE_N):
|
|
hx, hy = sx + HOLE_DX, sy + HOLE_DY + i * HOLE_PITCH
|
|
gd.rounded_rectangle(
|
|
[G(hx), G(hy), G(hx + HOLE_S), G(hy + HOLE_S)],
|
|
radius=S(HOLE_R * gscale),
|
|
fill=0,
|
|
)
|
|
|
|
gm = (np.asarray(glyph, dtype=np.float64) / 255.0)[..., None]
|
|
rgb = rgb * (1 - gm) + 255.0 * gm
|
|
|
|
out = np.dstack([np.clip(rgb, 0, 255), np.asarray(tile, dtype=np.float64)]).astype(np.uint8)
|
|
return Image.fromarray(out, "RGBA").resize((size, size), Image.LANCZOS)
|
|
|
|
|
|
def write_ico(path, images):
|
|
"""Write a PNG-compressed .ico (Vista+ format), preserving full alpha."""
|
|
blobs = []
|
|
for im in images:
|
|
buf = BytesIO()
|
|
im.save(buf, "PNG", optimize=True)
|
|
blobs.append(buf.getvalue())
|
|
with open(path, "wb") as f:
|
|
f.write(struct.pack("<HHH", 0, 1, len(images)))
|
|
offset = 6 + 16 * len(images)
|
|
for im, blob in zip(images, blobs):
|
|
w = 0 if im.width >= 256 else im.width
|
|
h = 0 if im.height >= 256 else im.height
|
|
f.write(struct.pack("<BBBBHHII", w, h, 0, 0, 1, 32, len(blob), offset))
|
|
offset += len(blob)
|
|
for blob in blobs:
|
|
f.write(blob)
|
|
|
|
|
|
PNG_TARGETS = {
|
|
"32x32.png": 32,
|
|
"64x64.png": 64,
|
|
"128x128.png": 128,
|
|
"128x128@2x.png": 256,
|
|
"icon.png": 512,
|
|
"Square30x30Logo.png": 30,
|
|
"Square44x44Logo.png": 44,
|
|
"Square71x71Logo.png": 71,
|
|
"Square89x89Logo.png": 89,
|
|
"Square107x107Logo.png": 107,
|
|
"Square142x142Logo.png": 142,
|
|
"Square150x150Logo.png": 150,
|
|
"Square284x284Logo.png": 284,
|
|
"Square310x310Logo.png": 310,
|
|
"StoreLogo.png": 50,
|
|
}
|
|
ICO_SIZES = [16, 24, 32, 48, 64, 128, 256]
|
|
|
|
|
|
def main():
|
|
params = parse_svg(SVG.read_text(encoding="utf-8"))
|
|
cache = {}
|
|
|
|
def get(size):
|
|
if size not in cache:
|
|
cache[size] = render(size, *params)
|
|
return cache[size]
|
|
|
|
for name, size in PNG_TARGETS.items():
|
|
get(size).save(ICONS / name, "PNG", optimize=True)
|
|
print(" %-24s %dx%d" % (name, size, size))
|
|
|
|
write_ico(ICONS / "icon.ico", [get(s) for s in ICO_SIZES])
|
|
print(" %-24s %s" % ("icon.ico", ICO_SIZES))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|