237 lines
6.5 KiB
Python
237 lines
6.5 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Generate squircle app icons with a house + check mark glyph.
|
|
|
|
No external dependencies. Writes PNGs using zlib and CRC via stdlib.
|
|
|
|
Usage:
|
|
python3 scripts/render_icon.py assets/app_icon/house_check 1024 512 256 192 128 96 64 48 32
|
|
"""
|
|
import os
|
|
import sys
|
|
import math
|
|
import struct
|
|
import zlib
|
|
from typing import List, Tuple
|
|
|
|
|
|
NAVY = (0x0F, 0x17, 0x2A, 255) # #0F172A
|
|
WHITE = (255, 255, 255, 255)
|
|
GREEN = (0x10, 0xB9, 0x81, 255) # #10B981
|
|
|
|
|
|
def srgb_to_lin(c: float) -> float:
|
|
c = c / 255.0
|
|
if c <= 0.04045:
|
|
return c / 12.92
|
|
return ((c + 0.055) / 1.055) ** 2.4
|
|
|
|
|
|
def lin_to_srgb(c: float) -> int:
|
|
if c <= 0.0031308:
|
|
v = 12.92 * c
|
|
else:
|
|
v = 1.055 * (c ** (1.0 / 2.4)) - 0.055
|
|
return max(0, min(255, int(round(v * 255.0))))
|
|
|
|
|
|
def over(dst: Tuple[float, float, float, float], src: Tuple[float, float, float, float]):
|
|
# dst, src in linear space RGBA (0..1)
|
|
dr, dg, db, da = dst
|
|
sr, sg, sb, sa = src
|
|
out_a = sa + da * (1.0 - sa)
|
|
if out_a == 0.0:
|
|
return (0.0, 0.0, 0.0, 0.0)
|
|
out_r = (sr * sa + dr * da * (1.0 - sa)) / out_a
|
|
out_g = (sg * sa + dg * da * (1.0 - sa)) / out_a
|
|
out_b = (sb * sa + db * da * (1.0 - sa)) / out_a
|
|
return (out_r, out_g, out_b, out_a)
|
|
|
|
|
|
def to_lin_rgba(color: Tuple[int, int, int, int], alpha_scale: float = 1.0):
|
|
r, g, b, a = color
|
|
return (
|
|
srgb_to_lin(r),
|
|
srgb_to_lin(g),
|
|
srgb_to_lin(b),
|
|
(a / 255.0) * alpha_scale,
|
|
)
|
|
|
|
|
|
def point_in_triangle(px, py, ax, ay, bx, by, cx, cy) -> bool:
|
|
# Barycentric technique
|
|
v0x, v0y = cx - ax, cy - ay
|
|
v1x, v1y = bx - ax, by - ay
|
|
v2x, v2y = px - ax, py - ay
|
|
dot00 = v0x * v0x + v0y * v0y
|
|
dot01 = v0x * v1x + v0y * v1y
|
|
dot02 = v0x * v2x + v0y * v2y
|
|
dot11 = v1x * v1x + v1y * v1y
|
|
dot12 = v1x * v2x + v1y * v2y
|
|
denom = dot00 * dot11 - dot01 * dot01
|
|
if denom == 0:
|
|
return False
|
|
inv = 1.0 / denom
|
|
u = (dot11 * dot02 - dot01 * dot12) * inv
|
|
v = (dot00 * dot12 - dot01 * dot02) * inv
|
|
return (u >= 0) and (v >= 0) and (u + v <= 1)
|
|
|
|
|
|
def point_in_rect(px, py, x0, y0, x1, y1) -> bool:
|
|
return (x0 <= px <= x1) and (y0 <= py <= y1)
|
|
|
|
|
|
def dist_point_to_segment(px, py, ax, ay, bx, by) -> float:
|
|
abx, aby = bx - ax, by - ay
|
|
apx, apy = px - ax, py - ay
|
|
ab2 = abx * abx + aby * aby
|
|
if ab2 == 0:
|
|
dx, dy = px - ax, py - ay
|
|
return math.hypot(dx, dy)
|
|
t = (apx * abx + apy * aby) / ab2
|
|
if t < 0:
|
|
t = 0
|
|
elif t > 1:
|
|
t = 1
|
|
hx, hy = ax + t * abx, ay + t * aby
|
|
dx, dy = px - hx, py - hy
|
|
return math.hypot(dx, dy)
|
|
|
|
|
|
def inside_superellipse(u: float, v: float, n: float = 4.5) -> bool:
|
|
# map [0,1] -> [-1,1]
|
|
x = 2.0 * u - 1.0
|
|
y = 2.0 * v - 1.0
|
|
return (abs(x) ** n + abs(y) ** n) <= 1.0
|
|
|
|
|
|
def render_icon(size: int) -> bytes:
|
|
# 2x2 supersampling
|
|
samples = [(0.25, 0.25), (0.75, 0.25), (0.25, 0.75), (0.75, 0.75)]
|
|
|
|
# House geometry (normalized 0..1)
|
|
roof = (0.28, 0.46, 0.50, 0.30, 0.72, 0.46) # (ax,ay,bx,by,cx,cy)
|
|
body = (0.32, 0.46, 0.68, 0.76) # (x0,y0,x1,y1)
|
|
|
|
# Check path
|
|
chk_a = (0.33, 0.60)
|
|
chk_b = (0.46, 0.74)
|
|
chk_c = (0.72, 0.48)
|
|
thickness = 0.08 # relative to width
|
|
|
|
lin_bg = to_lin_rgba(NAVY)
|
|
lin_white = to_lin_rgba(WHITE)
|
|
lin_green = to_lin_rgba(GREEN)
|
|
|
|
out = bytearray(size * size * 4)
|
|
idx = 0
|
|
for j in range(size):
|
|
for i in range(size):
|
|
# Accumulate in linear
|
|
dst = (0.0, 0.0, 0.0, 0.0)
|
|
|
|
cov_bg = 0.0
|
|
cov_house = 0.0
|
|
cov_check = 0.0
|
|
for (ox, oy) in samples:
|
|
u = (i + ox) / size
|
|
v = (j + oy) / size
|
|
|
|
if inside_superellipse(u, v):
|
|
cov_bg += 1.0
|
|
|
|
hx = 0
|
|
# house coverage (triangle or rect)
|
|
if point_in_triangle(u, v, *roof):
|
|
hx = 1
|
|
elif point_in_rect(u, v, *body):
|
|
hx = 1
|
|
cov_house += hx
|
|
|
|
# check coverage by distance to segments
|
|
d1 = dist_point_to_segment(u, v, *chk_a, *chk_b)
|
|
d2 = dist_point_to_segment(u, v, *chk_b, *chk_c)
|
|
if min(d1, d2) <= (thickness * 0.5):
|
|
cov_check += 1.0
|
|
|
|
ss = float(len(samples))
|
|
if cov_bg > 0.0:
|
|
dst = over(dst, (lin_bg[0], lin_bg[1], lin_bg[2], lin_bg[3] * (cov_bg / ss)))
|
|
if cov_house > 0.0:
|
|
dst = over(dst, (lin_white[0], lin_white[1], lin_white[2], lin_white[3] * (cov_house / ss)))
|
|
if cov_check > 0.0:
|
|
dst = over(dst, (lin_green[0], lin_green[1], lin_green[2], lin_green[3] * (cov_check / ss)))
|
|
|
|
r = lin_to_srgb(dst[0])
|
|
g = lin_to_srgb(dst[1])
|
|
b = lin_to_srgb(dst[2])
|
|
a = max(0, min(255, int(round(dst[3] * 255.0))))
|
|
|
|
out[idx + 0] = r
|
|
out[idx + 1] = g
|
|
out[idx + 2] = b
|
|
out[idx + 3] = a
|
|
idx += 4
|
|
|
|
return png_encode(size, size, bytes(out))
|
|
|
|
|
|
def png_chunk(typ: bytes, data: bytes) -> bytes:
|
|
return struct.pack(
|
|
">I", len(data)
|
|
) + typ + data + struct.pack(
|
|
">I", (zlib.crc32(typ + data) & 0xFFFFFFFF)
|
|
)
|
|
|
|
|
|
def png_encode(width: int, height: int, rgba: bytes) -> bytes:
|
|
# Build raw scanlines with filter 0
|
|
stride = width * 4
|
|
raw = bytearray()
|
|
for y in range(height):
|
|
raw.append(0) # filter type 0
|
|
start = y * stride
|
|
raw.extend(rgba[start : start + stride])
|
|
comp = zlib.compress(bytes(raw), level=9)
|
|
|
|
sig = b"\x89PNG\r\n\x1a\n"
|
|
ihdr = struct.pack(
|
|
">IIBBBBB",
|
|
width,
|
|
height,
|
|
8, # bit depth
|
|
6, # color type RGBA
|
|
0, # compression
|
|
0, # filter
|
|
0, # interlace
|
|
)
|
|
out = bytearray()
|
|
out.extend(sig)
|
|
out.extend(png_chunk(b"IHDR", ihdr))
|
|
out.extend(png_chunk(b"IDAT", comp))
|
|
out.extend(png_chunk(b"IEND", b""))
|
|
return bytes(out)
|
|
|
|
|
|
def main():
|
|
if len(sys.argv) < 3:
|
|
print(
|
|
"Usage: python3 scripts/render_icon.py <out_dir> <sizes...>",
|
|
file=sys.stderr,
|
|
)
|
|
sys.exit(2)
|
|
out_dir = sys.argv[1]
|
|
sizes = [int(s) for s in sys.argv[2:]]
|
|
os.makedirs(out_dir, exist_ok=True)
|
|
for s in sizes:
|
|
data = render_icon(s)
|
|
path = os.path.join(out_dir, f"{s}.png")
|
|
with open(path, "wb") as f:
|
|
f.write(data)
|
|
print(f"wrote {path}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|
|
|