Atridad Lahiji
d4023133b7
All checks were successful
Ascently - Docs Deploy / build-and-push (push) Successful in 3m59s
395 lines
12 KiB
Python
Executable File
395 lines
12 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import xml.etree.ElementTree as ET
|
|
from pathlib import Path
|
|
from typing import Callable, TypedDict
|
|
from PIL import Image, ImageDraw
|
|
|
|
|
|
class Polygon(TypedDict):
|
|
coords: list[tuple[float, float]]
|
|
fill: str
|
|
|
|
|
|
SCRIPT_DIR = Path(__file__).parent
|
|
PROJECT_ROOT = SCRIPT_DIR.parent
|
|
SOURCE_DIR = SCRIPT_DIR / "source"
|
|
LOGOS_DIR = SCRIPT_DIR / "logos"
|
|
|
|
|
|
def parse_svg_polygons(svg_path: Path) -> list[Polygon]:
|
|
tree = ET.parse(svg_path)
|
|
root = tree.getroot()
|
|
|
|
ns = {"svg": "http://www.w3.org/2000/svg"}
|
|
polygons = root.findall(".//svg:polygon", ns)
|
|
if not polygons:
|
|
polygons = root.findall(".//polygon")
|
|
|
|
result: list[Polygon] = []
|
|
for poly in polygons:
|
|
points_str = poly.get("points", "").strip()
|
|
fill = poly.get("fill", "#000000")
|
|
|
|
coords: list[tuple[float, float]] = []
|
|
for pair in points_str.split():
|
|
x, y = pair.split(",")
|
|
coords.append((float(x), float(y)))
|
|
|
|
result.append({"coords": coords, "fill": fill})
|
|
|
|
return result
|
|
|
|
|
|
def get_bbox(polygons: list[Polygon]) -> dict[str, float]:
|
|
all_coords: list[tuple[float, float]] = []
|
|
for poly in polygons:
|
|
all_coords.extend(poly["coords"])
|
|
|
|
xs = [c[0] for c in all_coords]
|
|
ys = [c[1] for c in all_coords]
|
|
|
|
return {
|
|
"min_x": min(xs),
|
|
"max_x": max(xs),
|
|
"min_y": min(ys),
|
|
"max_y": max(ys),
|
|
"width": max(xs) - min(xs),
|
|
"height": max(ys) - min(ys),
|
|
}
|
|
|
|
|
|
def scale_and_center(
|
|
polygons: list[Polygon], viewbox_size: float, target_width: float
|
|
) -> list[Polygon]:
|
|
bbox = get_bbox(polygons)
|
|
|
|
scale = target_width / bbox["width"]
|
|
center = viewbox_size / 2
|
|
|
|
scaled_polys: list[Polygon] = []
|
|
for poly in polygons:
|
|
scaled_coords = [(x * scale, y * scale) for x, y in poly["coords"]]
|
|
scaled_polys.append({"coords": scaled_coords, "fill": poly["fill"]})
|
|
|
|
scaled_bbox = get_bbox(scaled_polys)
|
|
current_center_x = (scaled_bbox["min_x"] + scaled_bbox["max_x"]) / 2
|
|
current_center_y = (scaled_bbox["min_y"] + scaled_bbox["max_y"]) / 2
|
|
|
|
offset_x = center - current_center_x
|
|
offset_y = center - current_center_y
|
|
|
|
final_polys: list[Polygon] = []
|
|
for poly in scaled_polys:
|
|
final_coords = [(x + offset_x, y + offset_y) for x, y in poly["coords"]]
|
|
final_polys.append({"coords": final_coords, "fill": poly["fill"]})
|
|
|
|
return final_polys
|
|
|
|
|
|
def format_svg_points(coords: list[tuple[float, float]]) -> str:
|
|
return " ".join(f"{x:.3f},{y:.3f}" for x, y in coords)
|
|
|
|
|
|
def format_android_path(coords: list[tuple[float, float]]) -> str:
|
|
points = " ".join(f"{x:.3f},{y:.3f}" for x, y in coords)
|
|
pairs = points.split()
|
|
return f"M{pairs[0]} L{pairs[1]} L{pairs[2]} Z"
|
|
|
|
|
|
def generate_svg(polygons: list[Polygon], width: int, height: int) -> str:
|
|
lines = [
|
|
f'<svg width="{width}" height="{height}" viewBox="0 0 {width} {height}" xmlns="http://www.w3.org/2000/svg">'
|
|
]
|
|
for poly in polygons:
|
|
points = format_svg_points(poly["coords"])
|
|
lines.append(f' <polygon points="{points}" fill="{poly["fill"]}"/>')
|
|
lines.append("</svg>")
|
|
return "\n".join(lines)
|
|
|
|
|
|
def generate_android_vector(
|
|
polygons: list[Polygon], width: int, height: int, viewbox: int
|
|
) -> str:
|
|
lines = [
|
|
'<?xml version="1.0" encoding="utf-8"?>',
|
|
'<vector xmlns:android="http://schemas.android.com/apk/res/android"',
|
|
f' android:width="{width}dp"',
|
|
f' android:height="{height}dp"',
|
|
f' android:viewportWidth="{viewbox}"',
|
|
f' android:viewportHeight="{viewbox}">',
|
|
]
|
|
for poly in polygons:
|
|
path = format_android_path(poly["coords"])
|
|
lines.append(
|
|
f' <path android:fillColor="{poly["fill"]}" android:pathData="{path}" />'
|
|
)
|
|
lines.append("</vector>")
|
|
return "\n".join(lines)
|
|
|
|
|
|
def rasterize_svg(
|
|
svg_path: Path,
|
|
output_path: Path,
|
|
size: int,
|
|
bg_color: tuple[int, int, int, int] | None = None,
|
|
circular: bool = False,
|
|
) -> None:
|
|
from xml.dom import minidom
|
|
|
|
doc = minidom.parse(str(svg_path))
|
|
|
|
img = Image.new(
|
|
"RGBA", (size, size), (255, 255, 255, 0) if bg_color is None else bg_color
|
|
)
|
|
draw = ImageDraw.Draw(img)
|
|
|
|
svg_elem = doc.getElementsByTagName("svg")[0]
|
|
viewbox = svg_elem.getAttribute("viewBox").split()
|
|
if viewbox:
|
|
vb_width = float(viewbox[2])
|
|
vb_height = float(viewbox[3])
|
|
scale_x = size / vb_width
|
|
scale_y = size / vb_height
|
|
else:
|
|
scale_x = scale_y = 1
|
|
|
|
def parse_transform(
|
|
transform_str: str,
|
|
) -> Callable[[float, float], tuple[float, float]]:
|
|
import re
|
|
|
|
if not transform_str:
|
|
return lambda x, y: (x, y)
|
|
|
|
transforms: list[tuple[str, list[float]]] = []
|
|
for match in re.finditer(r"(\w+)\(([^)]+)\)", transform_str):
|
|
func, args_str = match.groups()
|
|
args = [float(x) for x in args_str.replace(",", " ").split()]
|
|
transforms.append((func, args))
|
|
|
|
def apply_transforms(x: float, y: float) -> tuple[float, float]:
|
|
for func, args in transforms:
|
|
if func == "translate":
|
|
x += args[0]
|
|
y += args[1] if len(args) > 1 else args[0]
|
|
elif func == "scale":
|
|
x *= args[0]
|
|
y *= args[1] if len(args) > 1 else args[0]
|
|
return x, y
|
|
|
|
return apply_transforms
|
|
|
|
for g in doc.getElementsByTagName("g"):
|
|
transform = parse_transform(g.getAttribute("transform"))
|
|
|
|
for poly in g.getElementsByTagName("polygon"):
|
|
points_str = poly.getAttribute("points").strip()
|
|
fill = poly.getAttribute("fill")
|
|
if not fill:
|
|
fill = "#000000"
|
|
|
|
coords: list[tuple[float, float]] = []
|
|
for pair in points_str.split():
|
|
x, y = pair.split(",")
|
|
x, y = float(x), float(y)
|
|
x, y = transform(x, y)
|
|
coords.append((x * scale_x, y * scale_y))
|
|
|
|
draw.polygon(coords, fill=fill)
|
|
|
|
for poly in doc.getElementsByTagName("polygon"):
|
|
if poly.parentNode and getattr(poly.parentNode, "tagName", None) == "g":
|
|
continue
|
|
|
|
points_str = poly.getAttribute("points").strip()
|
|
fill = poly.getAttribute("fill")
|
|
if not fill:
|
|
fill = "#000000"
|
|
|
|
coords = []
|
|
for pair in points_str.split():
|
|
x, y = pair.split(",")
|
|
coords.append((float(x) * scale_x, float(y) * scale_y))
|
|
|
|
draw.polygon(coords, fill=fill)
|
|
|
|
if circular:
|
|
mask = Image.new("L", (size, size), 0)
|
|
mask_draw = ImageDraw.Draw(mask)
|
|
mask_draw.ellipse((0, 0, size, size), fill=255)
|
|
img.putalpha(mask)
|
|
|
|
img.save(output_path)
|
|
|
|
|
|
def main() -> None:
|
|
print("Generating branding assets...")
|
|
|
|
logo_svg = SOURCE_DIR / "logo.svg"
|
|
icon_light = SOURCE_DIR / "icon-light.svg"
|
|
icon_dark = SOURCE_DIR / "icon-dark.svg"
|
|
icon_tinted = SOURCE_DIR / "icon-tinted.svg"
|
|
|
|
polygons = parse_svg_polygons(logo_svg)
|
|
|
|
print(" iOS...")
|
|
ios_assets = PROJECT_ROOT / "ios/Ascently/Assets.xcassets/AppIcon.appiconset"
|
|
|
|
for src, dst in [
|
|
(icon_light, ios_assets / "app_icon_light_template.svg"),
|
|
(icon_dark, ios_assets / "app_icon_dark_template.svg"),
|
|
(icon_tinted, ios_assets / "app_icon_tinted_template.svg"),
|
|
]:
|
|
with open(src) as f:
|
|
content = f.read()
|
|
with open(dst, "w") as f:
|
|
f.write(content)
|
|
|
|
img_light = Image.new("RGB", (1024, 1024), (255, 255, 255))
|
|
draw_light = ImageDraw.Draw(img_light)
|
|
scaled = scale_and_center(polygons, 1024, int(1024 * 0.7))
|
|
for poly in scaled:
|
|
coords = [(x, y) for x, y in poly["coords"]]
|
|
draw_light.polygon(coords, fill=poly["fill"])
|
|
img_light.save(ios_assets / "app_icon_1024.png")
|
|
|
|
img_dark = Image.new("RGB", (1024, 1024), (26, 26, 26))
|
|
draw_dark = ImageDraw.Draw(img_dark)
|
|
for poly in scaled:
|
|
coords = [(x, y) for x, y in poly["coords"]]
|
|
draw_dark.polygon(coords, fill=poly["fill"])
|
|
img_dark.save(ios_assets / "app_icon_1024_dark.png")
|
|
|
|
img_tinted = Image.new("RGB", (1024, 1024), (0, 0, 0))
|
|
draw_tinted = ImageDraw.Draw(img_tinted)
|
|
for i, poly in enumerate(scaled):
|
|
coords = [(x, y) for x, y in poly["coords"]]
|
|
draw_tinted.polygon(coords, fill=(0, 0, 0))
|
|
img_tinted.save(ios_assets / "app_icon_1024_tinted.png")
|
|
|
|
print(" Android...")
|
|
|
|
polys_108 = scale_and_center(polygons, 108, 60)
|
|
android_xml = generate_android_vector(polys_108, 108, 108, 108)
|
|
(
|
|
PROJECT_ROOT / "android/app/src/main/res/drawable/ic_launcher_foreground.xml"
|
|
).write_text(android_xml)
|
|
|
|
polys_24 = scale_and_center(polygons, 24, 20)
|
|
mountains_xml = generate_android_vector(polys_24, 24, 24, 24)
|
|
(PROJECT_ROOT / "android/app/src/main/res/drawable/ic_mountains.xml").write_text(
|
|
mountains_xml
|
|
)
|
|
|
|
for density, size in [
|
|
("mdpi", 48),
|
|
("hdpi", 72),
|
|
("xhdpi", 96),
|
|
("xxhdpi", 144),
|
|
("xxxhdpi", 192),
|
|
]:
|
|
mipmap_dir = PROJECT_ROOT / f"android/app/src/main/res/mipmap-{density}"
|
|
|
|
img = Image.new("RGBA", (size, size), (255, 255, 255, 255))
|
|
draw = ImageDraw.Draw(img)
|
|
|
|
scaled = scale_and_center(polygons, size, int(size * 0.6))
|
|
for poly in scaled:
|
|
coords = [(x, y) for x, y in poly["coords"]]
|
|
draw.polygon(coords, fill=poly["fill"])
|
|
|
|
img.save(mipmap_dir / "ic_launcher.webp")
|
|
|
|
img_round = Image.new("RGBA", (size, size), (255, 255, 255, 255))
|
|
draw_round = ImageDraw.Draw(img_round)
|
|
|
|
for poly in scaled:
|
|
coords = [(x, y) for x, y in poly["coords"]]
|
|
draw_round.polygon(coords, fill=poly["fill"])
|
|
|
|
mask = Image.new("L", (size, size), 0)
|
|
mask_draw = ImageDraw.Draw(mask)
|
|
mask_draw.ellipse((0, 0, size, size), fill=255)
|
|
img_round.putalpha(mask)
|
|
|
|
img_round.save(mipmap_dir / "ic_launcher_round.webp")
|
|
|
|
print(" Docs...")
|
|
|
|
polys_32 = scale_and_center(polygons, 32, 26)
|
|
logo_svg_32 = generate_svg(polys_32, 32, 32)
|
|
(PROJECT_ROOT / "docs/src/assets/logo.svg").write_text(logo_svg_32)
|
|
(PROJECT_ROOT / "docs/src/assets/logo-dark.svg").write_text(logo_svg_32)
|
|
|
|
polys_256 = scale_and_center(polygons, 256, 208)
|
|
logo_svg_256 = generate_svg(polys_256, 256, 256)
|
|
(PROJECT_ROOT / "docs/src/assets/logo-highres.svg").write_text(logo_svg_256)
|
|
|
|
logo_32_path = PROJECT_ROOT / "docs/src/assets/logo.svg"
|
|
rasterize_svg(logo_32_path, PROJECT_ROOT / "docs/public/favicon.png", 32)
|
|
|
|
sizes = [16, 32, 48]
|
|
imgs = []
|
|
for size in sizes:
|
|
img = Image.new("RGBA", (size, size), (255, 255, 255, 0))
|
|
draw = ImageDraw.Draw(img)
|
|
|
|
scaled = scale_and_center(polygons, size, int(size * 0.8))
|
|
for poly in scaled:
|
|
coords = [(x, y) for x, y in poly["coords"]]
|
|
draw.polygon(coords, fill=poly["fill"])
|
|
|
|
imgs.append(img)
|
|
|
|
imgs[0].save(
|
|
PROJECT_ROOT / "docs/public/favicon.ico",
|
|
format="ICO",
|
|
sizes=[(s, s) for s in sizes],
|
|
append_images=imgs[1:],
|
|
)
|
|
|
|
print(" Logos...")
|
|
|
|
LOGOS_DIR.mkdir(exist_ok=True)
|
|
|
|
sizes = [64, 128, 256, 512, 1024, 2048]
|
|
for size in sizes:
|
|
img = Image.new("RGBA", (size, size), (255, 255, 255, 0))
|
|
draw = ImageDraw.Draw(img)
|
|
|
|
scaled = scale_and_center(polygons, size, int(size * 0.8))
|
|
for poly in scaled:
|
|
coords = [(x, y) for x, y in poly["coords"]]
|
|
draw.polygon(coords, fill=poly["fill"])
|
|
|
|
img.save(LOGOS_DIR / f"logo-{size}.png")
|
|
|
|
for size in sizes:
|
|
img = Image.new("RGBA", (size, size), (255, 255, 255, 255))
|
|
draw = ImageDraw.Draw(img)
|
|
|
|
scaled = scale_and_center(polygons, size, int(size * 0.8))
|
|
for poly in scaled:
|
|
coords = [(x, y) for x, y in poly["coords"]]
|
|
draw.polygon(coords, fill=poly["fill"])
|
|
|
|
img.save(LOGOS_DIR / f"logo-{size}-white.png")
|
|
|
|
for size in sizes:
|
|
img = Image.new("RGBA", (size, size), (26, 26, 26, 255))
|
|
draw = ImageDraw.Draw(img)
|
|
|
|
scaled = scale_and_center(polygons, size, int(size * 0.8))
|
|
for poly in scaled:
|
|
coords = [(x, y) for x, y in poly["coords"]]
|
|
draw.polygon(coords, fill=poly["fill"])
|
|
|
|
img.save(LOGOS_DIR / f"logo-{size}-dark.png")
|
|
|
|
print("Done.")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|