#!/usr/bin/env python3
"""Ling map: Ling programs as functional maps, and SVG files as Ling programs.
Ling -> SVG A .zip, a folder or single .ling files become one sheet in the Ling style.
Each file is a framed panel. Each function is a dial: the hub says what it is, the rings
read outward through its statements (ring 1), what they contain (ring 2) and what those
contain (ring 3), and the outer ring spells its name. Every cell takes one of the seven
colours by what the code does, and is hatched with that colour's signature family at a
density that says how much code it holds. Globals and types are tiles. Calls and imports
are connectors. The whole source travels inside the SVG, signed with ML-DSA-87.
SVG -> Ling A map made here gives its program back, byte for byte, after the signature is checked.
Any other SVG becomes a Ling program that redraws it with Ling's svg_* builtins.
python ling_map.py project.zip --out maps # Ling -> SVG, white and black
python ling_map.py map.svg --out restored # SVG -> Ling (the embedded program)
python ling_map.py drawing.svg --out drawn # SVG -> Ling (a program that redraws it)
"""
from __future__ import annotations
import argparse, base64, glob, hashlib, io, json, math, os, re, subprocess, unicodedata, zipfile
import xml.etree.ElementTree as ET
from dataclasses import dataclass, asdict, field, fields
from pathlib import Path
import cv2
import numpy as np
import ling_hatch as lh
import sizes
import ling_tiles as lt
from ling_hatch import KEYS, EMPTY, THEMES
HERE = Path(__file__).resolve().parent
ENTRY_NAMES = {'start', 'main', '启', 'เริ่ม', '시작', '始め', '始', 'начать', 'начало', 'inicio', 'comenzar', 'début',
'commencer', 'anfang', 'starten', 'início'}
SHAPE = {'asm': 'octagon', 'lit': 'cross', 'bind': 'circle', 'ctl': 'triangle', 'call': 'diamond', 'fn': 'hexagon', 'mod': 'square'}
DENSITY_TOKENS = [8, 24, 72] # a cell's hatch density says how many tokens it holds: up to 8, 24, 72, more
FORMAT = 'ling-map/1'
@dataclass
class MapOptions:
paper: str = 'a4' # a4 | a3 | a2 | auto (auto: as large as it needs for print-size lettering)
orientation: str = 'auto' # auto | portrait | landscape
margin_mm: float = 6.0
rings: int = 3 # how many levels of structure each dial shows
edges: bool = True # draw calls and imports as connectors
title: str = '' # title plate text; empty: the project name
dpi: int = 1440
line_mm: float = 0.123
spacing_mm: float = 0.28 # densest hatch spacing; the four densities are every 1st, 2nd, 3rd and 5th line
quality: str = 'standard'
key_phrase: str = '' # empty: fresh ML-DSA-87 key per run; set: the same program gives the same sheet
black_ground: bool = True
# =========================================================================== reading programs
def load_sources(paths) -> dict:
""".zip files, folders and .ling files -> {relative path: bytes}, sorted."""
out = {}
for p in [Path(p) for p in ([paths] if isinstance(paths, (str, Path)) else paths)]:
if p.is_dir():
for f in sorted(p.rglob('*.ling')): out[f.relative_to(p).as_posix()] = f.read_bytes()
elif p.suffix.lower() == '.zip':
with zipfile.ZipFile(p) as z:
for n in sorted(z.namelist()):
if n.lower().endswith('.ling') and not n.endswith('/') and '__MACOSX' not in n: out[n] = z.read(n)
else:
out[p.name] = p.read_bytes()
names = list(out)
if len(names) > 1: # drop a folder prefix every file shares
pre = os.path.commonprefix([n.rsplit('/', 1)[0] + '/' if '/' in n else '' for n in names])
if pre: out = {n[len(pre):]: b for n, b in out.items()}
return dict(sorted(out.items()))
_TABLE: dict = {}
def table() -> dict:
if not _TABLE:
_TABLE.update(json.loads((HERE / 'ling_keywords.json').read_text(encoding='utf-8')))
return _TABLE
_OPS = ['->', '=>', '==', '!=', '<=', '>=', '&&', '||', '..', '::', '+=', '-=', '*=', '/=', '<<']
def tokenize(src: str) -> list:
"""Ling's lexer rules: // and # comments, "strings" with escapes, numbers, words in any script, operators.
-> [(kind, value, start, end)] with kind in kw, id, num, str, bool, op."""
kwt = table()['keywords']; out = []; i = 0; n = len(src)
while i < n:
c = src[i]
if c in ' \t\r\n\x0c': i += 1; continue
if c == '#' or src.startswith('//', i):
j = src.find('\n', i); i = n if j < 0 else j; continue
if c == '"':
j = i + 1
while j < n and src[j] != '"': j += 2 if src[j] == '\\' else 1
out.append(('str', src[i + 1:j], i, min(j + 1, n))); i = min(j + 1, n); continue
if c.isdigit():
j = i; dot = False
while j < n and (src[j].isdigit() or (src[j] == '.' and not dot and j + 1 < n and src[j + 1].isdigit())):
dot = dot or src[j] == '.'; j += 1
out.append(('num', src[i:j], i, j)); i = j; continue
if c.isalnum() or c == '_' or unicodedata.category(c) in ('Mn', 'Mc'):
j = i
while j < n and (src[j].isalnum() or src[j] == '_' or unicodedata.category(src[j]) in ('Mn', 'Mc')): j += 1
w = src[i:j]; k = kwt.get(w)
if k in ('bool_true', 'bool_false') or w in ('true', 'false'): out.append(('bool', w, i, j))
elif k: out.append(('kw', k, i, j))
else: out.append(('id', w, i, j))
i = j; continue
op = next((o for o in _OPS if src.startswith(o, i)), c)
out.append(('op', op, i, i + len(op))); i += len(op)
return out
class Node:
"""One piece of program structure. cat is one of the seven keys."""
__slots__ = ('kind', 'cat', 'name', 's', 'e', 'kids', 'tokens', 'target', 'extra')
def __init__(self, kind, cat, name='', s=0, e=0, kids=None):
self.kind, self.cat, self.name, self.s, self.e = kind, cat, name, s, e
self.kids = kids or []; self.tokens = 1; self.target = None; self.extra = {}
def walk(self):
yield self
for k in self.kids: yield from k.walk()
class Parser:
"""A tolerant recursive-descent parser following Ling's own (src/parser/mod.rs). It keeps structure, not values:
statements, the blocks and calls inside them, and where literals sit."""
def __init__(self, src):
self.src = src; self.t = tokenize(src); self.i = 0; self.errors = []
# -- token helpers
def peek(self, k=0):
j = self.i + k
return self.t[j] if j < len(self.t) else ('eof', '', len(self.src), len(self.src))
def at(self, kind, val=None, k=0):
t = self.peek(k); return t[0] == kind and (val is None or t[1] == val)
def adv(self):
t = self.peek(); self.i += 1; return t
def expect(self, kind, val):
if not self.at(kind, val): raise SyntaxError('expected %s at %d, found %r' % (val, self.peek()[2], self.peek()[1]))
return self.adv()
def name(self):
t = self.adv()
if t[0] in ('id', 'kw'): return self.src[t[2]:t[3]]
raise SyntaxError('expected a name at %d' % t[2])
def node(self, kind, cat, name, i0, kids=None):
n = Node(kind, cat, name, self.t[i0][2] if i0 < len(self.t) else len(self.src), self.t[self.i - 1][3] if self.i else 0, kids)
n.tokens = max(1, self.i - i0); return n
# -- items
def program(self):
items = []
while not self.at('eof'):
i0 = self.i
try:
items.append(self.item())
except (SyntaxError, IndexError) as ex: # skip to the next top-level item and carry on
self.errors.append(str(ex)); self.i = max(self.i, i0 + 1); depth = 0
while not self.at('eof'):
if self.at('op', '{'): depth += 1
elif self.at('op', '}'): depth = max(0, depth - 1)
elif depth == 0 and self.at('kw') and self.peek()[1] in ('fn', 'bind', 'mod', 'use', 'form', 'choose', 'type'): break
self.i += 1
return items
def item(self):
i0 = self.i
if self.at('kw', 'async'): self.adv()
k = self.peek()
if k[0] == 'kw' and k[1] == 'bind':
self.adv(); name = self.name(); self.skip_type(); self.expect('op', '=')
block = self.at('kw', 'do') or self.at('op', '{') or self.at('op', '|') or self.at('op', '||')
parts, lits, simple = self.expr()
kind = 'entry' if block and name in ENTRY_NAMES else 'fn' if block else 'bind'
n = self.node(kind, 'mod' if kind == 'entry' else 'fn' if kind == 'fn' else 'bind', name, i0, parts)
n.extra['lits'] = lits; n.extra['value'] = self.src[self.t[i0 + 3][2]:n.e].strip() if kind == 'bind' and i0 + 3 < len(self.t) else ''
return n
if k[0] == 'kw' and k[1] == 'fn':
self.adv(); name = self.name(); self.skip_generics(); self.expect('op', '('); params = []
while not self.at('op', ')') and not self.at('eof'):
while self.at('op', '&') or (self.at('kw') and self.peek()[1] in ('own', 'lend')): self.adv()
params.append(self.name()); self.skip_type(stop=(',', ')'))
if self.at('op', ','): self.adv()
self.expect('op', ')')
while not (self.at('op') and self.peek()[1] in ('{', ';', '}')) and not self.at('eof'): self.adv() # return type, where clause
if self.at('op', '{'): self.adv(); body = self.block(); self.expect('op', '}')
else:
body = []
if self.at('op', ';'): self.adv()
n = self.node('entry' if name in ENTRY_NAMES else 'fn', 'mod' if name in ENTRY_NAMES else 'fn', name, i0, body)
n.extra['params'] = params; return n
if k[0] == 'kw' and k[1] == 'mod':
self.adv(); name = self.name(); self.skip_generics(); self.expect('op', '{'); kids = []
while not self.at('op', '}') and not self.at('eof'):
j0 = self.i
try:
kids.append(self.item())
except SyntaxError: # a field or other member: step over it
self.i = max(self.i, j0 + 1); depth = 0
while not self.at('eof') and not (depth == 0 and (self.at('op', '}') or (self.at('kw') and self.peek()[1] in ('fn', 'bind', 'mod')))):
if self.at('op') and self.peek()[1] in ('{', '(', '['): depth += 1
elif self.at('op') and self.peek()[1] in ('}', ')', ']'): depth -= 1
self.i += 1
self.expect('op', '}'); return self.node('mod', 'mod', name, i0, kids)
if k[0] == 'kw' and k[1] in ('type', 'form', 'choose'):
self.adv(); name = self.name(); self.skip_generics(); members = []
if self.at('op', '{'):
self.adv(); depth = 0
while not self.at('eof') and not (depth == 0 and self.at('op', '}')):
t = self.adv()
if t[1] in ('(', '{', '['): depth += 1
elif t[1] in (')', '}', ']'): depth -= 1
elif depth == 0 and t[0] in ('id', 'kw') and not self.at('op', '::'):
if not members or self.t[self.i - 2][1] in (',', ';', '{') or self.t[self.i - 2][0] != 'op': members.append(self.src[t[2]:t[3]])
self.expect('op', '}')
else:
while not self.at('eof') and not (self.at('kw') and self.peek()[1] in ('fn', 'bind', 'mod', 'use', 'form', 'choose', 'type')): self.adv()
n = self.node('type', 'bind', name, i0); n.extra['members'] = members; n.extra['form'] = k[1]; return n
if k[0] == 'kw' and k[1] == 'use':
self.adv(); t = self.adv(); path = t[1] if t[0] == 'str' else self.src[t[2]:t[3]]
if self.at('kw', 'as'): self.adv(); self.name()
return self.node('use', 'mod', path, i0)
# a bare statement at top level (scripts)
st = self.stmt()
st.extra['loose'] = True
return st
def skip_generics(self):
if self.at('op', '<'):
depth = 0
while not self.at('eof'):
t = self.adv()
if t[1] == '<': depth += 1
elif t[1] == '>':
depth -= 1
if depth <= 0: break
def skip_type(self, stop=('=',)):
if self.at('op', ':'):
depth = 0
while not self.at('eof'):
t = self.peek()
if depth == 0 and t[0] == 'op' and t[1] in stop: break
if t[1] in ('<', '(', '['): depth += 1
elif t[1] in ('>', ')', ']'):
if depth == 0: break
depth -= 1
self.adv()
# -- statements
def block(self):
out = []
while not self.at('op', '}') and not self.at('eof'):
i0 = self.i
try:
out.append(self.stmt())
except SyntaxError as ex:
self.errors.append(str(ex)); self.i = max(self.i, i0 + 1)
depth = 0
while not self.at('eof') and not (depth == 0 and (self.at('op', '}') or self.at('op', ';'))):
if self.at('op', '{'): depth += 1
elif self.at('op', '}'): depth -= 1
self.i += 1
if self.at('op', ';'): self.adv()
return out
def stmt(self):
i0 = self.i
if self.at('kw', 'bind'):
self.adv(); name = self.name(); self.skip_type(); self.expect('op', '=')
parts, lits, _ = self.expr()
return self.node('bind', 'bind', name, i0, self.with_lits(parts, lits, i0))
if self.at('kw', 'return') or self.at('kw', 'give'):
self.adv()
parts, lits = ([], 0) if self.at('op', ';') or self.at('op', '}') else self.expr()[:2]
return self.node('return', 'ctl', 'return', i0, self.with_lits(parts, lits, i0))
if self.at('kw') and self.peek()[1] in ('stop', 'again') and not self.at('op', '(', 1) and not self.at('op', '=', 1):
self.adv(); return self.node('jump', 'ctl', self.t[i0][1], i0)
parts, lits, simple = self.expr()
if simple and len(parts) == 1 and lits == 0:
return parts[0]
if not parts and lits:
return self.node('value', 'lit', '', i0)
if simple and len(parts) == 1:
parts[0].kids = self.with_lits(parts[0].kids, lits, i0); return parts[0]
return self.node('expr', 'fn', '', i0, self.with_lits(parts, lits, i0))
def with_lits(self, parts, lits, i0):
if lits:
n = Node('value', 'lit', '', self.t[i0][2], self.t[self.i - 1][3]); n.tokens = lits; return parts + [n]
return parts
# -- expressions: return (child nodes, literal count, is one simple node)
def expr(self):
i0 = self.i
parts, lits, simple = self.binary(0)
if self.at('op') and self.peek()[1] in ('=', '+=', '-=', '*=', '/='):
target = self.src[self.t[i0][2]:self.t[self.i - 1][3]]
self.adv(); p2, l2, _ = self.expr()
n = self.node('assign', 'bind', target[:40], i0, self.with_lits(parts + p2, lits + l2, i0))
return [n], 0, True
return parts, lits, simple
LEVELS = [('||',), ('&&',), ('==', '!=', '<', '>', '<=', '>='), ('+', '-', '^', '<<'), ('*', '/', '%')]
def binary(self, level):
if level == len(self.LEVELS): return self.unary()
parts, lits, simple = self.binary(level + 1)
while self.at('op') and self.peek()[1] in self.LEVELS[level]:
op = self.adv()[1]
if op == '>' and self.at('op', '>') and self.peek()[2] == self.t[self.i - 1][3]: self.adv() # >>
p2, l2, _ = self.binary(level + 1); parts, lits, simple = parts + p2, lits + l2, False
return parts, lits, simple
def unary(self):
if self.at('op') and self.peek()[1] in ('&', '!', '-'):
self.adv(); p, l, _ = self.postfix(); return p, l, False
if self.at('kw') and self.peek()[1] in ('wait', 'own', 'lend', 'share', 'move', 'copy') and not self.at('op', '(', 1):
self.adv(); return self.unary()
return self.postfix()
def postfix(self):
i0 = self.i
parts, lits, simple, name = self.primary()
while True:
if self.at('op', '.'):
self.adv(); m = self.name()
if self.at('op', '('):
self.adv(); a, al = self.args(); self.expect('op', ')')
n = self.node('call', 'call', m, i0, self.with_lits(parts + a, lits + al, i0)); n.extra['method'] = True
parts, lits, simple, name = [n], 0, True, None
else:
name = (name + '.' + m) if name else m
elif self.at('op', '::'):
self.adv(); seg = self.name(); name = (name + '::' + seg) if name else seg
elif self.at('op', '('):
self.adv(); a, al = self.args(); self.expect('op', ')')
n = self.node('call', 'call', name or '', i0, self.with_lits(parts + a, lits + al, i0))
parts, lits, simple, name = [n], 0, True, None
elif self.at('op', '['):
self.adv(); p2, l2, _ = self.expr(); self.expect('op', ']'); parts, lits, simple = parts + p2, lits + l2, False
elif self.at('op', '..'):
self.adv(); p2, l2, _, _n = self.primary(); parts, lits, simple = parts + p2, lits + l2, False
else:
break
return parts, lits, simple
def args(self):
parts, lits = [], 0
while not self.at('op', ')') and not self.at('eof'):
p, l, _ = self.expr(); parts += p; lits += l
if self.at('op', ','): self.adv()
return parts, lits
def primary(self):
"""-> (parts, lits, simple, name-if-identifier)"""
i0 = self.i; t = self.peek()
if t[0] in ('str', 'num', 'bool'): self.adv(); return [], 1, False, None
if t[0] == 'kw':
k = t[1]
if k == 'do' and self.at('op', '{', 1):
self.adv(); self.adv(); b = self.block(); self.expect('op', '}'); return b, 0, False, None
if k == 'if':
self.adv(); cp, cl, _ = self.binary(0); self.expect('op', '{'); then = self.block(); self.expect('op', '}')
kids = self.with_lits(cp, cl, i0) + then
while self.at('kw', 'else'):
j0 = self.i; self.adv()
if self.at('kw', 'if'):
self.adv(); cp, cl, _ = self.binary(0); self.expect('op', '{'); b = self.block(); self.expect('op', '}')
kids.append(self.node('if', 'ctl', 'else if', j0, self.with_lits(cp, cl, j0) + b))
else:
self.expect('op', '{'); b = self.block(); self.expect('op', '}')
kids.append(self.node('else', 'ctl', 'else', j0, b)); break
return [self.node('if', 'ctl', 'if', i0, kids)], 0, True, None
if k == 'while':
self.adv(); cp, cl, _ = self.expr(); self.expect('op', '{'); b = self.block(); self.expect('op', '}')
return [self.node('loop', 'ctl', 'while', i0, self.with_lits(cp, cl, i0) + b)], 0, True, None
if k == 'for':
self.adv(); var = self.name(); self.expect('kw', 'in'); ip, il, _ = self.postfix()
self.expect('op', '{'); b = self.block(); self.expect('op', '}')
return [self.node('loop', 'ctl', var, i0, self.with_lits(ip, il, i0) + b)], 0, True, None
if k == 'match':
self.adv(); sp, sl, _ = self.postfix(); self.expect('op', '{'); kids = self.with_lits(sp, sl, i0)
while not self.at('op', '}') and not self.at('eof'):
j0 = self.i
while not self.at('op', '=>') and not self.at('eof') and not self.at('op', '}'): self.adv() # pattern
self.expect('op', '=>'); p, l, _ = self.expr()
kids.append(self.node('arm', 'ctl', '', j0, self.with_lits(p, l, j0)))
if self.at('op', ','): self.adv()
self.expect('op', '}')
return [self.node('match', 'ctl', 'match', i0, kids)], 0, True, None
if k in ('return', 'give'):
self.adv()
p, l = ([], 0) if (self.at('op', ';') or self.at('op', '}') or self.at('eof')) else self.expr()[:2]
return [self.node('return', 'ctl', 'return', i0, self.with_lits(p, l, i0))], 0, True, None
if k == 'async': self.adv(); p, l, s_ = self.expr(); return p, l, s_, None
if k == 'asm':
self.adv()
if self.at('op', '!'): self.adv()
self.expect('op', '('); self.adv(); self.expect('op', ')')
return [self.node('asm', 'asm', 'asm', i0)], 0, True, None
self.adv(); return [], 0, False, self.src[t[2]:t[3]] # a keyword used as a name
if t[0] == 'id':
self.adv()
if self.at('str') and self.peek()[2] == t[3]: self.adv(); return [], 1, False, None # f"..."
return [], 0, False, t[1]
if t[0] == 'op':
if t[1] == '{': self.adv(); b = self.block(); self.expect('op', '}'); return b, 0, False, None
if t[1] == '[':
self.adv(); parts, lits = [], 0
while not self.at('op', ']') and not self.at('eof'):
p, l, _ = self.expr(); parts += p; lits += l
if self.at('op', ','): self.adv()
elif self.at('op', ';'): self.adv()
elif not self.at('op', ']'): raise SyntaxError('expected , or ] at %d' % self.peek()[2])
self.expect('op', ']'); return parts, lits, False, None
if t[1] in ('|', '||'):
self.adv()
if t[1] == '|':
while not self.at('op', '|') and not self.at('eof'): self.adv()
self.adv()
p, l, _ = self.expr()
return [self.node('lambda', 'fn', 'λ', i0, self.with_lits(p, l, i0))], 0, True, None
if t[1] == '(':
self.adv()
if self.at('op', ')'): self.adv(); return [], 0, False, None
parts, lits = [], 0
while True:
p, l, _ = self.expr(); parts += p; lits += l
if self.at('op', ','): self.adv(); continue
break
self.expect('op', ')'); return parts, lits, False, None
raise SyntaxError('unexpected %r at %d' % (t[1], t[2]))
def parse(src: str):
p = Parser(src); items = p.program(); return items, p.errors, len(p.t)
# =========================================================================== analysis
def _builtin_hue(name: str) -> str:
"""Colour of a builtin by what it does: hardware red, media orange, data yellow, timing green, I/O blue, maths indigo."""
t = table(); canon = t['builtins'].get(name, name); h = t['hue'].get(canon)
if h: return h
n = canon.lower()
if re.match(r'(a?(sin|cos|tan)h?2?|arc|sqrt|cbrt|exp|log|pow|abs|min|max|floor|ceil|round|neg|wrap|lerp|clamp|blake|sha|aes|argon|ed25519|x25519|base64|hash|vec|mat|dot|cross|norm)', n): return 'fn'
return ''
@dataclass
class Module:
path: str
name: str
fns: list = field(default_factory=list)
globals_: list = field(default_factory=list)
types: list = field(default_factory=list)
uses: list = field(default_factory=list)
errors: list = field(default_factory=list)
tokens: int = 0
def analyse(files: dict) -> dict:
"""-> project model: modules, the functions in them with their statement trees, the call graph and totals."""
mods = []; fn_index = {}
for path, raw in files.items():
try: src = raw.decode('utf-8')
except UnicodeDecodeError: src = raw.decode('utf-8', 'replace')
if path.replace('\\', '/').split('/')[0] == 'lexicons' or re.search(r'^\s*\[keywords\]', src, re.M):
continue # a lexicon table, not a program
items, errors, ntok = parse(src)
m = Module(path=path, name=Path(path).stem, errors=errors, tokens=ntok); loose = []
def take(items, prefix=''):
for it in items:
if it.kind in ('fn', 'entry'): it.extra['module'] = m; it.extra['qual'] = prefix + it.name; m.fns.append(it)
elif it.kind == 'bind': m.globals_.append(it)
elif it.kind == 'type': m.types.append(it)
elif it.kind == 'use': m.uses.append(it)
elif it.kind == 'mod': take(it.kids, prefix + it.name + '::')
else: loose.append(it)
take(items)
if loose: # top-level statements of a script act as its entry
n = Node('entry', 'mod', m.name, loose[0].s, loose[-1].e, loose); n.tokens = sum(k.tokens for k in loose)
n.extra.update(module=m, qual=m.name, script=True); m.fns.insert(0, n)
for f in m.fns: fn_index.setdefault(f.name, f)
mods.append(m)
# colour every call: a call to one of the project's own functions is a call (blue) and an edge; a builtin takes
# the colour of what it does; anything unknown stays a call
edges = {}
for m in mods:
for f in m.fns:
for n in f.walk():
if n.kind != 'call': continue
base = n.name.split('::')[-1].split('.')[-1]
tgt = fn_index.get(base)
if tgt is not None and not n.extra.get('method'):
n.target = tgt; n.cat = 'call'
if tgt is not f: edges[(id(f), id(tgt))] = (f, tgt, edges.get((id(f), id(tgt)), (0, 0, 0))[2] + 1)
else:
n.cat = _builtin_hue(base) or 'call'
by_stem = {}
for m in mods: by_stem.setdefault(m.name, m)
imports = []
for m in mods:
for u in m.uses:
t = by_stem.get(Path(u.name).stem)
if t is not None and t is not m: imports.append((m, t))
share = dict.fromkeys(KEYS, 0)
for m in mods:
for f in m.fns:
for n in f.walk(): share[n.cat] += 1 if n.kids else n.tokens
share['bind'] += sum(g.tokens for g in m.globals_) + sum(t.tokens for t in m.types); share['mod'] += len(m.uses) + 1
tot = max(1, sum(share.values()))
return {'modules': mods, 'edges': list(edges.values()), 'imports': imports, 'share': {k: v / tot for k, v in share.items()},
'counts': {'files': len(mods), 'functions': sum(len(m.fns) for m in mods), 'globals': sum(len(m.globals_) for m in mods),
'types': sum(len(m.types) for m in mods), 'calls': sum(e[2] for e in edges.values()),
'tokens': sum(m.tokens for m in mods), 'parse_errors': sum(len(m.errors) for m in mods)}}
# =========================================================================== lettering
_FONTS: dict = {'files': None, 'open': {}, 'char': {}}
_FONT_HINTS = ['NotoSansCJK-Regular', 'NotoSansSC', 'NotoSansJP', 'NotoSansKR', 'NotoSansThai', 'Loma.', 'DejaVuSans.ttf', 'NotoSans-Regular',
'NotoSansArabic', 'NotoSansHebrew', 'Arial Unicode', 'msyh', 'malgun', 'LeelawUI', 'tahoma', 'PingFang', 'AppleSDGothicNeo',
'Thonburi', 'segoeui', 'FreeSans.', 'unifont']
def _font_files():
if _FONTS['files'] is None:
dirs = ['/usr/share/fonts', '/usr/local/share/fonts', os.path.expanduser('~/.fonts'), os.path.expanduser('~/.local/share/fonts'),
'/System/Library/Fonts', '/Library/Fonts', os.path.expanduser('~/Library/Fonts'), 'C:/Windows/Fonts', str(HERE / 'fonts')]
found = []
for d in dirs:
if os.path.isdir(d):
for ext in ('ttf', 'otf', 'ttc'): found += glob.glob(os.path.join(d, '**', '*.' + ext), recursive=True)
rank = lambda f: next((i for i, h in enumerate(_FONT_HINTS) if h.lower() in os.path.basename(f).lower()), 999)
_FONTS['files'] = [f for f in sorted(found, key=rank) if rank(f) < 999]
return _FONTS['files']
def script_glyph(ch: str):
"""Outline of a character that Daemon and Chesilin do not have, from a system font. -> (contours y-down, advance,
units per em) or None. Marks that sit on a base letter (Thai vowels and tones) keep their offsets."""
if ch in _FONTS['char']: return _FONTS['char'][ch]
from fontTools.ttLib import TTFont, TTCollection
res = None
for f in _font_files():
if f not in _FONTS['open']:
try:
fonts = TTCollection(f, lazy=True).fonts if f.lower().endswith('.ttc') else [TTFont(f, lazy=True)]
if f.lower().endswith('.ttc'):
fonts = sorted(fonts, key=lambda t: 0 if ' SC' in (t['name'].getDebugName(1) or '') else 1)[:1]
_FONTS['open'][f] = [(t, t.getBestCmap() or {}, t.getGlyphSet(), t['head'].unitsPerEm) for t in fonts]
except Exception:
_FONTS['open'][f] = []
for t, cmap, gs, upm in _FONTS['open'][f]:
g = cmap.get(ord(ch))
if g is None: continue
pen = lt.RecordingPen(); gs[g].draw(pen); cs, cur = [], []; last = (0, 0)
for op, a in pen.value:
if op == 'moveTo': cur = [a[0]]; last = a[0]
elif op == 'lineTo': cur.append(a[0]); last = a[0]
elif op == 'qCurveTo':
pts = [last] + list(a)
if pts[-1] is None: pts = pts[:-1] + [pts[1]]
for i in range(1, len(pts) - 1):
p0 = pts[0] if i == 1 else ((pts[i - 1][0] + pts[i][0]) / 2, (pts[i - 1][1] + pts[i][1]) / 2)
p2 = pts[-1] if i == len(pts) - 2 else ((pts[i][0] + pts[i + 1][0]) / 2, (pts[i][1] + pts[i + 1][1]) / 2)
for q in (0.34, 0.67, 1.0):
cur.append(((1 - q) ** 2 * p0[0] + 2 * (1 - q) * q * pts[i][0] + q * q * p2[0],
(1 - q) ** 2 * p0[1] + 2 * (1 - q) * q * pts[i][1] + q * q * p2[1]))
last = pts[-1]
elif op == 'curveTo':
p0, (c1, c2, p3) = last, a
for q in (0.2, 0.4, 0.6, 0.8, 1.0):
cur.append(tuple((1 - q) ** 3 * p0[k] + 3 * (1 - q) ** 2 * q * c1[k] + 3 * (1 - q) * q * q * c2[k] + q ** 3 * p3[k] for k in (0, 1)))
last = p3
elif op in ('closePath', 'endPath'):
if len(cur) > 2: cs.append(np.array(cur, float) * [1, -1])
cur = []
res = (cs, gs[g].width, upm); break
if res: break
_FONTS['char'][ch] = res
return res
def clusters(text: str) -> list:
"""Split into letters with their combining marks, so a Thai vowel stays with its consonant."""
out = []
for ch in text:
if out and unicodedata.category(ch) in ('Mn', 'Mc', 'Me'): out[-1] += ch
else: out.append(ch)
return out
def cluster_outline(cl: str):
"""Contours of one cluster in its own bounding box (y down) -> (width, height, contours) or None."""
x = 0.0; cs = []
for ch in cl:
g = script_glyph(ch)
if g is None: return None
cont, adv, upm = g
cs += [c + [x, 0] for c in cont]; x += adv
if not cs: return None
allp = np.vstack(cs); mn = allp.min(0); mx = allp.max(0)
return float(mx[0] - mn[0]) or 1.0, float(mx[1] - mn[1]) or 1.0, [c - mn for c in cs]
def ring_glyph(ch: str):
"""What goes in one ring cell: Chesilin if it has the letter, else the letter's own script. -> (w, h, contours, face)"""
c = '.' if ch == '_' else ch
g = lt.ling_glyph('chesilin', c)
if g: return g[0], g[1], g[2], 'chesilin'
o = cluster_outline(ch)
return (o[0], o[1], o[2], 'script') if o else None
def daemon_ok(text: str) -> bool:
return all(c == ' ' or lt.ling_glyph('daemon', c) for c in text)
# =========================================================================== layout (design units, u)
HUB, BAND, NAME_BAND, BEZEL, GAP = 13.0, 14.0, 14.0, 4.0, 12.0
TILE = 16.0 # label tile, the screen floor of the design system
def tree_depth(n: Node, limit: int) -> int:
return 1 if (limit <= 1 or not n.kids) else 1 + max(tree_depth(k, limit - 1) for k in n.kids)
def dial_radius(f: Node, o: MapOptions) -> dict:
levels = max(1, min(o.rings, max((tree_depth(k, o.rings) for k in f.kids), default=1)))
hub = HUB + 1.6 * math.sqrt(len(f.kids))
need = (len(clusters(f.name)) + 1) * 9.5 / (2 * math.pi) + NAME_BAND / 2 # the name ring must hold the whole name
inner = max(hub + levels * BAND, need - NAME_BAND / 2)
band = (inner - hub) / levels
return {'hub': hub, 'levels': levels, 'band': band, 'name_r0': inner, 'R': inner + NAME_BAND + BEZEL}
def pack_circles(radii: list, aspect: float, gap: float = GAP) -> list:
"""Place circles one after another, each as near the centre as it fits. The first is the root. -> [(x, y)]
aspect: the shape of the box the cluster should fill (width / height); None: a round cluster about the root."""
pos = []
for i, r in enumerate(radii):
if not pos: pos.append((0.0, 0.0)); continue
P = np.array(pos); Rr = np.array(radii[:i]); C = np.zeros((0, 2))
nearest = np.argsort(np.hypot(P[:, 0] / (aspect or 1.0), P[:, 1]))[:40] if len(pos) > 40 else range(len(pos))
nearest_list = list(nearest)
for near in (nearest_list, list(range(len(pos)))): # the 40 nearest first; if every spot they offer is taken, all of them
cand = []
for a in near: # touching one placed circle
for k in range(24):
th = 2 * math.pi * k / 24; d = Rr[a] + r + gap
cand.append((P[a, 0] + d * math.cos(th), P[a, 1] + d * math.sin(th)))
for ia in range(len(near) if near is nearest_list else 0): # touching two placed circles (not on the retry: too many pairs)
for ib in range(ia + 1, len(near)):
a, b = near[ia], near[ib]
da, db = Rr[a] + r + gap, Rr[b] + r + gap; dx, dy = P[b] - P[a]; d = math.hypot(dx, dy)
if d == 0 or d > da + db or d < abs(da - db): continue
x = (da * da - db * db + d * d) / (2 * d); h2 = da * da - x * x
if h2 < 0: continue
h = math.sqrt(h2); ux, uy = dx / d, dy / d
cand.append((P[a, 0] + x * ux - h * uy, P[a, 1] + x * uy + h * ux))
cand.append((P[a, 0] + x * ux + h * uy, P[a, 1] + x * uy - h * ux))
C = np.array(cand).reshape(-1, 2)
C = C[(np.hypot(C[:, None, 0] - P[None, :, 0], C[:, None, 1] - P[None, :, 1]) >= (Rr[None, :] + r + gap - 1e-6)).all(1)]
if len(C) or len(near) == len(pos): break
if not len(C): # still nothing (a crowded or odd cluster): go round the outside of everything
d = (np.hypot(P[:, 0], P[:, 1]) + Rr).max() + r + gap
C = np.array([(d * math.cos(2 * math.pi * k / 72), d * math.sin(2 * math.pi * k / 72)) for k in range(72)])
bx0, bx1 = (P[:, 0] - Rr).min(), (P[:, 0] + Rr).max(); by0, by1 = (P[:, 1] - Rr).min(), (P[:, 1] + Rr).max()
w = np.maximum(bx1, C[:, 0] + r) - np.minimum(bx0, C[:, 0] - r); h = np.maximum(by1, C[:, 1] + r) - np.minimum(by0, C[:, 1] - r)
if aspect: score = np.maximum(w / aspect, h) + 0.02 * np.hypot(C[:, 0], C[:, 1]) # smallest box, then nearest the root
else: score = np.hypot(C[:, 0], C[:, 1]) + r # smallest circle about the root
pos.append(tuple(C[int(score.argmin())]))
return pos
def word_w(n: int, size: float = TILE) -> float:
return n * size + max(0, n - 1) * size * 0.14
def daemon_clean(text: str) -> str:
out = ''
for ch in text:
out += next((c for c in (ch, ch.upper(), ch.lower()) if c == ' ' or lt.ling_glyph('daemon', c)), '')
return out.strip()
def foot_spec(model: dict, o: MapOptions, project: str, nst: int = 4) -> dict:
"""Sizes of the foot of the sheet: legend with hatch swatches, share dial, digest, title plate. In a row on a
landscape sheet, stacked in two rows on a portrait one."""
S, M, G = TILE, 22.0, 16.0; c = model['counts']
title = daemon_clean((o.title or project)[:12]) or 'LING'; sub = '%d files %d fn' % (c['files'], c['functions']); rev = 'rev 2026.1'
ts = 30.0; plate_w = max(word_w(len(title), ts), word_w(len(sub), S), word_w(len(rev), S)) + 40; plate_h = ts + S + 8 + S + 14 + 40
rowA = 4 * S * 1.7 - S * 0.7 + 2 * M; rowB = max(4 * S + 3 * S * 0.14 + 2 * M, plate_h)
labw = S * 2.2 + word_w(4, S); leg_min = 2 * (labw + 12 + nst * 18) + 28 + 2 * M; grid_w = word_w(16, S) + 2 * M; key_h = S * 0.75 + 10
return {'title': title, 'sub': sub, 'rev': rev, 'ts': ts, 'plate_w': plate_w, 'plate_h': plate_h, 'rowA': rowA, 'rowB': rowB, 'labw': labw,
'grid_w': grid_w, 'key_h': key_h, 'G': G, 'M': M,
'row': {'F': leg_min + rowA + grid_w + plate_w + 3 * G, 'h': key_h + max(rowA, plate_h) + 24},
'stack': {'F': max(leg_min + G + rowA, grid_w + G + plate_w), 'h': key_h + rowA + G + rowB + 24}}
def layout(model: dict, o: MapOptions, project: str = 'project') -> dict:
"""-> every drawn thing with its place, in design units, and the sheet size that holds them."""
panels = []
for m in model['modules']:
fns = list(m.fns)
# the root first, then by distance along calls from it, then by size: the map reads outward from the root
entry = [f for f in fns if f.kind == 'entry']; rest = [f for f in fns if f.kind != 'entry']
calls = {}
for a, b, _n in model['edges']: calls.setdefault(id(a), []).append(b)
order, seen, queue = [], set(), list(entry) or rest[:1]
while queue:
f = queue.pop(0)
if id(f) in seen or f.extra.get('module') is not m: continue
seen.add(id(f)); order.append(f); queue += calls.get(id(f), [])
order += sorted([f for f in fns if id(f) not in seen], key=lambda f: -f.tokens)
dials = [dict(dial_radius(f, o), fn=f) for f in order]
ncell = sum(1 for _ in m.globals_) + len(m.types)
pos = pack_circles([d['R'] for d in dials], 1.25) if dials else []
for d, p in zip(dials, pos): d['x'], d['y'] = p
if dials:
x0 = min(d['x'] - d['R'] for d in dials); x1 = max(d['x'] + d['R'] for d in dials)
y0 = min(d['y'] - d['R'] for d in dials); y1 = max(d['y'] + d['R'] for d in dials)
else:
x0 = y0 = 0.0; x1 = y1 = 0.0
# globals and types: a table of tiles under the dials
rows = []
for g in m.globals_: rows.append(('bind', g, g.name, g.extra.get('value', '')))
for t in m.types: rows.append(('type', t, t.name, ' '.join(t.extra.get('members', [])[:4])))
label = lambda s, n: ''.join(clusters(s)[:n])
cells = [(kind, node, label(name, 14), label(re.sub(r'\s+', ' ', val), 10)) for kind, node, name, val in rows]
colw = max([TILE * 1.8 + word_w(len(clusters(a))) + (TILE * 0.9 + word_w(len(clusters(b))) if b else 0) for _, _, a, b in cells], default=0) + TILE * 1.5
width = max(x1 - x0, colw, word_w(len(clusters(m.name)) + 2) + 90, 220.0)
ncol = max(1, int(width // colw)) if cells else 1
nrow = math.ceil(len(cells) / ncol) if cells else 0
table_h = nrow * TILE * 1.6 + (TILE if cells else 0)
pad = 26.0
panels.append({'mod': m, 'dials': dials, 'cells': cells, 'ncol': ncol, 'colw': colw, 'x0': x0, 'y0': y0,
'w': width + 2 * pad, 'h': (y1 - y0) + table_h + 2 * pad + 6, 'pad': pad, 'dial_w': x1 - x0, 'dial_h': y1 - y0})
# panels on shelves, tried against the paper's shape; a small program is enlarged to the width the foot needs
foot = foot_spec(model, o, project); best = None
for land in ([False, True] if o.orientation == 'auto' else [o.orientation == 'landscape']):
asp = (297 / 210) if land else (210 / 297)
tot = sum(p['w'] * (p['h'] + 40) for p in panels) or 1.0
for grow in (1.0, 1.15, 1.35, 1.6, 2.0, 2.6):
mode = 'row' if land else 'stack'; F = foot[mode]['F']
Wt = max(max((p['w'] for p in panels), default=300), math.sqrt(tot * asp) * grow)
x = y = 0.0; shelf = 0.0; places = []
for p in sorted(panels, key=lambda p: -p['h']):
if x > 0 and x + p['w'] > Wt: x = 0.0; y += shelf + 44; shelf = 0.0
places.append((p, x, y)); x += p['w'] + 20; shelf = max(shelf, p['h'])
Wc = max((px + p['w'] - 20 * 0 for p, px, _ in places), default=Wt); Hp = y + shelf + 44
zoom = min(max(1.0, F / Wc), 3.0)
Wtot = max(Wc * zoom, F); Htot = Hp * zoom + foot[mode]['h']
K = min((297 if land else 210) / Wtot, (210 if land else 297) / Htot)
score = K * math.sqrt(zoom)
if best is None or score > best[0]: best = (score, land, places, Wc, Hp, zoom, Wtot, Htot, mode)
_, land, places, Wc, Hp, zoom, Wtot, Htot, mode = best
for p, px, py in places: p['x'], p['y'] = px, py + 30 # room for the title tab above each frame
return {'panels': panels, 'W': Wtot, 'H': Htot, 'landscape': land, 'zoom': zoom, 'map_w': Wc, 'map_h': Hp, 'foot': foot, 'mode': mode}
# =========================================================================== drawing
def _poly_d(pts, closed=True):
p = np.rint(np.asarray(pts)).astype(int); d = np.diff(p, axis=0)
return 'M%d %d' % (p[0, 0], p[0, 1]) + ''.join('l%d %d' % (a, b) for a, b in d if a or b) + ('z' if closed else '')
def _sector_pts(cx, cy, r0, r1, a0, a1):
n = max(2, int(math.ceil((a1 - a0) / math.radians(4))))
A = np.linspace(a0, a1, n + 1)
outer = [(cx + r1 * math.sin(a), cy - r1 * math.cos(a)) for a in A]
inner = [(cx + r0 * math.sin(a), cy - r0 * math.cos(a)) for a in A[::-1]]
return outer + inner
def density_step(tokens: int, nsteps: int) -> int:
s = sum(tokens > t for t in DENSITY_TOKENS)
return min(s, nsteps - 1)
class Sheet:
"""Collects what one sheet holds: exact outlines per colour, a label raster for the signature hatch, component
calls for the Ling bundle, and the per-node data that ties each drawn thing to its source."""
def __init__(self, W_u, H_u, pxu, geo, theme):
self.pxu, self.geo, self.theme = pxu, geo, theme; self.sc = geo['sc']
self.Wpx, self.Hpx = int(round(W_u * pxu)), int(round(H_u * pxu))
self.raster = np.full((self.Hpx // self.sc + 1, self.Wpx // self.sc + 1), EMPTY, np.uint8)
self.lines = {k: {} for k in list(KEYS) + ['ink']} # colour -> stroke width (px) -> [d]
self.k = pxu # pixels per unit for what is being drawn now
self.calls = {} # scale -> Ling bundle components, in design units
self.groups = [] # (attrs, colour, width, d): traceable pieces
self.nsteps = len(geo['mults'])
def px(self, v): return v * self.k
def add(self, color, d, width=None):
w = int(round(width if width is not None else self.geo['line']))
self.lines[color].setdefault(max(1, w), []).append(d)
def region(self, pts_px, hue, step):
"""A hatched region: fill its label on the raster, then clear a margin along its edge so the hatch stays
inside its own outline and never runs into a neighbour of the same colour."""
q = np.rint(np.asarray(pts_px) / self.sc).astype(np.int32)
cv2.fillPoly(self.raster, [q], int(KEYS.index(hue) * 4 + step))
cv2.polylines(self.raster, [q], True, int(EMPTY), max(2, int(round(self.geo['line'] * 2.2 / self.sc))))
def component(self, name, **opts):
self.calls.setdefault(self.k, []).append({'c': name, 'o': opts})
def ring_name(sh: Sheet, cx, cy, r0, r1, text, color):
"""A name set round a ring, one glyph per annular cell, repeated to fill the ring, with an empty cell between."""
band = r1 - r0; rm = (r0 + r1) / 2; unit = clusters(text) + [' ']
n = max(len(unit), int(2 * math.pi * rm / (sh.px(1) * 9.5) + 0.01))
reps = max(1, n // len(unit)); txt = unit * reps; m = len(txt); dth = 2 * math.pi / m
A = 2 * math.pi * rm / m; line = sh.geo['line']; dw = max(3, round(0.75 * line))
for i, cl in enumerate(txt):
a = i * dth
sh.add(color, 'M%d %dL%d %d' % (round(cx + r0 * math.sin(a)), round(cy - r0 * math.cos(a)),
round(cx + r1 * math.sin(a)), round(cy - r1 * math.cos(a))), dw)
if cl == ' ': continue
g = ring_glyph(cl)
if g is None: continue
w, h, polys, face = g; k = min(0.7 * A / w, 0.62 * band / h); th = (i + 0.5) * dth
tw = line if h * k >= 10 * line else max(4, round(0.7 * line))
for c in polys:
u = (c[:, 0] - w / 2) * k; v = (h / 2 - c[:, 1]) * k
if face == 'chesilin': # the ring face bends with its ring
pts = []
for j in range(len(c)):
pts += lt._polar(cx, cy, rm, th, (u[j], v[j]), (u[(j + 1) % len(c)], v[(j + 1) % len(c)]))
else: # other scripts keep their shape and only turn to face the ring
ct, st = math.cos(th), math.sin(th)
pts = [(cx + rm * st + uu * ct + vv * st, cy - rm * ct + uu * st - vv * ct) for uu, vv in zip(u, v)]
sh.add(color, _poly_d(pts), tw)
def script_label(sh: Sheet, text, x, y, size, color, align='left'):
"""A straight label in the text's own script, drawn in outline. (x, y) is the top-left of its line box."""
cls = clusters(text); outs = [cluster_outline(c) if c != ' ' else None for c in cls]
hs = [o[1] for o in outs if o]
if not hs: return 0.0
k = 0.72 * size / max(hs); adv = [(o[0] * k + size * 0.12) if o else size * 0.4 for o in outs]; total = sum(adv)
x0 = x - (total if align == 'right' else total / 2 if align == 'center' else 0)
for o, a in zip(outs, adv):
if o:
for c in o[2]:
sh.add(color, _poly_d(np.stack([x0 + c[:, 0] * k, y + (size - o[1] * k) / 2 + c[:, 1] * k], 1)), max(4, round(0.8 * sh.geo['line'])))
x0 += a
return total
def label(sh: Sheet, text, x_u, y_u, color, size=TILE, align='left'):
"""A label: Daemon tiles when Daemon has every letter, else the text's own script in outline. -> width in u"""
if not text: return 0.0
if daemon_ok(text):
sh.component('Word', text=text, x=x_u, y=y_u, size=size, color=color, align=align)
return word_w(len(text), size)
return script_label(sh, text, sh.px(x_u), sh.px(y_u), sh.px(size), color, align) / sh.k
def draw_dial(sh: Sheet, d: dict, ox, oy, o: MapOptions, path: str):
"""One function. Hub: its node shape (the root holds 灵). Rings outward: its statements, what they contain, and
so on. Outer ring: its name."""
f = d['fn']; cx, cy = sh.px(ox + d['x']), sh.px(oy + d['y']); R = sh.px(d['R']); hub = sh.px(d['hub']); band = sh.px(d['band'])
col = f.cat; line = sh.geo['line']
sh.add(col, lt._circle_d(round(cx), round(cy), round(R)), 2 * line) # bezel
sh.add(col, lt._circle_d(round(cx), round(cy), round(R - sh.px(BEZEL) * 0.75)))
r_in = sh.px(d['name_r0']); ring_name(sh, cx, cy, r_in, r_in + sh.px(NAME_BAND), f.name, col)
sh.add(col, lt._circle_d(round(cx), round(cy), round(r_in)))
sh.add(col, lt._circle_d(round(cx), round(cy), round(hub)))
if f.kind == 'entry':
g = json.loads((HERE / 'hub_glyph.json').read_text(encoding='utf-8')); s = 1.25 * hub
for c in g['contours']: sh.add('mod', _poly_d([(cx + x * s, cy + y * s) for x, y in c]), max(4, round(0.8 * line)))
else:
sh.add(col, lt._node(SHAPE[col], cx, cy, 0.6 * hub))
def cells(nodes, a0, a1, level):
if not nodes or level >= d['levels']: return
wts = [math.sqrt(n.tokens) for n in nodes]; tot = sum(wts); a = a0
r0 = hub + level * band; r1 = r0 + band
for n, wt in zip(nodes, wts):
b = a + (a1 - a0) * wt / tot
if (b - a) * r0 >= 2.2 * line:
pts = _sector_pts(cx, cy, r0, r1, a, b)
sh.region(pts, n.cat, density_step(n.tokens, sh.nsteps))
sh.groups.append(({'data-ling': '%s:%d-%d' % (path, n.s, n.e), 'data-kind': n.kind, 'data-name': n.name[:60]}, n.cat, line, _poly_d(pts)))
cells(n.kids, a, b, level + 1)
a = b
cells(f.kids, 0.0, 2 * math.pi, 0)
return cx, cy, R
def _clip_segment(p, q, circles, skip, rects=()):
"""Parts of the segment p-q outside every circle and rectangle (so a connector seems to pass behind them)."""
p, q = np.array(p, float), np.array(q, float); dq = q - p; L2 = float(dq @ dq)
if L2 == 0: return []
cuts = []
for x0, y0, x1, y1 in rects: # slab test
t0, t1 = 0.0, 1.0
for a, d, lo, hi in ((p[0], dq[0], x0, x1), (p[1], dq[1], y0, y1)):
if abs(d) < 1e-9:
if a < lo or a > hi: t0, t1 = 1.0, 0.0
else:
ta, tb = sorted(((lo - a) / d, (hi - a) / d)); t0, t1 = max(t0, ta), min(t1, tb)
if t1 > t0: cuts.append((t0, t1))
for i, (cx, cy, r) in enumerate(circles):
if i in skip: continue
f = p - (cx, cy); b = 2 * float(f @ dq); c = float(f @ f) - (r * 1.03) ** 2; disc = b * b - 4 * L2 * c
if disc <= 0: continue
s = math.sqrt(disc); t0, t1 = (-b - s) / (2 * L2), (-b + s) / (2 * L2)
if t1 > 0 and t0 < 1: cuts.append((max(0.0, t0), min(1.0, t1)))
cuts.sort(); out = []; t = 0.0
for a, b in cuts:
if a > t: out.append((p + dq * t, p + dq * a))
t = max(t, b)
if t < 1: out.append((p + dq * t, q))
return out
def render(files: dict, model: dict, lay: dict, o: MapOptions, theme: str, params: dict, bundle_meta: dict) -> str:
geo = lh.geometry(lh.Options(dpi=o.dpi, line_mm=o.line_mm, spacing_mm=o.spacing_mm, quality=o.quality)); u = geo['u']
geo['mults'] = [5, 3, 2, 1]; geo['cover'] = [1 - (1 - geo['line'] / (geo['base2'] * m)) ** 2 for m in geo['mults']] # cells are small: no very open hatch
paper = sizes.size_mm(o.paper, 'portrait') if (o.paper in sizes.PAPERS or o.paper in sizes.SCREENS) else None
if paper:
pw, ph = (max(paper), min(paper)) if lay['landscape'] else (min(paper), max(paper))
K = min((pw - 2 * o.margin_mm) / lay['W'], (ph - 2 * o.margin_mm) / lay['H'])
else: # as large as print-size lettering needs: 16u tile -> 5.85 mm
K = 5.85 / TILE; pw, ph = lay['W'] * K + 2 * o.margin_mm, lay['H'] * K + 2 * o.margin_mm
pxu = K * u; W_u, H_u = pw / K, ph / K
ox0, oy0 = (W_u - lay['W']) / 2, (H_u - lay['H']) / 2
sh = Sheet(W_u, H_u, pxu, geo, theme); th = THEMES[theme]; line = geo['line']
centre = {}; circles = []; rect_of = {}; Z = lay['zoom']; sh.k = pxu * Z
ox0, oy0 = (ox0 + (lay['W'] - lay['map_w'] * Z) / 2) / Z, oy0 / Z # the map's origin, in map units
# ---- panels
for p in lay['panels']:
m = p['mod']; x, y = ox0 + p['x'], oy0 + p['y']
title = m.name if daemon_ok(m.name) else ''
sh.component('Frame', x=x, y=y, w=p['w'], h=p['h'], color='mod', title=title[:22], titleSize=TILE, titleColor='mod')
if not title: script_label(sh, m.name, sh.px(x + 40), sh.px(y - TILE * 1.6), sh.px(TILE * 1.3), 'mod')
rect_of[id(m)] = (sh.px(x), sh.px(y), sh.px(x + p['w']), sh.px(y + p['h']))
dx, dy = x + p['pad'] + (p['w'] - 2 * p['pad'] - p['dial_w']) / 2 - p['x0'], y + p['pad'] - p['y0']
for d in p['dials']:
cx, cy, R = draw_dial(sh, d, dx, dy, o, m.path)
centre[id(d['fn'])] = len(circles); circles.append((cx, cy, R))
# the table of globals and types
ty = y + p['pad'] + p['dial_h'] + (TILE if p['dials'] else 0)
for i, (kind, node, name, val) in enumerate(p['cells']):
cxu = x + p['pad'] + (i % p['ncol']) * p['colw']; cyu = ty + (i // p['ncol']) * TILE * 1.6
sh.component('Node', kind='circle' if kind == 'bind' else 'square', x=cxu + TILE * 0.55, y=cyu + TILE / 2, r=TILE * 0.5,
color='bind', set='grid' if kind == 'type' else 'cross')
w = label(sh, name, cxu + TILE * 1.5, cyu, 'bind')
if val: label(sh, val, cxu + TILE * 1.5 + w + TILE * 0.7, cyu, 'lit' if kind == 'bind' else 'ink')
sh.groups.append(({'data-ling': '%s:%d-%d' % (m.path, node.s, node.e), 'data-kind': node.kind, 'data-name': node.name[:60]}, 'bind', line,
'M%d %dh%d' % (sh.px(cxu), sh.px(cyu + TILE * 1.25), sh.px(TILE * 1.1))))
# ---- connectors: calls between functions, imports between files
if o.edges:
for a, b, n in model['edges']:
if id(a) not in centre or id(b) not in centre: continue
ia, ib = centre[id(a)], centre[id(b)]; (ax, ay, ar), (bx, by, br) = circles[ia], circles[ib]
dx, dy = bx - ax, by - ay; dist = math.hypot(dx, dy)
if dist <= ar + br: continue
ux, uy = dx / dist, dy / dist; p0 = (ax + ux * ar, ay + uy * ar); p1 = (bx - ux * br, by - uy * br)
ma, mb = a.extra['module'], b.extra['module']
behind = [r for k, r in rect_of.items() if k not in (id(ma), id(mb))] # a call between files passes behind the other files
wpx = max(line, sh.px(1.5 if n > 1 else 0.9) / math.sqrt(Z))
for s0, s1 in _clip_segment(p0, p1, circles, {ia, ib}, behind):
sh.add('call', 'M%d %dL%d %d' % (round(s0[0]), round(s0[1]), round(s1[0]), round(s1[1])), wpx)
t = sh.px(3.0) / math.sqrt(Z); ex, ey = p1 # the call's diamond sits at the callee
sh.add('call', _poly_d([(ex, ey), (ex - ux * t - uy * t * 0.6, ey - uy * t + ux * t * 0.6), (ex - ux * 2 * t, ey - uy * 2 * t),
(ex - ux * t + uy * t * 0.6, ey - uy * t - ux * t * 0.6)]), max(line, sh.px(0.9) / math.sqrt(Z)))
for a, b in model['imports']: # an import joins two files across the gutter between them
ra, rb = rect_of[id(a)], rect_of[id(b)]
A = ((ra[0] + ra[2]) / 2, (ra[1] + ra[3]) / 2); B = ((rb[0] + rb[2]) / 2, (rb[1] + rb[3]) / 2)
for s0, s1 in _clip_segment(A, B, [], set(), list(rect_of.values())):
sh.add('mod', 'M%d %dL%d %d' % (round(s0[0]), round(s0[1]), round(s1[0]), round(s1[1])), sh.px(2.0))
for e in (s0, s1): sh.add('mod', _poly_d([(e[0] - sh.px(2.5), e[1] - sh.px(2.5)), (e[0] + sh.px(2.5), e[1] - sh.px(2.5)),
(e[0] + sh.px(2.5), e[1] + sh.px(2.5)), (e[0] - sh.px(2.5), e[1] + sh.px(2.5))]), sh.px(1.0))
# ---- foot: legend with each colour's hatch at its densities, the share dial, the digest, the title plate
sh.k = pxu; ox0, oy0 = (W_u - lay['W']) / 2, (H_u - lay['H']) / 2
ft = lay['foot']; mode = lay['mode']; S = TILE; M = ft['M']; G = ft['G']; FW = lay['W']; nst = len(geo['mults']); rowA = ft['rowA']
fx = ox0; fy = oy0 + lay['H'] - ft[mode]['h'] + 24
label(sh, 'tokens ' + ' '.join('%d' % t for t in DENSITY_TOKENS[:nst - 1]) + ' +', fx + M, fy, 'ink', S * 0.75) # what each density stands for
fy += ft['key_h']
if mode == 'row':
leg_w = FW - 3 * G - rowA - ft['grid_w'] - ft['plate_w']; dx_ = fx + leg_w + G; gx = dx_ + rowA + G; gy = fy; gw = ft['grid_w']; gh = rowA
px_, py_ = fx + FW - ft['plate_w'], fy + rowA - ft['plate_h']
else:
leg_w = FW - G - rowA; dx_ = fx + leg_w + G; gx = fx; gy = fy + rowA + G; gw = FW - G - ft['plate_w']; gh = ft['rowB']
px_, py_ = fx + FW - ft['plate_w'], gy + ft['rowB'] - ft['plate_h']
sh.component('Frame', x=fx, y=fy, w=leg_w, h=rowA, color='ink')
cols = [KEYS[:4], KEYS[4:]]; cw = (leg_w - 2 * M - 28) / 2; labw = ft['labw']
sw = max(10.0, min(34.0, (cw - labw - 12 - (nst - 1) * 4) / nst)); x_off = (cw - (labw + 12 + nst * (sw + 4) - 4)) / 2
for ci, keys in enumerate(cols):
cxu = fx + M + ci * (cw + 28) + x_off
sh.component('Legend', x=cxu, y=fy + M, size=S, keys=keys)
for r, k in enumerate(keys):
for s_i in range(nst):
x0, y0 = sh.px(cxu + labw + 12 + s_i * (sw + 4)), sh.px(fy + M + r * S * 1.7); w, h = sh.px(sw), sh.px(S)
pts = [(x0, y0), (x0 + w, y0), (x0 + w, y0 + h), (x0, y0 + h)]
sh.region(pts, k, s_i); sh.add(k, _poly_d(pts), max(line, sh.px(0.8)))
dcx, dcy = dx_ + rowA / 2, fy + rowA / 2; Rd = rowA / 2 - 14
sh.component('Frame', x=dx_, y=fy, w=rowA, h=rowA, color='ink')
ud = max(0.5, Rd / 150); rc = Rd - 9 * ud - 14 - 2.5; a = 0.0; rh = rc - 16 - 2.5
sh.component('Dial', cx=dcx, cy=dcy, r=Rd, diamonds=False, ticks=0, rings=[{'text': 'ml dsa 87 ', 'cells': 12, 'band': 14, 'color': 'ink'}],
hub={'color': 'mod', 'r': rh})
g = json.loads((HERE / 'hub_glyph.json').read_text(encoding='utf-8'))
for cc in g['contours']: sh.add('mod', _poly_d([(sh.px(dcx + x * rh * 1.25), sh.px(dcy + y * rh * 1.25)) for x, y in cc]), max(4, round(0.8 * line)))
for k in KEYS:
v = model['share'][k]
if v <= 0.004: continue
b = a + 2 * math.pi * v; pts = _sector_pts(sh.px(dcx), sh.px(dcy), sh.px(rc - 16), sh.px(rc), a, b)
sh.region(pts, k, max(0, nst - 2)); sh.add(k, _poly_d(pts)); a = b
sh.component('Frame', x=gx, y=gy, w=gw, h=gh, color='ink')
hexd = bundle_meta['sha3_256'].upper(); grid_h = 4 * S + 3 * S * 0.14
for q in range(4):
sh.component('Word', text=hexd[q * 16:q * 16 + 16], x=gx + (gw - word_w(16, S)) / 2, y=gy + (gh - grid_h) / 2 + q * S * 1.14, size=S, color='bind')
sh.component('TitlePlate', x=px_, y=py_, title=ft['title'], subtitle=ft['sub'], rev=ft['rev'], size=ft['ts'], small=S)
c = model['counts']
# ---- assemble
hatch, st = lh.hatch_picture(sh.raster, params, theme, geo)
hatch = re.sub(r'.*?', '', hatch, flags=re.S)
hatch = re.sub(r'id="(\w+?)(-hatch)?"', lambda mm: 'id="hatch-%s%s"' % (mm.group(1), mm.group(2) or ''), hatch)
comp = ''.join('%s' % (k, lh.LingJS.components(calls)) for k, calls in sh.calls.items())
comp = re.sub(r'class="lg lg-(\w+)"', lambda mm: 'stroke="%s"' % th.get(mm.group(1), th['ink']), comp)
body = ['%s' % (line, hatch)]
for k in list(KEYS) + ['ink']:
if sh.lines[k]:
body.append('%s' % (k, th[k], ''.join(
'' % (''.join(ds), w) for w, ds in sorted(sh.lines[k].items()))))
body.append('%s' % ''.join(
'' % (' '.join('%s="%s"' % (a, lh._esc(v).replace('"', '"')) for a, v in at.items()), th[col], w, d)
for at, col, w, d in sh.groups))
body.append('%s' % comp)
cap_mm = float(0.6 * TILE * K); pw, ph = float(pw), float(ph)
meta = dict(bundle_meta, sheet={'size_mm': [round(pw, 1), round(ph, 1)], 'ground': theme, 'user_units': 'device pixels at %d dpi' % o.dpi,
'label_cap_height_mm': round(cap_mm, 2), 'print_floor_mm': 3.5, 'labels_meet_print_floor': bool(cap_mm >= 3.5),
'density': 'hatch density = tokens in the cell: up to %s, then more' % ', '.join(map(str, DENSITY_TOKENS[:nst - 1])),
'counts': model['counts'], 'share': {k: round(v, 4) for k, v in model['share'].items()},
'hatch_runs': st.get('hatch_runs', 0), 'options': asdict(o) | {'key_phrase': bool(o.key_phrase)}})
mj = json.dumps(meta, ensure_ascii=True).replace('&', '&').replace('<', '<').replace('>', '>')
ground = '\n' % (sh.Wpx, sh.Hpx, th['ground']) if theme == 'black' and o.black_ground else ''
desc = ('A functional map of the Ling program %s: %d files, %d functions, %d globals, %d calls between functions. Each framed panel is a '
'file. Each dial is a function: its rings read outward through its statements and what they contain, coloured by what the code does '
'(red hardware, orange media and literals, yellow data, green control, blue calls and I/O, indigo computation, violet modules), '
'hatched more densely the more code a cell holds, with its name round the outside. Tiles list globals and types. Lines join callers '
'to the functions they call. The program itself is stored in this file.' % (
lh._esc(bundle_meta['project']), c['files'], c['functions'], c['globals'], c['calls']))
return ('\n\n' % (round(pw, 2), round(ph, 2), sh.Wpx, sh.Hpx, lh._esc(bundle_meta['project']), desc, mj, ground, '\n'.join(body)))
# =========================================================================== Ling -> SVG
def bundle(files: dict) -> bytes:
"""The exact bytes the signature covers: every file's path and content, length-prefixed, in path order."""
out = io.BytesIO(); out.write(FORMAT.encode() + b'\n')
for path, raw in sorted(files.items()):
p = path.encode('utf-8'); out.write(len(p).to_bytes(4, 'big') + p + len(raw).to_bytes(8, 'big') + raw)
return out.getvalue()
def source_meta(files: dict, params: dict, project: str = '') -> dict:
"""What an SVG stores so it can give its program back: the files, their digest, the public key and the signature."""
enc = []
for path, raw in sorted(files.items()):
try: enc.append({'path': path, 'text': raw.decode('utf-8')})
except UnicodeDecodeError: enc.append({'path': path, 'base64': base64.b64encode(raw).decode()})
return {'format': FORMAT, 'project': project or (Path(next(iter(files))).stem if len(files) == 1 else 'project'), 'files': enc,
'algorithm': params['algorithm'], 'key': params['key'], 'context': params['context'], 'sha3_256': params['sha3_256'],
'public_key': params['public_key'], 'signature': params['signature'], 'hues': params['hues'],
'signed': 'the bundle: "%s" newline, then for each file in path order: 4-byte path length, path, 8-byte length, bytes' % FORMAT}
def program_to_svg(files: dict, o: MapOptions = None, grounds=('white', 'black'), project: str = '', progress=None) -> dict:
"""{path: bytes} -> {ground: svg}. The same signature is used for every ground."""
o = o or MapOptions(); say = progress or (lambda m: None)
if not files: raise ValueError('No .ling files found.')
say('parsing'); model = analyse(files)
if not model['modules']: raise ValueError('No Ling programs found (only lexicon tables).')
say('signing'); msg = bundle(files); params = lh.sign(msg, lh.Options(key_phrase=o.key_phrase))
meta = source_meta(files, params, project)
say('laying out'); lay = layout(model, o, meta['project'])
out = {}
for g in grounds:
say('drawing on ' + g); out[g] = render(files, model, lay, o, g, params, meta)
return out
# =========================================================================== SVG -> Ling
def embedded_program(svg: str):
"""The program stored in a map, with its signature checked. -> ({path: bytes}, info) or None if the SVG holds none."""
try: root = ET.fromstring(svg.encode('utf-8'))
except ET.ParseError: return None
md = next((e for e in root.iter() if e.tag.endswith('metadata') and e.get('id') == 'ling-source'), None)
if md is None or not (md.text or '').strip(): return None
meta = json.loads(md.text)
if meta.get('format') != FORMAT: return None
files = {f['path']: (f['text'].encode('utf-8') if 'text' in f else base64.b64decode(f['base64'])) for f in meta['files']}
msg = bundle(files); ok = False; why = ''
try:
pk, sig, ctx = bytes.fromhex(meta['public_key']), bytes.fromhex(meta['signature']), meta['context'].encode()
try:
from cryptography.hazmat.primitives.asymmetric import mldsa
mldsa.MLDSA87PublicKey.from_public_bytes(pk).verify(sig, msg, ctx); ok = True
except ImportError:
from dilithium_py.ml_dsa import ML_DSA_87
ok = bool(ML_DSA_87.verify(pk, msg, sig, ctx=ctx))
except Exception as ex:
why = type(ex).__name__
return files, {'project': meta.get('project', 'project'), 'signature_valid': ok, 'why': why,
'sha3_256_matches': hashlib.sha3_256(msg).hexdigest() == meta.get('sha3_256')}
def sheet_info(svg: str) -> dict:
"""What a map says about its own sheet: size, lettering height against the print floor, counts."""
md = next(e for e in ET.fromstring(svg.encode('utf-8')).iter() if e.tag.endswith('metadata') and e.get('id') == 'ling-source')
return json.loads(md.text)['sheet']
_NUM = re.compile(r'[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?')
_CMD = re.compile(r'([MmLlHhVvCcSsQqTtAaZz])|([-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?)')
def _mat(tr: str):
"""An SVG transform attribute -> 3x3 matrix."""
M = np.eye(3)
for name, args in re.findall(r'(\w+)\s*\(([^)]*)\)', tr or ''):
v = [float(x) for x in _NUM.findall(args)]; T = np.eye(3)
if name == 'translate': T[0, 2] = v[0]; T[1, 2] = v[1] if len(v) > 1 else 0
elif name == 'scale': T[0, 0] = v[0]; T[1, 1] = v[1] if len(v) > 1 else v[0]
elif name == 'rotate':
a = math.radians(v[0]); c, s = math.cos(a), math.sin(a); T[:2, :2] = [[c, -s], [s, c]]
if len(v) == 3:
P = np.eye(3); P[0, 2], P[1, 2] = v[1], v[2]; Q = np.eye(3); Q[0, 2], Q[1, 2] = -v[1], -v[2]; T = P @ T @ Q
elif name == 'matrix' and len(v) == 6: T[0] = [v[0], v[2], v[4]]; T[1] = [v[1], v[3], v[5]]
elif name == 'skewX': T[0, 1] = math.tan(math.radians(v[0]))
elif name == 'skewY': T[1, 0] = math.tan(math.radians(v[0]))
M = M @ T
return M
def _arc_pts(p0, rx, ry, phi, large, sweep, p1, n=None):
"""Endpoint arc -> points (SVG implementation notes, F.6.5)."""
if rx == 0 or ry == 0: return [p1]
cp, sp = math.cos(phi), math.sin(phi); dx, dy = (p0[0] - p1[0]) / 2, (p0[1] - p1[1]) / 2
x1, y1 = cp * dx + sp * dy, -sp * dx + cp * dy; rx, ry = abs(rx), abs(ry)
lam = x1 * x1 / (rx * rx) + y1 * y1 / (ry * ry)
if lam > 1: rx *= math.sqrt(lam); ry *= math.sqrt(lam)
num = rx * rx * ry * ry - rx * rx * y1 * y1 - ry * ry * x1 * x1; den = rx * rx * y1 * y1 + ry * ry * x1 * x1
co = (-1 if large == sweep else 1) * math.sqrt(max(0, num / den)) if den else 0
cxp, cyp = co * rx * y1 / ry, -co * ry * x1 / rx
cx, cy = cp * cxp - sp * cyp + (p0[0] + p1[0]) / 2, sp * cxp + cp * cyp + (p0[1] + p1[1]) / 2
a0 = math.atan2((y1 - cyp) / ry, (x1 - cxp) / rx); a1 = math.atan2((-y1 - cyp) / ry, (-x1 - cxp) / rx); da = a1 - a0
if sweep and da < 0: da += 2 * math.pi
if not sweep and da > 0: da -= 2 * math.pi
n = n or max(6, int(abs(da) / math.radians(3)))
return [(cx + rx * math.cos(a0 + da * i / n) * cp - ry * math.sin(a0 + da * i / n) * sp,
cy + rx * math.cos(a0 + da * i / n) * sp + ry * math.sin(a0 + da * i / n) * cp) for i in range(1, n + 1)]
def path_polylines(d: str) -> list:
"""SVG path data -> [(points, closed)]. Curves are flattened."""
toks = [(m.group(1), m.group(2)) for m in _CMD.finditer(d)]; i = 0; out = []; pts = []; cur = (0.0, 0.0); start = cur; cmd = ''; lastc = None
def num():
nonlocal i
v = float(toks[i][1]); i += 1; return v
def flush(closed=False):
nonlocal pts
if len(pts) > 1: out.append((pts, closed))
pts = []
while i < len(toks):
if toks[i][0]: cmd = toks[i][0]; i += 1
elif not cmd: i += 1; continue
C = cmd.upper(); rel = cmd.islower() and C != 'Z'; bx, by = (cur if rel else (0.0, 0.0))
if C == 'Z':
if pts: pts.append(start); flush(True)
cur = start; lastc = None; cmd = ''; continue
try:
if C == 'M':
flush(); cur = (bx + num(), by + num()); start = cur; pts = [cur]; cmd = 'l' if rel else 'L'; lastc = None; continue
if not pts: pts = [cur]
if C == 'L': cur = (bx + num(), by + num()); pts.append(cur)
elif C == 'H': cur = ((cur[0] if rel else 0) + num(), cur[1]); pts.append(cur)
elif C == 'V': cur = (cur[0], (cur[1] if rel else 0) + num()); pts.append(cur)
elif C in ('C', 'S'):
if C == 'C': c1 = (bx + num(), by + num())
else: c1 = (2 * cur[0] - lastc[0], 2 * cur[1] - lastc[1]) if lastc and lastc[2] == 'C' else cur
c2 = (bx + num(), by + num()); p3 = (bx + num(), by + num()); p0 = cur
for q in np.linspace(0, 1, 25)[1:]:
pts.append(tuple((1 - q) ** 3 * p0[k] + 3 * (1 - q) ** 2 * q * c1[k] + 3 * (1 - q) * q * q * c2[k] + q ** 3 * p3[k] for k in (0, 1)))
cur = p3; lastc = (c2[0], c2[1], 'C'); continue
elif C in ('Q', 'T'):
if C == 'Q': c1 = (bx + num(), by + num())
else: c1 = (2 * cur[0] - lastc[0], 2 * cur[1] - lastc[1]) if lastc and lastc[2] == 'Q' else cur
p2 = (bx + num(), by + num()); p0 = cur
for q in np.linspace(0, 1, 17)[1:]:
pts.append(tuple((1 - q) ** 2 * p0[k] + 2 * (1 - q) * q * c1[k] + q * q * p2[k] for k in (0, 1)))
cur = p2; lastc = (c1[0], c1[1], 'Q'); continue
elif C == 'A':
rx, ry, rot, large, sweep = num(), num(), num(), num(), num(); p1 = (bx + num(), by + num())
pts += _arc_pts(cur, rx, ry, math.radians(rot), bool(large), bool(sweep), p1); cur = p1
lastc = None
except (IndexError, TypeError, ValueError):
break
flush()
return out
def flatten_svg(svg: str) -> dict:
"""Any SVG -> its line work: {'w', 'h', 'ground', 'shapes': [(kind, points, colour, width)], 'skipped': {...}}.
kind is line (a stroked polyline), fill (a filled outline), rect or circle (filled, axis-aligned)."""
root = ET.fromstring(svg.encode('utf-8')); tag = lambda e: e.tag.rsplit('}', 1)[-1]
vb = [float(x) for x in _NUM.findall(root.get('viewBox') or '')]
def length(v, default):
m = _NUM.match(v or '')
return float(m.group(0)) * {'mm': 96 / 25.4, 'cm': 960 / 25.4, 'in': 96, 'pt': 96 / 72}.get((v or '')[m.end():].strip(), 1) if m else default
if len(vb) != 4: vb = [0, 0, length(root.get('width'), 800), length(root.get('height'), 600)]
shapes = []; skipped = {}; ground = None
def style(e, inh):
st = dict(inh)
for k in ('stroke', 'fill', 'stroke-width'):
if e.get(k) is not None: st[k] = e.get(k)
for part in (e.get('style') or '').split(';'):
if ':' in part:
k, v = part.split(':', 1)
if k.strip() in ('stroke', 'fill', 'stroke-width', 'display'): st[k.strip()] = v.strip()
return st
def emit(subpaths, st, M, exact=None):
"""subpaths: [points]. A fill covers all of them together (so holes stay holes); each is stroked on its own."""
sc = math.sqrt(abs(np.linalg.det(M[:2, :2]))); stroke, fill = st.get('stroke', 'none'), st.get('fill', '#000000')
Ps = [(np.c_[np.array(p, float), np.ones(len(p))] @ M.T)[:, :2] for p in subpaths if len(p) > 1]
if not Ps: return
if fill not in ('none', 'transparent', '') and not fill.startswith('url') and any(len(P) > 2 for P in Ps):
upright = abs(M[0, 1]) < 1e-9 and abs(M[1, 0]) < 1e-9
if exact and exact[0] == 'rect' and upright: # Ling can fill these two exactly
shapes.append(('rect', np.array([Ps[0].min(0), Ps[0].max(0) - Ps[0].min(0)]), _hex(fill), 0.0))
elif exact and exact[0] == 'circle' and upright and abs(abs(M[0, 0]) - abs(M[1, 1])) < 1e-9:
shapes.append(('circle', np.array([(np.array([exact[1], exact[2], 1.0]) @ M.T)[:2], [exact[3] * sc, 0]]), _hex(fill), 0.0))
else: shapes.append(('fill', [P for P in Ps if len(P) > 2], _hex(fill), sc))
if stroke not in ('none', 'transparent', '') and not stroke.startswith('url'):
w = float((_NUM.findall(str(st.get('stroke-width', '1'))) or ['1'])[0]) * sc
for P in Ps: shapes.append(('line', P, _hex(stroke), w))
def walk(e, M, st):
nonlocal ground
t = tag(e)
if t in ('defs', 'metadata', 'title', 'desc', 'style', 'clipPath', 'mask', 'symbol', 'pattern', 'linearGradient', 'radialGradient', 'filter'): return
M = M @ _mat(e.get('transform')); st = style(e, st)
if st.get('display') == 'none': return
f = lambda k, dflt=0.0: float((_NUM.findall(e.get(k) or '') or [dflt])[0])
if t == 'path':
emit([pts for pts, closed in path_polylines(e.get('d') or '')], st, M)
elif t == 'rect':
x, y, w, h = f('x'), f('y'), f('width'), f('height')
if ground is None and not shapes and w >= vb[2] * 0.98 and h >= vb[3] * 0.98 and st.get('fill', 'none') not in ('none', ''):
ground = _hex(st['fill']); return
emit([[(x, y), (x + w, y), (x + w, y + h), (x, y + h), (x, y)]], st, M, ('rect',))
elif t in ('circle', 'ellipse'):
cx, cy = f('cx'), f('cy'); rx = f('r') if t == 'circle' else f('rx'); ry = f('r') if t == 'circle' else f('ry')
n = max(24, int(8 * math.sqrt(max(rx, ry)) + 16))
emit([[(cx + rx * math.cos(2 * math.pi * i / n), cy + ry * math.sin(2 * math.pi * i / n)) for i in range(n + 1)]], st, M,
('circle', cx, cy, rx) if rx == ry else None)
elif t == 'line': emit([[(f('x1'), f('y1')), (f('x2'), f('y2'))]], dict(st, fill='none'), M)
elif t in ('polyline', 'polygon'):
v = [float(x) for x in _NUM.findall(e.get('points') or '')]; pts = list(zip(v[0::2], v[1::2]))
if len(pts) > 1: emit([pts + (pts[:1] if t == 'polygon' else [])], st, M)
elif t in ('text', 'image', 'use', 'foreignObject'): skipped[t] = skipped.get(t, 0) + 1; return
for ch in e: walk(ch, M, st)
base = np.eye(3); base[0, 2], base[1, 2] = -vb[0], -vb[1]
walk(root, base, {})
return {'w': vb[2], 'h': vb[3], 'ground': ground, 'shapes': shapes, 'skipped': skipped}
_NAMED = {'black': '#000000', 'white': '#ffffff', 'red': '#ff0000', 'green': '#008000', 'blue': '#0000ff', 'yellow': '#ffff00', 'gray': '#808080',
'grey': '#808080', 'orange': '#ffa500', 'purple': '#800080', 'currentColor': '#000000'}
def _hex(c: str) -> str:
c = c.strip()
if c in _NAMED: return _NAMED[c]
if re.fullmatch(r'#[0-9a-fA-F]{3}', c): return '#' + ''.join(ch * 2 for ch in c[1:]).lower()
if re.fullmatch(r'#[0-9a-fA-F]{6}', c): return c.lower()
m = re.match(r'rgba?\(([^)]+)\)', c)
if m:
v = [float(x) for x in _NUM.findall(m.group(1))][:3]
return '#%02x%02x%02x' % tuple(int(round(min(255, max(0, x)))) for x in v)
return '#000000'
def svg_to_drawing_program(svg: str, name: str = 'drawing', size: float = 2000.0, per_fn: int = 400, fills: str = 'hatch') -> tuple:
"""Any SVG -> (Ling source, notes): a program that redraws the SVG with svg_begin, svg_line, svg_polyline,
svg_rect, svg_circle and svg_end. One function per colour and weight, in pieces small enough to read.
Ling can fill only rectangles and circles, so other filled shapes are drawn the Ling way: outlined, and
crosshatched in their colour (fills='hatch') or left open (fills='outline')."""
fl = flatten_svg(svg); k = size / max(fl['w'], fl['h']); W, H = fl['w'] * k, fl['h'] * k
layers = {}; nfill = 0; solids = []
for kind, P, col, w in fl['shapes']:
if kind in ('rect', 'circle'): solids.append((kind, P * k, col)); continue
if kind == 'fill':
nfill += 1; cs = [c * k for c in P]; hair = round(max(0.6, size / 1600), 1)
layers.setdefault((col, hair), []).extend(cs)
if fills == 'hatch':
for ang in (45, -45):
layers[(col, hair)] += [np.array(seg) for seg in lt._hatch_polys(cs, ang, size / 220)]
continue
layers.setdefault((col, round(max(0.1, w * k), 1)), []).append(P * k)
num = lambda v: ('%.2f' % v).rstrip('0').rstrip('.')
out = ['// %s.ling: redraws %s.svg with Ling\'s SVG builtins, as %s_redrawn.svg.' % (name, name, name),
'// Made by ling_map.py. %d strokes in %d layers, on a %s x %s canvas.' % (sum(len(v) for v in layers.values()), len(layers), num(W), num(H)), '']
calls = []
for part in range(0, len(solids), per_fn): # filled rectangles and circles first, in document order
fname = 'solids_%d' % (part // per_fn + 1); calls.append(fname); out.append('fn %s() {' % fname)
for kind, P, col in solids[part:part + per_fn]:
if kind == 'rect': out.append(' svg_rect(%s, %s, %s, %s, "%s")' % (num(P[0, 0]), num(P[0, 1]), num(P[1, 0]), num(P[1, 1]), col))
else: out.append(' svg_circle(%s, %s, %s, "%s")' % (num(P[0, 0]), num(P[0, 1]), num(P[1, 0]), col))
out += ['}', '']
for li, ((col, w), polys) in enumerate(sorted(layers.items(), key=lambda kv: -len(kv[1]))):
for part in range(0, len(polys), per_fn):
fname = 'layer_%d_%d' % (li + 1, part // per_fn + 1); calls.append(fname)
out.append('// %s, width %s' % (col, num(w))); out.append('fn %s() {' % fname)
for P in polys[part:part + per_fn]:
if len(P) > 3 and np.allclose(P[0], P[-1]): P = np.vstack([P, P[1]]) # closed: run on one step so the corner joins
if len(P) == 2: out.append(' svg_line(%s, %s, %s, %s, "%s", %s)' % (num(P[0, 0]), num(P[0, 1]), num(P[1, 0]), num(P[1, 1]), col, num(w)))
else: out.append(' svg_polyline("%s", "%s", %s)' % (' '.join('%s,%s' % (num(x), num(y)) for x, y in P), col, num(w)))
out.append('}'); out.append('')
out.append('bind start = do {')
out.append(' svg_begin("%s_redrawn.svg", %s, %s)' % (name, num(W), num(H)))
out.append(' svg_rect(0, 0, %s, %s, "%s")' % (num(W), num(H), fl['ground'] or '#ffffff'))
out += [' %s()' % c for c in calls]
out += [' svg_end()', '}', '']
notes = {'strokes': sum(len(v) for v in layers.values()), 'layers': len(layers), 'functions': len(calls), 'canvas': [round(W, 1), round(H, 1)], 'filled_rects_and_circles': len(solids),
'filled_shapes_hatched' if fills == 'hatch' else 'filled_shapes_outlined': nfill, 'skipped_elements': fl['skipped']}
return '\n'.join(out), notes
def svg_to_ling(svg: str, name: str = 'drawing', mode: str = 'auto') -> tuple:
"""-> ({path: bytes}, info). mode auto: the stored program if the SVG is a map made here, else a drawing program.
mode draw: always a drawing program. mode source: only the stored program."""
if mode in ('auto', 'source'):
emb = embedded_program(svg)
if emb: return emb[0], dict(emb[1], kind='stored program')
if mode == 'source': raise ValueError('This SVG does not carry a Ling program.')
src, notes = svg_to_drawing_program(svg, name)
return {name + '.ling': src.encode('utf-8')}, dict(notes, kind='drawing program')
# =========================================================================== command line
def write_outputs(files: dict, out_dir, stem: str) -> list:
out_dir = Path(out_dir); out_dir.mkdir(parents=True, exist_ok=True); made = []
for path, raw in files.items():
f = out_dir / stem / path if len(files) > 1 else out_dir / path
f.parent.mkdir(parents=True, exist_ok=True); f.write_bytes(raw); made.append(str(f))
if len(files) > 1:
z = out_dir / (stem + '.zip')
with zipfile.ZipFile(z, 'w', zipfile.ZIP_DEFLATED) as zf:
for path, raw in files.items(): zf.writestr(path, raw)
made.append(str(z))
return made
def main():
ap = argparse.ArgumentParser(description=__doc__.split('\n\n')[0], formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument('inputs', nargs='+', help='.ling files, a .zip or a folder (Ling -> SVG), or .svg files (SVG -> Ling)')
ap.add_argument('--out', default='ling_map_out'); ap.add_argument('--project', default='')
ap.add_argument('--grounds', nargs='+', default=['white', 'black'], choices=['white', 'black'])
ap.add_argument('--mode', default='auto', choices=['auto', 'draw', 'source'], help='SVG -> Ling: stored program, or a drawing program')
ap.add_argument('--png-scale', type=float, default=0.0)
for f in fields(MapOptions):
kind = {'int': int, 'float': float, 'bool': lambda v: v.lower() in ('1', 'true', 'yes')}.get(f.type, str)
ap.add_argument('--' + f.name.replace('_', '-'), type=kind, default=f.default)
a = ap.parse_args(); out = Path(a.out); out.mkdir(parents=True, exist_ok=True)
svgs = [p for p in a.inputs if p.lower().endswith('.svg')]; rest = [p for p in a.inputs if not p.lower().endswith('.svg')]
for p in svgs:
files, info = svg_to_ling(Path(p).read_text(encoding='utf-8'), Path(p).stem, a.mode)
made = write_outputs(files, out, Path(p).stem)
print('%s -> %s (%s)' % (p, ', '.join(made[-2:]), {k: v for k, v in info.items() if k != 'why'}))
if rest:
o = MapOptions(**{f.name: getattr(a, f.name) for f in fields(MapOptions)}); files = load_sources(rest)
project = a.project or (Path(rest[0]).stem if len(rest) == 1 else 'project')
for g, svg in program_to_svg(files, o, a.grounds, project, lambda m: print(m, flush=True)).items():
f = out / ('%s_map_%s.svg' % (project, g)); f.write_text(svg, encoding='utf-8'); print(f)
if a.png_scale > 0: lt.write_png(svg, f.with_suffix('.png'), g, a.png_scale)
if __name__ == '__main__':
main()