#!/usr/bin/env python3
"""Generate the LED-nameplate routing visualiser HTML.
Uses the SAME `dijkstra_alg` module as `generate_nameplate.py`, so the
images here are exactly what would appear on the PCB.
Two ways to view:
* Static file (all 36 glyphs precomputed + embedded):
python3 route_visualizer.py [output.html]
* Live server (adds the interactive Custom-Shape editor, which routes
arbitrary 5x9 selections on demand via the shared Python router):
python3 route_server.py
"""
import json
import os
import sys
# Allow `python3 route_visualizer.py` from any CWD
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, SCRIPT_DIR)
PROJECT_DIR = os.path.dirname(SCRIPT_DIR)
import dijkstra_alg as da
import generate_nameplate as gn # shared GND-keepout extraction
FONT_PATH = gn.FONT_PATH # shared resolver (dev tree OR bundled-alongside)
DEFAULT_OUTPUT = os.path.join(SCRIPT_DIR, "route_visualizer.html")
_TEMPLATE_PCB = None
def _template_pcb():
"""Lazily load the blank-letter template PCB (for GND-keepout)."""
global _TEMPLATE_PCB
if _TEMPLATE_PCB is None:
import zipfile
with zipfile.ZipFile(gn.TEMPLATE_ZIP) as zf:
_TEMPLATE_PCB = zf.read(
'blank-letter-template/blank-letter-template.kicad_pcb').decode()
return _TEMPLATE_PCB
def _gnd_keepout(surviving):
"""Same GND-copper keepout the PCB generator uses, so visualiser routes
match the board exactly."""
vias, segs = gn.kept_gnd_geometry(_template_pcb(), surviving)
return da.gnd_keepout_nodes(vias, segs)
def load_font():
with open(FONT_PATH) as f:
return json.load(f)
# ---------------------------------------------------------------------------
# Computation (shared by static glyphs and the live /api/route endpoint)
# ---------------------------------------------------------------------------
def _geometry(surviving):
"""Variant-independent scene geometry: bounds, grid nodes, LED placement,
cap centres. Bounds are the full 5x9 tile (fixed), so every shape shares
the same canvas."""
x0, x1, y0, y1 = da.grid_bounds()
grid_nodes = []
yy = y0
while yy <= y1 + 1e-6:
xx = x0
while xx <= x1 + 1e-6:
grid_nodes.append([round(xx, 3), round(yy, 3)])
xx += da.ROUTING_UNIT
yy += da.ROUTING_UNIT
caps = []
leds = []
for (r, c) in sorted(surviving):
cx, cy = da.grid_pos(r, c)
caps.append([round(cx + da.CAP_OFFSET[0], 3), round(cy + da.CAP_OFFSET[1], 3)])
din_x, din_y = da.corner_for(r, c, 'DIN')
dout_x, dout_y = da.corner_for(r, c, 'DOUT')
leds.append({
'r': r, 'c': c,
'x': round(cx, 3), 'y': round(cy, 3),
'rot': da.get_led_rotation(r),
'din': [round(din_x, 3), round(din_y, 3)],
'dout': [round(dout_x, 3), round(dout_y, 3)],
})
return {
'bounds': [round(v, 3) for v in (x0, y0, x1, y1)],
'grid_nodes': grid_nodes,
'leds': leds,
'caps': caps,
'survivor_count': len(surviving),
}
def _variant(surviving, inverted):
"""Routing result for one chain-order variant: chain indices, routes,
final blocked set."""
results, final_blocked = da.route_chain(
surviving, inverted=inverted, extra_blocked=_gnd_keepout(surviving))
surv_chain = [(r, c) for (r, c) in da.chain_order(inverted=inverted)
if (r, c) in surviving]
chain_idx = {f'{r},{c}': i for i, (r, c) in enumerate(surv_chain)}
routes = []
for res in results:
if res['path'] is None:
routes.append({'i': res['i'], 'path': None,
'src': list(res['src']), 'dst': list(res['dst'])})
continue
waypoints = da.consolidate(res['path'])
routes.append({
'i': res['i'],
'src': [round(res['src'][0], 3), round(res['src'][1], 3)],
'dst': [round(res['dst'][0], 3), round(res['dst'][1], 3)],
'path': [[round(x, 3), round(y, 3)] for (x, y) in waypoints],
})
return {
'chain_idx': chain_idx,
'routes': routes,
'blocked': [[round(x, 3), round(y, 3)] for (x, y) in sorted(final_blocked)],
'chain_count': len(surv_chain),
}
def compute_shape(surviving, inverted=False):
"""Flat single-variant scene for the live API (custom editor)."""
geo = _geometry(surviving)
v = _variant(surviving, inverted)
geo.update(routes=v['routes'], blocked=v['blocked'],
chain_idx=v['chain_idx'], chain_count=v['chain_count'])
return geo
def compute_letter_data(bitmap):
"""Both NORMAL and INVERTED variants for one embedded glyph (shared
geometry + per-variant routes/blocked/chain_idx)."""
surviving = set()
for r in range(da.GRID_ROWS):
for c in range(da.GRID_COLS):
if bitmap[r][c]:
surviving.add((r, c))
data = _geometry(surviving)
data['normal'] = _variant(surviving, inverted=False)
data['inverted'] = _variant(surviving, inverted=True)
return data
def build_meta():
"""Geometry constants the renderer needs to draw realistic footprints +
keepout zones, pulled straight from dijkstra_alg so they never drift."""
return {
'grid_cols': da.GRID_COLS,
'grid_rows': da.GRID_ROWS,
'led_pitch': da.LED_PITCH,
'routing_unit': da.ROUTING_UNIT,
'led_body_half': da.LED_BODY_HALF,
'pad_half': [da.PAD_HALF_X, da.PAD_HALF_Y],
'pad_margin': da.PAD_MARGIN,
'pad_clearance': da.PAD_CLEARANCE,
'pad_local': {k: list(v) for k, v in da.PAD_LOCAL.items()},
'cap_offset': list(da.CAP_OFFSET),
'cap_half': [da.CAP_HALF_X, da.CAP_HALF_Y],
'din_offset': list(da.DIN_OFFSET),
'dout_offset': list(da.DOUT_OFFSET),
}
def build_html(letters_data, glyph_order):
payload = {
'meta': build_meta(),
'glyph_order': glyph_order,
'letters': letters_data,
}
payload_json = json.dumps(payload, separators=(',', ':'))
return _HTML_TEMPLATE.replace('__PAYLOAD__', payload_json)
def build_all_glyphs():
"""(glyph_order, letters_data) for A-Z, 0-9 with at least one lit cell."""
font = load_font()
candidates = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
glyph_order, letters_data = [], {}
for g in candidates:
if g not in font:
continue
bitmap = font[g]
if not any(any(row) for row in bitmap):
continue
glyph_order.append(g)
letters_data[g] = compute_letter_data(bitmap)
return glyph_order, letters_data
def render_full_html():
glyph_order, letters_data = build_all_glyphs()
return build_html(letters_data, glyph_order)
_HTML_TEMPLATE = r"""
LED Nameplate Routing Visualiser
LED Nameplate Routing Visualiser
Same Dijkstra router as generate_nameplate.py (shared
dijkstra_alg.py). Pick a glyph, or switch to Custom Shape to
draw any 5×9 pattern and route it live.
Glyph
Draw shape(click / drag cells)
PadDINDOUTKeepoutCapTrace
"""
def main():
output = sys.argv[1] if len(sys.argv) > 1 else DEFAULT_OUTPUT
glyph_order, letters_data = build_all_glyphs()
html = build_html(letters_data, glyph_order)
with open(output, 'w') as f:
f.write(html)
print(f"Wrote {output}")
print(f" Glyphs: {len(glyph_order)}")
for variant in ('normal', 'inverted'):
total = sum(len(d[variant]['routes']) for d in letters_data.values())
failed = sum(sum(1 for r in d[variant]['routes'] if not r['path'])
for d in letters_data.values())
print(f" [{variant}] {total} chain links, {failed} unrouted")
if __name__ == "__main__":
main()