307 lines
10 KiB
Python
307 lines
10 KiB
Python
#!/usr/bin/env python3
|
||
"""Generate MiSans bitmap font C arrays for ILI9341 LCD driver."""
|
||
|
||
import glob
|
||
import math
|
||
import os
|
||
import re
|
||
import sys
|
||
from PIL import Image, ImageDraw, ImageFont
|
||
|
||
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||
HEADER_IN = os.path.join(ROOT, "device", "LCD_ILI9341", "Drv_ILI9341_Lcd_ChineseFont.h")
|
||
HEADER_OUT = HEADER_IN
|
||
ENG_HEADER_IN = os.path.join(ROOT, "device", "LCD_ILI9341", "Drv_ILI9341_Lcd_EnglishFont.h")
|
||
ENG_HEADER_OUT = ENG_HEADER_IN
|
||
|
||
MISANS_DIR = os.path.join(os.path.dirname(ROOT), "..", "Doc", "UI", "MiSans")
|
||
MISANS_DIR = os.path.normpath(MISANS_DIR)
|
||
|
||
|
||
def find_ttf(name_part):
|
||
for path in glob.glob(os.path.join(MISANS_DIR, "**", "*.ttf"), recursive=True):
|
||
if name_part.lower() in os.path.basename(path).lower():
|
||
return path
|
||
raise FileNotFoundError(f"TTF matching {name_part} not found under {MISANS_DIR}")
|
||
|
||
|
||
def parse_chs_tables(text):
|
||
tables = {}
|
||
for m in re.finditer(r"const char (CHS\d+Table)\[\]\[2\] = \{(.*?)\};", text, re.S):
|
||
name = m.group(1)
|
||
body = m.group(2)
|
||
entries = []
|
||
comments = []
|
||
for line in body.splitlines():
|
||
cm = re.search(r"\{(0x[0-9A-Fa-f]{2})\s*,\s*(0x[0-9A-Fa-f]{2})\}", line)
|
||
if cm:
|
||
entries.append((int(cm.group(1), 16), int(cm.group(2), 16)))
|
||
cmt = re.search(r"//\s*(.+)", line)
|
||
comments.append(cmt.group(1).strip() if cmt else "")
|
||
tables[name] = list(zip(entries, comments))
|
||
return tables
|
||
|
||
|
||
def gbk_char(h, l):
|
||
return bytes([h, l]).decode("gbk", errors="replace")
|
||
|
||
|
||
def render_glyph(ch, size, font, square=True):
|
||
"""Rasterize into size×size with 1px margin so CJK strokes are not clipped."""
|
||
if square:
|
||
w = h = size
|
||
else:
|
||
w = size // 2
|
||
h = size
|
||
|
||
img = Image.new("L", (w, h), 0)
|
||
draw = ImageDraw.Draw(img)
|
||
pad = 1 if size >= 10 else 0
|
||
|
||
bbox = draw.textbbox((0, 0), ch, font=font)
|
||
tw = bbox[2] - bbox[0]
|
||
th = bbox[3] - bbox[1]
|
||
inner_w = max(1, w - 2 * pad)
|
||
inner_h = max(1, h - 2 * pad)
|
||
x = pad + (inner_w - tw) // 2 - bbox[0]
|
||
y = pad + (inner_h - th) // 2 - bbox[1]
|
||
# Prefer keeping top/bottom strokes inside the bitmap
|
||
if y < pad:
|
||
y = pad
|
||
if y + th > h - pad:
|
||
y = max(pad, h - pad - th)
|
||
if x < pad:
|
||
x = pad
|
||
draw.text((x, y), ch, fill=255, font=font)
|
||
|
||
pixels = []
|
||
for row in range(h):
|
||
for col in range(w):
|
||
pixels.append(1 if img.getpixel((col, row)) > 127 else 0)
|
||
return pixels, w, h
|
||
|
||
|
||
def cn_to_bytes_msb(pixels, width, height):
|
||
row_bytes = (width + 7) // 8
|
||
out = []
|
||
for row in range(height):
|
||
for bi in range(row_bytes):
|
||
val = 0
|
||
for bit in range(8):
|
||
col = bi * 8 + bit
|
||
if col < width and pixels[row * width + col]:
|
||
val |= (0x80 >> bit)
|
||
elif col >= width:
|
||
pass
|
||
out.append(val)
|
||
return out
|
||
|
||
|
||
def ascii_to_bytes_lsb(pixels, width, height):
|
||
row_bytes = (width + 7) // 8
|
||
out = []
|
||
for row in range(height):
|
||
for bi in range(row_bytes):
|
||
val = 0
|
||
for bit in range(8):
|
||
col = bi * 8 + bit
|
||
if col < width and pixels[row * width + col]:
|
||
val |= (0x01 << bit)
|
||
out.append(val)
|
||
return out
|
||
|
||
|
||
def fmt_bytes(data):
|
||
parts = []
|
||
for i, b in enumerate(data):
|
||
parts.append(f"0x{b:02X}")
|
||
lines = []
|
||
for i in range(0, len(parts), 16):
|
||
lines.append(",".join(parts[i:i + 16]))
|
||
return "{" + ",".join(lines) + "}"
|
||
|
||
|
||
def generate_chinese_array(table_name, entries, size, font):
|
||
lines = [f"const unsigned char Chinese_font_{size}[][{((size + 7)//8)*size}] = {{"]
|
||
for idx, ((h, l), comment) in enumerate(entries):
|
||
ch = gbk_char(h, l)
|
||
pixels, w, hgt = render_glyph(ch, size, font, square=True)
|
||
data = cn_to_bytes_msb(pixels, w, hgt)
|
||
cmt = comment or ch
|
||
lines.append(f"{fmt_bytes(data)},/*\"{cmt}\",{idx}*/")
|
||
lines.append("};")
|
||
return "\n".join(lines)
|
||
|
||
|
||
def generate_ascii_array(size, font, array_name=None):
|
||
sizex = size // 2
|
||
row_bytes = (sizex + 7) // 8
|
||
total = row_bytes * size
|
||
suffix = f"{size}{sizex}"
|
||
name = array_name or f"ascii_{suffix}"
|
||
lines = [f"const unsigned char {name}[][{total}]={{"]
|
||
|
||
for num in range(95):
|
||
ch = chr(num + 32)
|
||
pixels, w, hgt = render_glyph(ch, size, font, square=False)
|
||
data = ascii_to_bytes_lsb(pixels, w, hgt)
|
||
lines.append(f"{fmt_bytes(data)},/*\"{ch}\",{num}*/")
|
||
lines.append("};")
|
||
return name, "\n".join(lines)
|
||
|
||
|
||
def patch_header_chinese(text, tables, fonts_by_size):
|
||
# Replace each Chinese_font_XX array
|
||
for size, font in fonts_by_size.items():
|
||
table_key = {
|
||
8: "CHS8Table",
|
||
11: "CHS11Table",
|
||
12: "CHS12Table",
|
||
13: "CHS13Table",
|
||
15: "CHS15Table",
|
||
16: "CHS16Table",
|
||
28: "CHS24Table", # reuse 24 table chars for 28 if no CHS28
|
||
}.get(size)
|
||
|
||
if size == 28:
|
||
table_key = "CHS24Table"
|
||
if table_key not in tables:
|
||
print(f"Skip size {size}: no {table_key}")
|
||
continue
|
||
|
||
entries = tables[table_key]
|
||
new_array = generate_chinese_array(table_key, entries, size, font)
|
||
|
||
pat = rf"const unsigned char Chinese_font_{size}\[\]\[\d+\] = \{{.*?\}};"
|
||
if re.search(pat, text, re.S):
|
||
text = re.sub(pat, new_array, text, count=1, flags=re.S)
|
||
else:
|
||
# insert before Chinese_font for next size or at end of tables section
|
||
insert_after = f"const char {table_key}"
|
||
# add new table for CHS8/CHS15 if missing
|
||
pass
|
||
|
||
return text
|
||
|
||
|
||
def ensure_chs8_table(text, tables):
|
||
if "CHS8Table" in tables:
|
||
return text, tables
|
||
if "CHS12Table" not in tables:
|
||
return text, tables
|
||
# Insert CHS8Table copy of CHS12Table before CHS11Table
|
||
entries = tables["CHS12Table"]
|
||
block = "const char CHS8Table[][2] = {\n"
|
||
for (h, l), cmt in entries:
|
||
block += f" {{0x{h:02X},0x{l:02X}}}, // {cmt}\n"
|
||
block += "};\n\n"
|
||
text = text.replace("const char CHS11Table", block + "const char CHS11Table", 1)
|
||
tables["CHS8Table"] = entries
|
||
return text, tables
|
||
|
||
|
||
def ensure_chs15_table(text, tables):
|
||
if "CHS15Table" in tables:
|
||
return text, tables
|
||
if "CHS13Table" not in tables:
|
||
return text, tables
|
||
entries = tables["CHS13Table"]
|
||
block = "const char CHS15Table[][2] = {\n"
|
||
for (h, l), cmt in entries:
|
||
block += f" {{0x{h:02X},0x{l:02X}}}, // {cmt}\n"
|
||
block += "};\n\n"
|
||
text = text.replace("const char CHS16Table", block + "const char CHS16Table", 1)
|
||
tables["CHS15Table"] = entries
|
||
return text, tables
|
||
|
||
|
||
def main():
|
||
medium = find_ttf("MiSans-Medium")
|
||
semibold = find_ttf("MiSans-Semibold")
|
||
print("Medium:", medium)
|
||
print("Semibold:", semibold)
|
||
|
||
with open(HEADER_IN, "r", encoding="utf-8", errors="replace") as f:
|
||
text = f.read()
|
||
|
||
tables = parse_chs_tables(text)
|
||
print("Tables:", {k: len(v) for k, v in tables.items()})
|
||
|
||
text, tables = ensure_chs8_table(text, tables)
|
||
text, tables = ensure_chs15_table(text, tables)
|
||
|
||
# Regenerate all Chinese font arrays
|
||
cn_sizes = [8, 11, 12, 13, 15, 16, 24, 28]
|
||
for size in cn_sizes:
|
||
if size in (24, 28):
|
||
table_key = "CHS24Table"
|
||
font = ImageFont.truetype(semibold if size == 28 else medium, size - 2)
|
||
else:
|
||
table_key = {
|
||
8: "CHS8Table", 11: "CHS11Table", 12: "CHS12Table",
|
||
13: "CHS13Table", 15: "CHS15Table", 16: "CHS16Table",
|
||
}[size]
|
||
font = ImageFont.truetype(medium, max(6, size - 2))
|
||
|
||
if table_key not in tables:
|
||
continue
|
||
entries = tables[table_key]
|
||
new_array = generate_chinese_array(table_key, entries, size, font)
|
||
pat = rf"const unsigned char Chinese_font_{size}\[\]\[\d+\] =[\s\S]*?\}};"
|
||
if re.search(pat, text, re.S):
|
||
text = re.sub(pat, new_array, text, count=1, flags=re.S)
|
||
print(f"Updated Chinese_font_{size} ({len(entries)} glyphs)")
|
||
else:
|
||
# Insert new array before Chinese_font for next existing or after CHS tables
|
||
anchor = "const unsigned char Chinese_font_11"
|
||
if size == 8:
|
||
anchor = "const unsigned char Chinese_font_11"
|
||
elif size == 15:
|
||
anchor = "const unsigned char Chinese_font_16"
|
||
elif size == 28:
|
||
anchor = None
|
||
if anchor and anchor in text:
|
||
text = text.replace(anchor, new_array + "\n\n" + anchor, 1)
|
||
print(f"Inserted Chinese_font_{size}")
|
||
elif size == 28:
|
||
text = text.rstrip() + "\n\n" + new_array + "\n"
|
||
print(f"Appended Chinese_font_{size}")
|
||
|
||
with open(HEADER_OUT, "w", encoding="utf-8", newline="\n") as f:
|
||
f.write(text)
|
||
|
||
# English / ASCII fonts
|
||
with open(ENG_HEADER_IN, "r", encoding="utf-8", errors="replace") as f:
|
||
eng = f.read()
|
||
|
||
ascii_targets = [
|
||
(8, medium, None), (11, medium, None), (12, medium, None), (13, medium, "ascii_1306"),
|
||
(15, medium, None), (16, medium, "ascii_1608"), (24, medium, "ascii_2412"),
|
||
(28, semibold, None),
|
||
]
|
||
for size, ttf, legacy_name in ascii_targets:
|
||
font = ImageFont.truetype(ttf, size - 1)
|
||
name, arr = generate_ascii_array(size, font, legacy_name)
|
||
pat = rf"const unsigned char {name}\[\]\[\d+\][\s\S]*?\}};"
|
||
if re.search(pat, eng, re.S):
|
||
eng = re.sub(pat, arr, eng, count=1, flags=re.S)
|
||
print(f"Updated {name}")
|
||
else:
|
||
auto_name, _ = generate_ascii_array(size, font)
|
||
pat2 = rf"const unsigned char {auto_name}\[\]\[\d+\][\s\S]*?\}};"
|
||
if auto_name != name and re.search(pat2, eng, re.S):
|
||
eng = re.sub(pat2, arr, eng, count=1, flags=re.S)
|
||
print(f"Updated {auto_name} -> {name}")
|
||
else:
|
||
eng = eng.rstrip() + "\n\n" + arr + "\n"
|
||
print(f"Appended {name}")
|
||
|
||
with open(ENG_HEADER_OUT, "w", encoding="utf-8", newline="\n") as f:
|
||
f.write(eng)
|
||
|
||
print("Done.")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|