408 lines
14 KiB
Python
408 lines
14 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 _dilate(pixels, w, h, times=1):
|
||
cur = pixels[:]
|
||
for _ in range(times):
|
||
nxt = cur[:]
|
||
for y in range(h):
|
||
for x in range(w):
|
||
if cur[y * w + x]:
|
||
continue
|
||
hit = False
|
||
for dy in (-1, 0, 1):
|
||
for dx in (-1, 0, 1):
|
||
nx, ny = x + dx, y + dy
|
||
if 0 <= nx < w and 0 <= ny < h and cur[ny * w + nx]:
|
||
nxt[y * w + x] = 1
|
||
hit = True
|
||
break
|
||
if hit:
|
||
break
|
||
cur = nxt
|
||
return cur
|
||
|
||
|
||
def render_glyph(ch, size, font, square=True, threshold=90, pack_ink=False, thicken=0):
|
||
"""Rasterize into size×size (CJK) or (size/2)×size (ASCII).
|
||
|
||
pack_ink=True (recommended for size<=13): crop FreeType ink bbox, fit into
|
||
cell, lower threshold — keeps strokes at tiny LCD sizes where MiSans Medium
|
||
otherwise collapses to sparse fragments.
|
||
"""
|
||
if square:
|
||
w = h = size
|
||
else:
|
||
w = max(3, size // 2)
|
||
h = size
|
||
|
||
if not pack_ink:
|
||
scale = 4
|
||
big = Image.new("L", (w * scale, h * scale), 0)
|
||
draw = ImageDraw.Draw(big)
|
||
bbox = draw.textbbox((0, 0), ch, font=font)
|
||
tw = max(1, bbox[2] - bbox[0])
|
||
th = max(1, bbox[3] - bbox[1])
|
||
pad = scale
|
||
inner_w = w * scale - 2 * pad
|
||
inner_h = h * scale - 2 * pad
|
||
x = pad + (inner_w - tw) // 2 - bbox[0]
|
||
y = pad + (inner_h - th) // 2 - bbox[1]
|
||
draw.text((x, y), ch, fill=255, font=font)
|
||
img = big.resize((w, h), Image.Resampling.LANCZOS)
|
||
pixels = [1 if img.getpixel((col, row)) > threshold else 0
|
||
for row in range(h) for col in range(w)]
|
||
if thicken:
|
||
pixels = _dilate(pixels, w, h, times=thicken)
|
||
return pixels, w, h
|
||
|
||
# --- small-size path: oversample → threshold → crop ink → fit cell ---
|
||
try:
|
||
ttf_path = font.path
|
||
except Exception:
|
||
ttf_path = None
|
||
scale = 8
|
||
pt = max(size + 2, int(size * 1.35)) * scale
|
||
font_big = ImageFont.truetype(ttf_path, pt) if ttf_path else font
|
||
canvas = Image.new("L", (w * scale * 2, h * scale * 2), 0)
|
||
draw = ImageDraw.Draw(canvas)
|
||
bbox = draw.textbbox((0, 0), ch, font=font_big)
|
||
margin = scale
|
||
draw.text((margin - bbox[0], margin - bbox[1]), ch, fill=255, font=font_big)
|
||
ink = canvas.point(lambda p: 255 if p > threshold else 0)
|
||
ib = ink.getbbox()
|
||
if ib is None:
|
||
return [0] * (w * h), w, h
|
||
cropped = ink.crop(ib)
|
||
cw, chh = cropped.size
|
||
pad = 1 if size >= 11 else 0
|
||
tw = max(1, w - 2 * pad)
|
||
th = max(1, h - 2 * pad)
|
||
fit = min(tw / cw, th / chh)
|
||
nw = max(1, int(round(cw * fit)))
|
||
nh = max(1, int(round(chh * fit)))
|
||
resized = cropped.resize((nw, nh), Image.Resampling.LANCZOS)
|
||
out = Image.new("L", (w, h), 0)
|
||
out.paste(resized, ((w - nw) // 2, (h - nh) // 2))
|
||
pixels = [1 if out.getpixel((col, row)) > 128 else 0
|
||
for row in range(h) for col in range(w)]
|
||
if thicken:
|
||
pixels = _dilate(pixels, w, h, times=thicken)
|
||
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):
|
||
# Small CJK: pack ink + lower threshold (Semibold preferred by caller)
|
||
pack = size <= 13
|
||
thr = 40 if pack else 90
|
||
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, threshold=thr, pack_ink=pack, thicken=0)
|
||
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}"
|
||
# Tiny ASCII (KEY/BPM/digits): Semibold + ink-pack; no dilate (avoids blob)
|
||
pack = size <= 13
|
||
thr = 40 if pack else 90
|
||
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, threshold=thr, pack_ink=pack, thicken=0)
|
||
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_chs9_table(text, tables):
|
||
if "CHS9Table" in tables:
|
||
return text, tables
|
||
src = "CHS11Table" if "CHS11Table" in tables else ("CHS12Table" if "CHS12Table" in tables else None)
|
||
if not src:
|
||
return text, tables
|
||
entries = tables[src]
|
||
block = "const char CHS9Table[][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["CHS9Table"] = 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)
|
||
|
||
only = None
|
||
for a in sys.argv[1:]:
|
||
if a.startswith("--only="):
|
||
only = {int(x) for x in a.split("=", 1)[1].split(",") if x.strip()}
|
||
|
||
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_chs9_table(text, tables)
|
||
text, tables = ensure_chs15_table(text, tables)
|
||
|
||
# Regenerate all Chinese font arrays
|
||
cn_sizes = [8, 9, 11, 12, 13, 15, 16, 24, 28]
|
||
if only:
|
||
cn_sizes = [s for s in cn_sizes if s in only]
|
||
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", 9: "CHS9Table", 11: "CHS11Table", 12: "CHS12Table",
|
||
13: "CHS13Table", 15: "CHS15Table", 16: "CHS16Table",
|
||
}[size]
|
||
# ≤13: Semibold + pack_ink inside generate_*; larger: Medium oversample
|
||
ttf = semibold if size <= 13 else medium
|
||
pt = max(8, size + 2) if size <= 13 else max(8, size + 2) * 4
|
||
font = ImageFont.truetype(ttf, pt)
|
||
|
||
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 == 9:
|
||
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：默认跳过，避免破坏已校准的数字字模；需要时传 --ascii
|
||
# --only= 仅过滤要生成的字号，仍须配合 --ascii 才会写英文头文件
|
||
if "--ascii" not in sys.argv:
|
||
print("Skip English fonts (pass --ascii to regenerate).")
|
||
print("Done.")
|
||
return
|
||
|
||
with open(ENG_HEADER_IN, "r", encoding="utf-8", errors="replace") as f:
|
||
eng = f.read()
|
||
|
||
# ≤13 ASCII: Semibold (thicker strokes survive 4×8 / 5×11 cells)
|
||
ascii_targets = [
|
||
(8, semibold, None), (9, semibold, None), (11, semibold, None), (12, semibold, None),
|
||
(13, semibold, "ascii_1306"), (15, medium, None), (16, medium, "ascii_1608"),
|
||
(24, medium, "ascii_2412"), (28, semibold, None),
|
||
]
|
||
if only:
|
||
ascii_targets = [t for t in ascii_targets if t[0] in only]
|
||
for size, ttf, legacy_name in ascii_targets:
|
||
font = ImageFont.truetype(ttf, max(8, size + 1) if size <= 13 else max(6, 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()
|