160 lines
4.7 KiB
Python
160 lines
4.7 KiB
Python
import sys
|
|
import os
|
|
from PIL import Image
|
|
import cairosvg
|
|
import io
|
|
import xml.etree.ElementTree as ET
|
|
|
|
threshold = 128
|
|
|
|
|
|
def parse_svg_intrinsic_size(svg_data):
|
|
try:
|
|
root = ET.fromstring(svg_data)
|
|
except ET.ParseError:
|
|
return None, None
|
|
|
|
viewbox = root.get("viewBox") or root.get("viewbox")
|
|
if viewbox:
|
|
parts = viewbox.replace(",", " ").split()
|
|
if len(parts) == 4:
|
|
try:
|
|
vb_w = float(parts[2])
|
|
vb_h = float(parts[3])
|
|
if vb_w > 0 and vb_h > 0:
|
|
return vb_w, vb_h
|
|
except ValueError:
|
|
pass
|
|
|
|
def parse_len(value):
|
|
if not value:
|
|
return None
|
|
cleaned = "".join(ch for ch in value if ch.isdigit() or ch in ".-")
|
|
if not cleaned:
|
|
return None
|
|
try:
|
|
parsed = float(cleaned)
|
|
return parsed if parsed > 0 else None
|
|
except ValueError:
|
|
return None
|
|
|
|
w = parse_len(root.get("width"))
|
|
h = parse_len(root.get("height"))
|
|
return w, h
|
|
|
|
|
|
def fit_inside_canvas(src_w, src_h, dst_w, dst_h):
|
|
if src_w <= 0 or src_h <= 0 or dst_w <= 0 or dst_h <= 0:
|
|
return dst_w, dst_h
|
|
|
|
src_ratio = src_w / src_h
|
|
dst_ratio = dst_w / dst_h
|
|
|
|
if src_ratio >= dst_ratio:
|
|
fit_w = dst_w
|
|
fit_h = max(1, int(round(fit_w / src_ratio)))
|
|
else:
|
|
fit_h = dst_h
|
|
fit_w = max(1, int(round(fit_h * src_ratio)))
|
|
|
|
return fit_w, fit_h
|
|
|
|
|
|
def svg_to_png_bytes(svg_path, width, height):
|
|
with open(svg_path, "rb") as f:
|
|
svg_data = f.read()
|
|
|
|
src_w, src_h = parse_svg_intrinsic_size(svg_data)
|
|
render_w, render_h = fit_inside_canvas(
|
|
src_w or width, src_h or height, width, height
|
|
)
|
|
|
|
png_bytes = cairosvg.svg2png(
|
|
bytestring=svg_data, output_width=render_w, output_height=render_h
|
|
)
|
|
return png_bytes
|
|
|
|
|
|
def center_on_canvas(img, width, height):
|
|
if img.mode != "RGBA":
|
|
img = img.convert("RGBA")
|
|
canvas = Image.new("RGBA", (width, height), (255, 255, 255, 255))
|
|
x = (width - img.width) // 2
|
|
y = (height - img.height) // 2
|
|
canvas.paste(img, (x, y), img)
|
|
return canvas
|
|
|
|
|
|
def load_image(path, width, height):
|
|
ext = os.path.splitext(path)[1].lower()
|
|
if ext == ".svg":
|
|
png_bytes = svg_to_png_bytes(path, width, height)
|
|
img = Image.open(io.BytesIO(png_bytes)).convert("RGBA")
|
|
img = center_on_canvas(img, width, height)
|
|
else:
|
|
img = Image.open(path).convert("RGBA")
|
|
# Keep source aspect ratio and fit inside requested canvas.
|
|
fit = img.copy()
|
|
fit.thumbnail((width, height), Image.LANCZOS)
|
|
img = center_on_canvas(fit, width, height)
|
|
# Flatten alpha: paste on white background
|
|
background = Image.new("RGBA", img.size, (255, 255, 255, 255))
|
|
background.paste(img, mask=img.split()[3])
|
|
img = background
|
|
# Rotate 90 degrees counterclockwise
|
|
img = img.rotate(90, expand=True)
|
|
return img
|
|
|
|
|
|
def image_to_c_array(img, array_name):
|
|
# Convert to grayscale, then threshold to get white=1, black=0
|
|
# Convert to grayscale
|
|
img = img.convert("L")
|
|
width, height = img.size
|
|
pixels = list(img.getdata())
|
|
packed = []
|
|
for y in range(height):
|
|
for x in range(0, width, 8):
|
|
byte = 0
|
|
for b in range(8):
|
|
if x + b < width:
|
|
v = pixels[y * width + x + b]
|
|
# 1 for white, 0 for black
|
|
bit = 1 if v >= threshold else 0
|
|
byte |= bit << (7 - b)
|
|
packed.append(byte)
|
|
# Format as C array
|
|
c = f"#pragma once\n#include <cstdint>\n\n"
|
|
c += f"// size: {width}x{height}\n"
|
|
c += f"static const uint8_t {array_name}[] = {{\n "
|
|
for i, v in enumerate(packed):
|
|
c += f"0x{v:02X}, "
|
|
if (i + 1) % 16 == 0:
|
|
c += "\n "
|
|
c = c.rstrip(", \n") + "\n};\n"
|
|
return c
|
|
|
|
|
|
def main():
|
|
if len(sys.argv) < 5:
|
|
print("Usage: python convert_image.py input.png output_name width height")
|
|
sys.exit(1)
|
|
input_path, output_name, width, height = sys.argv[1:5]
|
|
array_name = output_name.capitalize() + "Icon"
|
|
width, height = int(width), int(height)
|
|
img = load_image(input_path, width, height)
|
|
c_array = image_to_c_array(img, array_name)
|
|
|
|
# Always save to src/components/icons/[output_name].h relative to project root
|
|
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
|
output_dir = os.path.join(project_root, "src", "components", "icons")
|
|
os.makedirs(output_dir, exist_ok=True)
|
|
output_path = os.path.join(output_dir, f"{output_name}.h")
|
|
with open(output_path, "w") as f:
|
|
f.write(c_array)
|
|
print(f"Wrote {output_path}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|