| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| |
| """Regenerate the shipped app-icon artwork. |
| |
| Every PNG under apps/desktop/assets/app-icons/ except `mono.png` comes out of |
| this file. The mark is not traced, not drawn over stock art, and not generated |
| by a model: it is a handful of stroked polylines defined by the constants |
| below, so the provenance of the artwork is the source you are reading. |
| |
| python3 scripts/generate-app-icons.py # rewrite every icon |
| python3 scripts/generate-app-icons.py --check # verify, write nothing |
| |
| `--check` is what the test harness uses: it re-renders and compares bytes, so |
| a change to the geometry that is not reflected in the committed PNGs fails. |
| The harness passes no names, so every shipped tile is compared, and rendering |
| is spread across all cores to keep that affordable. |
| |
| There is no SVG rasteriser available in CI, so the PNGs are rendered here by |
| evaluating the same geometry as signed distance fields — including the miter |
| wedge a sharp join adds, which a plain capsule union would miss. |
| |
| Artwork is written at 1024x1024 with a 100px transparent margin on all four |
| sides. That is the macOS icon grid: the solid block occupies 824/1024 (80.5%) |
| and the dock scales the canvas without adding padding of its own, so a |
| full-bleed tile would sit 24% wider than every neighbour. |
| """ |
| |
| import io |
| import math |
| import os |
| import sys |
| from multiprocessing import Pool |
| import struct |
| import zlib |
| |
| SIZE = 1024.0 |
| CORNER_R = 229.0 |
| STROKE = 70.0 |
| HW = STROKE / 2.0 |
| |
| APEX = (512, 274) |
| VALLEY = (512, 800) |
| FOOT_L, FOOT_R = (180, 845), (844, 845) |
| BAR_Y = 162 |
| BAR = [(405, BAR_Y), (619, BAR_Y)] |
| # clearance between the bar's underside and the top of the tip's round join, |
| # kept at ~60% of the stroke so the two never read as one shape |
| BAR_GAP = (APEX[1] - HW) - (BAR_Y + HW) |
| |
| |
| def shoulder(foot): |
| """Where the inner arm crosses the leg. The inner V mirrors the outer legs, |
| so by symmetry the crossing sits halfway between apex and valley.""" |
| sy = (APEX[1] + VALLEY[1]) / 2.0 |
| sx = APEX[0] + (foot[0] - APEX[0]) * (sy - APEX[1]) / (foot[1] - APEX[1]) |
| return (round(sx, 1), sy) |
| |
| |
| SHOULDER_L, SHOULDER_R = shoulder(FOOT_L), shoulder(FOOT_R) |
| |
| |
| def mark_box(): |
| """viewBox for the bare mark: the glyph's bounding box.""" |
| x0, x1 = FOOT_L[0] - HW, FOOT_R[0] + HW |
| y0, y1 = BAR_Y - HW, FOOT_L[1] + HW |
| return ("%g %g %g %g" % (x0, y0, x1 - x0, y1 - y0), int(x1 - x0), int(y1 - y0)) |
| |
| # How the tip meets the M, i.e. what the boundary between the two colours looks |
| # like. Whoever is painted last owns the joint: |
| # flat tip on top, butt cap on the shoulder — cut across the leg, and it |
| # shaves off the M's corner |
| # round tip on top, round cap — arc bulging down into the M |
| # tangent as round, raised half a stroke so the arc just touches the shoulder |
| # round-up M on top, round join — its round shoulder bulges up into the tip |
| # flat-up M on top, legs run half a stroke past the shoulder, cut flat |
| # miter-up M on top, sharp (miter) join — the corner runs out to a point and |
| # the boundary lies along the inner arm's outer edge, i.e. parallel |
| # to the M's two middle strokes |
| JOINT = "miter-up" |
| JOINT_STYLES = { |
| "flat": dict(lift=0.0, cap="butt", m_on_top=False, join="round"), |
| "round": dict(lift=0.0, cap="round", m_on_top=False, join="round"), |
| "tangent": dict(lift=HW, cap="round", m_on_top=False, join="round"), |
| "round-up": dict(lift=0.0, cap="butt", m_on_top=True, join="round"), |
| "flat-up": dict(lift=HW, cap="butt", m_on_top=True, join="round"), |
| "miter-up": dict(lift=0.0, cap="butt", m_on_top=True, join="miter"), |
| } |
| |
| |
| def along_leg(shoulder, lift): |
| """Walk `lift` units from a shoulder towards the apex.""" |
| dx, dy = APEX[0] - shoulder[0], APEX[1] - shoulder[1] |
| n = math.hypot(dx, dy) |
| return (shoulder[0] + dx / n * lift, shoulder[1] + dy / n * lift) |
| |
| |
| def parts(joint=None): |
| """(name, polyline, cap, join), painted in order — the last one drawn owns |
| the shoulder, so its outline is what the colour boundary follows.""" |
| s = JOINT_STYLES[joint or JOINT] |
| lift, join = s["lift"], s["join"] |
| bar = [("bar", BAR, "round", "round")] |
| |
| if not s["m_on_top"]: |
| body = [("body", [FOOT_L, SHOULDER_L, VALLEY, SHOULDER_R, FOOT_R], |
| "round", "round")] |
| tip = [("tip", [along_leg(SHOULDER_L, lift), APEX, |
| along_leg(SHOULDER_R, lift)], s["cap"], "round")] |
| return body + tip + bar |
| |
| # M on top: the tip runs down to the shoulders and is painted over. |
| tip = [("tip", [SHOULDER_L, APEX, SHOULDER_R], "butt", "round")] |
| if join == "miter": |
| # each half is one stroke so the shoulder is a real join and can be |
| # mitred; they overlap at the valley, which stays round |
| body = [("body", [FOOT_L, SHOULDER_L, VALLEY], "round", "miter"), |
| ("body", [FOOT_R, SHOULDER_R, VALLEY], "round", "miter")] |
| else: |
| body = [("body", [FOOT_L, SHOULDER_L, VALLEY, SHOULDER_R, FOOT_R], |
| "round", "round")] |
| # stubs carry the M past the shoulder and stop flat there |
| body += [("body", [along_leg(s2, -lift), along_leg(s2, lift)], "butt", "round") |
| for s2 in (SHOULDER_L, SHOULDER_R) if lift] |
| return tip + body + bar |
| |
| |
| # name, group, label, background, body, tip, bar |
| V = lambda name, group, label, bg, body, tip, bar: dict( |
| name=name, group=group, label=label, bg=bg, body=body, tip=tip, bar=bar) |
| |
| |
| def grad(c1, c2, angle=90): |
| """A gradient paint spec, valid for the tile or for any stroked part. |
| |
| angle: 0 = left-to-right, 90 = top-to-bottom. A bare (c1, c2) tuple is the |
| original top-to-bottom form and is still accepted everywhere. |
| """ |
| return ("grad", c1, c2, angle) |
| |
| |
| W = "#FFFFFF" |
| |
| VARIANTS = [ |
| # --- 浅蓝系 --------------------------------------------------------- |
| V("sky", "蓝", "原色 sky", "#47A3E2", W, W, W), |
| V("cyan", "蓝", "青蓝", "#4FC3D9", W, W, W), |
| V("ice", "蓝", "冰蓝渐变", ("#9BDCFB", "#4A9FE0"), W, W, W), |
| V("pale-inverted", "蓝", "淡底深标", "#DCEEFB", "#2E86D6", "#2E86D6", "#2E86D6"), |
| # --- 黑白 ----------------------------------------------------------- |
| V("ink", "黑白", "墨黑底", "#111315", W, W, W), |
| V("paper", "黑白", "纸白底", "#FFFFFF", "#14161A", "#14161A", "#14161A"), |
| V("graphite", "黑白", "白底灰尖", "#FFFFFF", "#14161A", "#8A9199", "#14161A"), |
| # --- 铅笔 ----------------------------------------------------------- |
| V("pencil-kraft", "铅笔", "牛皮纸底", "#D9C7A4", "#F5B301", "#14110F", W), |
| V("pencil-sky", "铅笔", "天蓝底", "#47A3E2", "#FFC531", "#17191B", W), |
| V("pencil-navy", "铅笔", "深蓝底", "#1F3A5F", "#F7C948", "#0B0D10", W), |
| # --- 高山 ----------------------------------------------------------- |
| V("alpine", "高山", "晴空雪山", ("#C8E9FF", "#79C3F0"), "#3E5C76", W, W), |
| V("dusk", "高山", "黄昏", ("#FFC48C", "#F4886B"), "#35314C", "#FFF3E4", W), |
| V("night", "高山", "夜山", ("#16233A", "#31527A"), "#0C1422", "#E8F1FF", "#DCE8FF"), |
| V("forest", "高山", "苍绿", ("#D6ECDD", "#8FC7A8"), "#2C4A3B", W, W), |
| # --- 深色 ----------------------------------------------------------- |
| # ink was the only true dark tile; a mid-tone one glows like a light leak |
| # in a dark dock or a dark UI shell. |
| V("midnight", "深色", "午夜蓝", "#0A1220", "#9EC7F0", "#E8F2FF", "#5B8DEF"), |
| V("carbon", "深色", "纯黑 OLED", "#000000", "#3FA9F5", "#7FD4FF", "#3FA9F5"), |
| V("slate", "深色", "石板", "#1E242C", "#8FA6BC", "#DDE7F0", "#6B8299"), |
| V("obsidian", "深色", "曜石", grad("#1A1030", "#0A0616", 135), |
| "#A78BFA", "#E9E2FF", "#7C5CE0"), |
| # --- 霓虹 ----------------------------------------------------------- |
| # Amber CRT and phosphor green are the terminal's own history, not styling. |
| V("neon-cyan", "霓虹", "荧光青", "#0B0F14", "#00E5FF", "#B8FBFF", "#00A8CC"), |
| V("matrix", "霓虹", "磷绿", "#050A06", "#39FF14", "#C8FFB8", "#1F9E0A"), |
| V("magenta", "霓虹", "品红", "#14091F", "#FF3DCE", "#FFD6F5", "#B01E8E"), |
| V("amber-crt", "霓虹", "琥珀 CRT", "#0D0A05", "#FFB000", "#FFE7B0", "#C77A00"), |
| # --- 莫兰迪 --------------------------------------------------------- |
| V("clay", "莫兰迪", "陶土", "#C97B63", "#FFF6F0", W, "#8E4A36"), |
| V("sage", "莫兰迪", "鼠尾草", "#9CAF88", "#2F3D28", "#F4F8EF", "#2F3D28"), |
| V("dust", "莫兰迪", "灰粉", "#C4A69C", "#4A362F", "#FBF4F1", "#4A362F"), |
| V("fog", "莫兰迪", "雾蓝", "#A8B5BF", "#2B3742", "#F2F6F9", "#2B3742"), |
| # --- 暖色 ----------------------------------------------------------- |
| V("sunset", "暖色", "日落", grad("#FF9A5A", "#FF5E7E", 135), W, "#FFF0E8", W), |
| V("amber", "暖色", "琥珀", "#F5A623", "#3D2A08", "#FFF6E2", "#3D2A08"), |
| V("terracotta", "暖色", "赤陶", grad("#E2825A", "#C4553C", 135), |
| "#FFF2EA", W, "#8E3A26"), |
| # --- 自然 ----------------------------------------------------------- |
| V("ocean", "自然", "深海", grad("#0E4D64", "#1B7A8C", 160), "#DFF6F8", W, W), |
| V("moss", "自然", "苔原", grad("#2F4A34", "#1C2E20", 135), "#9FD4A8", W, "#6FA97A"), |
| V("desert", "自然", "沙漠", grad("#EBCF9C", "#D89A55", 135), |
| "#4A2E16", "#FFF8EC", "#4A2E16"), |
| V("glacier", "自然", "冰川", grad("#F0FAFF", "#BFE4F5", 135), |
| "#2C5F7C", "#6FB5D8", "#2C5F7C"), |
| # --- 金属(描边渐变)------------------------------------------------ |
| V("gold", "金属", "鎏金", "#141210", grad("#F7E7A0", "#B8860B", 120), |
| grad("#FFF8D8", "#D4AF37", 120), grad("#F7E7A0", "#B8860B", 120)), |
| V("chrome", "金属", "铬", "#16181C", grad("#F4F7FA", "#8A97A6", 120), |
| grad("#FFFFFF", "#B8C4D0", 120), grad("#F4F7FA", "#8A97A6", 120)), |
| # --- 高对比 --------------------------------------------------------- |
| # Not a style but an obligation: one-colour printing, and 7:1 contrast. |
| V("mono-black", "高对比", "纯黑", W, "#000000", "#000000", "#000000"), |
| V("mono-white", "高对比", "纯白", "#000000", W, W, W), |
| V("hazard", "高对比", "黑黄", "#111111", "#FFD400", "#FFD400", "#FFD400"), |
| ] |
| |
| |
| # --- svg -------------------------------------------------------------------- |
| def svg(variant, transparent=False, joint=None, box=None, inset=0.0): |
| name = variant["name"] |
| bg = variant["bg"] |
| # the bare mark is cropped to the glyph's bounding box |
| box = box or (mark_box() if transparent else ("0 0 1024 1024", 1024, 1024)) |
| out = ['<svg xmlns="http://www.w3.org/2000/svg" viewBox="%s" ' |
| 'width="%d" height="%d">' % box, |
| ' <title>%s</title>' % variant["label"]] |
| defs = [] |
| |
| def paint_of(spec, ident, user_space): |
| """A fill/stroke value, registering a gradient def when needed. |
| |
| Stroke gradients must be userSpaceOnUse: under the default |
| objectBoundingBox each path gets its own box, so the ramp would |
| restart at every seam between body, tip and bar. |
| """ |
| gr = as_grad(spec) |
| if gr is None: |
| return spec |
| c1, c2, angle = gr |
| if user_space: |
| _, mw, mh = mark_box() |
| p1, p2 = grad_axis(angle, (FOOT_L[0] - HW, BAR_Y - HW, |
| float(mw), float(mh))) |
| coords = ('x1="%.2f" y1="%.2f" x2="%.2f" y2="%.2f" ' |
| 'gradientUnits="userSpaceOnUse"' % (p1 + p2)) |
| else: |
| p1, p2 = grad_axis(angle, (0.0, 0.0, 1.0, 1.0)) |
| coords = 'x1="%.4f" y1="%.4f" x2="%.4f" y2="%.4f"' % (p1 + p2) |
| defs.append(' <linearGradient id="%s" %s>' |
| '<stop offset="0" stop-color="%s"/>' |
| '<stop offset="1" stop-color="%s"/></linearGradient>' |
| % (ident, coords, c1, c2)) |
| return "url(#%s)" % ident |
| |
| paint = paint_of(bg, "bg-" + name, False) |
| strokes = {p: paint_of(variant[p], "%s-%s" % (p, name), True) |
| for p in ("body", "tip", "bar")} |
| if defs: |
| out += [' <defs>'] + defs + [' </defs>'] |
| |
| if not transparent: |
| if inset: |
| out.append(' <g transform="translate(%g %g) scale(%g)">' |
| % (inset * SIZE, inset * SIZE, 1 - 2 * inset)) |
| out.append(' <rect width="1024" height="1024" rx="229" ry="229" fill="%s"/>' % paint) |
| if inset: |
| out.append(' </g>') |
| if inset: |
| out.append(' <g transform="translate(%g %g) scale(%g)">' |
| % (inset * SIZE, inset * SIZE, 1 - 2 * inset)) |
| out.append(' <g fill="none" stroke-width="70" stroke-miterlimit="8">') |
| for part, points, cap, join in parts(joint): |
| d = "M " + " L ".join("%.1f %.1f" % p for p in points) |
| out.append(' <path d="%s" stroke="%s" stroke-linecap="%s" ' |
| 'stroke-linejoin="%s"/>' % (d, strokes[part], cap, join)) |
| out.append(' </g>') |
| if inset: |
| out.append(' </g>') |
| out += ['</svg>', ''] |
| return "\n".join(out) |
| |
| |
| # --- png -------------------------------------------------------------------- |
| def rgb(h): |
| h = h.lstrip("#") |
| return (int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)) |
| |
| |
| def as_grad(spec): |
| """Normalise a paint spec to (c1, c2, angle) or None if it is flat. |
| |
| A bare 2-tuple is the original top-to-bottom form and stays valid. |
| """ |
| if isinstance(spec, str): |
| return None |
| if spec[0] == "grad": |
| return (spec[1], spec[2], spec[3] if len(spec) > 3 else 90) |
| return (spec[0], spec[1], 90) |
| |
| |
| def grad_axis(angle, box): |
| """The two endpoints of the gradient axis, matching how SVG maps a |
| linearGradient onto a box: the unit-square endpoints scaled onto it.""" |
| x0, y0, w, h = box |
| a = math.radians(angle) |
| cx, sy = math.cos(a), math.sin(a) |
| p1 = (x0 + (0.5 - cx / 2) * w, y0 + (0.5 - sy / 2) * h) |
| p2 = (x0 + (0.5 + cx / 2) * w, y0 + (0.5 + sy / 2) * h) |
| return p1, p2 |
| |
| |
| def ramp(spec, box): |
| """Compile a paint spec into f(x, y) -> (r, g, b).""" |
| gr = as_grad(spec) |
| if gr is None: |
| c = rgb(spec) |
| return lambda x, y: c |
| ca, cb, angle = rgb(gr[0]), rgb(gr[1]), gr[2] |
| (px, py), (qx, qy) = grad_axis(angle, box) |
| dx, dy = qx - px, qy - py |
| den = dx * dx + dy * dy or 1.0 |
| |
| def f(x, y): |
| t = ((x - px) * dx + (y - py) * dy) / den |
| t = 0.0 if t < 0.0 else (1.0 if t > 1.0 else t) |
| return (ca[0] + (cb[0] - ca[0]) * t, |
| ca[1] + (cb[1] - ca[1]) * t, |
| ca[2] + (cb[2] - ca[2]) * t) |
| return f |
| |
| |
| def miter_rhombus(p, v, n): |
| """The wedge a miter join fills at vertex `v`, between segments p->v->n. |
| |
| Returned as the full rhombus where the two stroke bands' infinite strips |
| cross, not just the wedge above the vertex: the extra half sits inside the |
| two bands, so this overlaps them instead of merely abutting them. Abutting |
| shapes each cover ~50% of the pixels along the shared edge and the union |
| would show a hairline of whatever is underneath. Returns None if straight. |
| """ |
| d1 = (v[0] - p[0], v[1] - p[1]) |
| d2 = (n[0] - v[0], n[1] - v[1]) |
| l1, l2 = math.hypot(*d1), math.hypot(*d2) |
| d1, d2 = (d1[0] / l1, d1[1] / l1), (d2[0] / l2, d2[1] / l2) |
| cross = d1[0] * d2[1] - d1[1] * d2[0] |
| if abs(cross) < 1e-9: |
| return None |
| k = HW / cross |
| pts = [(v[0] + k * (s1 * d2[0] - s2 * d1[0]), |
| v[1] + k * (s1 * d2[1] - s2 * d1[1])) |
| for s1 in (1, -1) for s2 in (1, -1)] |
| pts.sort(key=lambda q: math.atan2(q[1] - v[1], q[0] - v[0])) |
| return pts |
| |
| |
| def prims(joint=None): |
| """Flatten the parts into drawing primitives with bounding boxes.""" |
| out = [] |
| for part, points, cap, join in parts(joint): |
| for i in range(len(points) - 1): |
| (ax, ay), (bx, by) = points[i], points[i + 1] |
| ra = cap == "round" if i == 0 else join == "round" |
| rb = cap == "round" if i == len(points) - 2 else join == "round" |
| out.append((part, "seg", (ax, ay, bx, by, ra, rb), |
| (min(ax, bx) - HW - 2, min(ay, by) - HW - 2, |
| max(ax, bx) + HW + 2, max(ay, by) + HW + 2))) |
| if join == "miter": |
| for i in range(1, len(points) - 1): |
| q = miter_rhombus(points[i - 1], points[i], points[i + 1]) |
| if q: |
| xs, ys = [p[0] for p in q], [p[1] for p in q] |
| out.append((part, "poly", q, |
| (min(xs) - 2, min(ys) - 2, max(xs) + 2, max(ys) + 2))) |
| return out |
| |
| |
| _PRIMS = {} |
| |
| |
| def prims_for(joint): |
| joint = joint or JOINT |
| if joint not in _PRIMS: |
| _PRIMS[joint] = prims(joint) |
| return _PRIMS[joint] |
| |
| |
| def seg_sdf(px, py, ax, ay, bx, by, ra, rb): |
| vx, vy = bx - ax, by - ay |
| length = math.hypot(vx, vy) |
| ux, uy = vx / length, vy / length |
| wx, wy = px - ax, py - ay |
| s = wx * ux + wy * uy # axial position, 0..length |
| dp = abs(wx * uy - wy * ux) # perpendicular distance |
| d = max(dp - HW, -s, s - length) # band with butt ends |
| if ra: |
| d = min(d, math.hypot(wx, wy) - HW) |
| if rb: |
| d = min(d, math.hypot(px - bx, py - by) - HW) |
| return d |
| |
| |
| def poly_sdf(px, py, pts): |
| """Exact distance to a convex polygon, negative inside.""" |
| best = 1e18 |
| pos = neg = False |
| for i in range(len(pts)): |
| ax, ay = pts[i] |
| bx, by = pts[(i + 1) % len(pts)] |
| vx, vy = bx - ax, by - ay |
| wx, wy = px - ax, py - ay |
| t = (wx * vx + wy * vy) / (vx * vx + vy * vy) |
| t = 0.0 if t < 0.0 else (1.0 if t > 1.0 else t) |
| dx, dy = wx - t * vx, wy - t * vy |
| best = min(best, math.sqrt(dx * dx + dy * dy)) |
| if vx * wy - vy * wx > 0.0: # same side of every edge = inside, |
| pos = True # whichever way the quad is wound |
| else: |
| neg = True |
| return best if (pos and neg) else -best |
| |
| |
| def render(variant, size, transparent=False, joint=None, inset=0.0): |
| k = 1.0 - 2.0 * inset |
| scale = size / SIZE * k # pixels per design unit |
| aa = 1.0 / scale # antialiasing width, design units |
| origin = inset * SIZE * (size / SIZE) # margin, in pixels |
| half = SIZE / 2.0 |
| inner = half - CORNER_R |
| prim = prims_for(joint) |
| order = list(dict.fromkeys(p for p, _, _, _ in prim)) |
| # the tile gradient spans the canvas; a stroke gradient spans the glyph's |
| # bounding box, so it matches the SVG's userSpaceOnUse ramp exactly |
| _, mw, mh = mark_box() |
| mbox = (FOOT_L[0] - HW, BAR_Y - HW, float(mw), float(mh)) |
| bg_paint = ramp(variant["bg"], (0.0, 0.0, SIZE, SIZE)) |
| part_paint = {p: ramp(variant[p], mbox) for p in order} |
| |
| rows = [] |
| for iy in range(size): |
| y = (iy + 0.5 - origin) / scale |
| row = bytearray(b"\x00") # PNG filter: none |
| for ix in range(size): |
| x = (ix + 0.5 - origin) / scale |
| |
| cover = {} |
| for part, kind, data, (x0, y0, x1, y1) in prim: |
| if x < x0 or x > x1 or y < y0 or y > y1: |
| continue |
| d = (seg_sdf(x, y, *data) if kind == "seg" |
| else poly_sdf(x, y, data)) |
| if d < aa: |
| c = min(1.0, max(0.0, 0.5 - d / aa)) |
| if c > cover.get(part, 0.0): |
| cover[part] = c |
| |
| if transparent: |
| alpha = 0.0 |
| r = g = b = 0.0 |
| else: |
| qx = max(abs(x - half) - inner, 0.0) |
| qy = max(abs(y - half) - inner, 0.0) |
| d = math.hypot(qx, qy) - CORNER_R |
| alpha = min(1.0, max(0.0, 0.5 - d / aa)) |
| r, g, b = bg_paint(x, y) |
| |
| for part in order: |
| c = cover.get(part, 0.0) |
| if not c: |
| continue |
| if not transparent: |
| c = min(c, alpha) # never paint outside the tile |
| else: |
| alpha = max(alpha, c) |
| cr, cg, cb = part_paint[part](x, y) |
| r += (cr - r) * c |
| g += (cg - g) * c |
| b += (cb - b) * c |
| |
| px = (r, g, b, alpha * 255) |
| row += bytes(0 if c < 0 else (255 if c > 255 else int(c + .5)) for c in px) |
| rows.append(bytes(row)) |
| return b"".join(rows) |
| |
| |
| def write_png(path, size, raw, height=None, rgb=False): |
| with open(path, "wb") as handle: |
| write_png_stream(handle, size, raw, height=height, rgb=rgb) |
| |
| |
| def write_png_stream(handle, size, raw, height=None, rgb=False): |
| """Write raw scanlines out as a PNG. |
| |
| Defaults to the square RGBA image every icon is; `height` and `rgb` exist |
| for the contact sheet, which is neither. |
| """ |
| color_type = 2 if rgb else 6 # 2 = RGB, 6 = RGBA |
| h = height or size |
| |
| def chunk(tag, data): |
| return (struct.pack(">I", len(data)) + tag + data |
| + struct.pack(">I", zlib.crc32(tag + data) & 0xFFFFFFFF)) |
| fh = handle |
| if True: |
| fh.write(b"\x89PNG\r\n\x1a\n") |
| fh.write(chunk(b"IHDR", |
| struct.pack(">IIBBBBB", size, h, 8, color_type, 0, 0, 0))) |
| fh.write(chunk(b"IDAT", zlib.compress(raw, 9))) |
| fh.write(chunk(b"IEND", b"")) |
| |
| |
| MACOS_MARGIN = 100 / 1024.0 |
| ART_SIZE = 1024 |
| |
| |
| def art_directory(): |
| here = os.path.dirname(os.path.abspath(__file__)) |
| return os.path.join(here, "..", "apps", "desktop", "assets", "app-icons") |
| |
| |
| def _render_one(variant): |
| """Render one icon. Top-level so it survives the pickling a Pool does.""" |
| return variant["name"], render(variant, ART_SIZE, inset=MACOS_MARGIN) |
| |
| |
| def main(argv): |
| check = "--check" in argv |
| # Positional names limit the run to a subset. This is a convenience for |
| # working on one colourway by hand — the test deliberately passes none, so |
| # CI always compares the whole catalogue. |
| wanted = {a for a in argv if not a.startswith("-")} |
| selected = [v for v in VARIANTS if not wanted or v["name"] in wanted] |
| unknown = wanted - {v["name"] for v in VARIANTS} |
| if unknown: |
| print("unknown icon(s): %s" % ", ".join(sorted(unknown))) |
| return 2 |
| dest = art_directory() |
| stale = [] |
| # Rasterising 38 tiles at 1024px is ~90s of single-threaded signed-distance |
| # evaluation, which is the difference between checking the whole catalogue |
| # in CI and checking a sample of it. The work is per-icon and pure, so it |
| # parallelises exactly. |
| workers = min(len(selected), os.cpu_count() or 1) |
| if workers > 1: |
| with Pool(workers) as pool: |
| rendered = pool.map(_render_one, selected) |
| else: |
| rendered = [_render_one(v) for v in selected] |
| |
| for name, raw in rendered: |
| path = os.path.join(dest, name + ".png") |
| if check: |
| buffer = io.BytesIO() |
| write_png_stream(buffer, ART_SIZE, raw) |
| with open(path, "rb") as handle: |
| if handle.read() != buffer.getvalue(): |
| stale.append(name) |
| else: |
| write_png(path, ART_SIZE, raw) |
| if not check: |
| print("wrote %d icons to %s" % (len(selected), dest)) |
| return 0 |
| if stale: |
| print("out of date: %s" % ", ".join(stale)) |
| print("run: python3 scripts/generate-app-icons.py") |
| return 1 |
| print("all %d icons match the committed artwork" % len(selected)) |
| return 0 |
| |
| |
| if __name__ == "__main__": |
| raise SystemExit(main(sys.argv[1:])) |
