v5.1.0: history tab, portable data folder, optional faststart, new icons & build tools
This commit is contained in:
@@ -0,0 +1,248 @@
|
||||
#!/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()
|
||||
Reference in New Issue
Block a user