path: root/scripts/extract-wordmark.py

#!/usr/bin/env python3
"""Generate src/wordmark.h from an outgoing invoice PDF.

The invoice header draws "MAKANDRA AB" and "FAKTURA" in Comfortaa Bold
(SIL OFL 1.1), white on the #314c59 bar.  This script extracts the two
words as filled vector paths so the PDF code can draw them without
embedding a font or depending on one at runtime.  It is stdlib only and
shells out to poppler for the SVG conversion:

    pdftocairo -svg -f 1 -l 1 7.pdf /tmp/7.svg
    scripts/extract-wordmark.py /path/to/7.pdf

The source invoices are real customer documents and are not distributed
with the repository; only the two wordmark words are extracted.  The
generated header stores each word as one path in PDF user space (y up),
normalized to the left baseline, plus its width and height in points.

Usage: extract-wordmark.py [--check] [--out FILE] PDF
"""

import argparse
import hashlib
import os
import re
import shutil
import subprocess
import sys
import tempfile

BAR_COLOR = "rgb(19.215393%, 29.803467%, 34.901428%)"
WHITE_FILL = "rgb(100%, 100%, 100%)"
HEADER_BAND_Y = 90.0
NUMBER = r"[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?"
TOKEN = re.compile(r"([MLCZmlcz])|(" + NUMBER + r")")
VALUE = re.compile(NUMBER)
FILL_RE = re.compile(re.escape(WHITE_FILL) + r'"[^>]*>(.*?)</g>', re.S)
GLYPH_RE = re.compile(r'<g id="(glyph-[^"]+)">(.*?)</g>', re.S)
PATH_RE = re.compile(r'<path d="([^"]*)"')
USE_RE = re.compile(
    r'<use xlink:href="#(glyph-[^"]+)" x="(' + NUMBER + r')" y="(' + NUMBER + r')"'
)
BAR_RE = re.compile(re.escape(BAR_COLOR) + r'"[^>]*\bd="([^"]*)"')
REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DEFAULT_OUT = os.path.join(REPO_ROOT, "src", "wordmark.h")

WORDS = ("MAKANDRA", "FAKTURA")


def render_svg(pdf):
    """Run pdftocairo on page 1 and return the SVG text."""
    if shutil.which("pdftocairo") is None:
        sys.exit("extract-wordmark: pdftocairo not found in PATH")
    with tempfile.TemporaryDirectory() as tmp:
        out = os.path.join(tmp, "page.svg")
        subprocess.run(
            ["pdftocairo", "-svg", "-f", "1", "-l", "1", pdf, out],
            check=True,
        )
        with open(out, encoding="utf-8") as fh:
            return fh.read()


def parse_glyphs(svg):
    """Map glyph id -> path data (empty for blank glyphs such as space)."""
    glyphs = {}
    for match in GLYPH_RE.finditer(svg):
        path = PATH_RE.search(match.group(2))
        glyphs[match.group(1)] = path.group(1) if path else ""
    if not glyphs:
        sys.exit("extract-wordmark: no glyph definitions in SVG")
    return glyphs


def header_words(svg, page_height):
    """Return the two white word groups inside the dark header bar.

    Each group is a list of (glyph id, x, y) placements in document order,
    leftmost word first.
    """
    groups = []
    for match in FILL_RE.finditer(svg):
        uses = [
            (ref, float(x), float(y))
            for ref, x, y in USE_RE.findall(match.group(1))
        ]
        if uses and max(y for _, _, y in uses) < HEADER_BAND_Y:
            groups.append(uses)
    groups.sort(key=lambda uses: uses[0][1])
    if len(groups) != 2:
        sys.exit(
            "extract-wordmark: expected 2 white header groups, found %d" % len(groups)
        )
    return groups


def bar_bbox(svg):
    """Bounding box of the #314c59 header bar path."""
    match = BAR_RE.search(svg)
    if not match:
        sys.exit("extract-wordmark: header bar colour not found in SVG")
    nums = [float(v) for v in VALUE.findall(match.group(1))]
    xs, ys = nums[0::2], nums[1::2]
    return min(xs), min(ys), max(xs), max(ys)


def transform_path(data, dx, dy, page_height):
    """Clone glyph path data, offset it, and flip y into PDF user space.

    Returns a list of (operator, [(x, y), ...]) segments with absolute
    coordinates; only the absolute M/L/C/Z operators are accepted.
    """
    tokens = [
        (op, None if op else float(num))
        for op, num in TOKEN.findall(data)
    ]
    segments = []
    i = 0
    while i < len(tokens):
        op = tokens[i][0]
        i += 1
        if op == "Z":
            segments.append(("Z", []))
            continue
        pairs = {"M": 1, "L": 1, "C": 3}.get(op)
        if pairs is None:
            sys.exit("extract-wordmark: unsupported path operator %r" % op)
        points = []
        for _ in range(pairs):
            if i + 1 >= len(tokens):
                sys.exit("extract-wordmark: truncated path data")
            x, y = tokens[i][1], tokens[i + 1][1]
            i += 2
            points.append((dx + x, page_height - (dy + y)))
        segments.append((op, points))
    return segments


def fmt(value):
    """Format a coordinate with at most 3 decimals, without trailing zeros."""
    if abs(value) < 0.0005:
        value = 0.0
    text = "%.3f" % value
    text = text.rstrip("0").rstrip(".")
    return text if text not in ("", "-0") else "0"


def compose_word(uses, glyphs, page_height):
    """Compose one word into a single normalized path string.

    The word's origin becomes the left edge of its ink on the baseline.
    Returns (path, width, height, svg bbox, placements, unique glyphs).
    """
    baseline = page_height - uses[0][2]
    segments = []
    for ref, x, y in uses:
        if ref not in glyphs:
            sys.exit("extract-wordmark: missing glyph %s" % ref)
        segments.extend(transform_path(glyphs[ref], x, y, page_height))

    points = [point for _, points in segments for point in points]
    if not points:
        sys.exit("extract-wordmark: word has no outline points")
    min_x = min(point[0] for point in points)
    max_x = max(point[0] for point in points)
    min_y = min(point[1] for point in points)
    max_y = max(point[1] for point in points)
    svg_bbox = (min_x, max_x, page_height - max_y, page_height - min_y)

    parts = []
    out_min = [None, None]
    out_max = [None, None]
    for op, points in segments:
        if op == "Z":
            parts.append("Z")
            continue
        coords = []
        for x, y in points:
            x, y = round(x - min_x, 3), round(y - baseline, 3)
            coords.append(x)
            coords.append(y)
            for i, value in enumerate((x, y)):
                if out_min[i] is None:
                    out_min[i] = out_max[i] = value
                else:
                    out_min[i] = min(out_min[i], value)
                    out_max[i] = max(out_max[i], value)
        parts.append(op + " " + " ".join(fmt(v) for v in coords))

    return (
        " ".join(parts),
        out_max[0] - out_min[0],
        out_max[1] - out_min[1],
        svg_bbox,
        len(uses),
        len({ref for ref, _, _ in uses}),
    )


def c_literal(name, path, indent="    ", width=76):
    """Format a path as one or more adjacent C string literals."""
    lines, current = [], ""
    for token in path.split(" "):
        if current and len(current) + 1 + len(token) > width:
            lines.append(current)
            current = token
        else:
            current = token if not current else current + " " + token
    if current:
        lines.append(current)
    out = ["static const char %s[] =" % name]
    for i, line in enumerate(lines):
        end = ";" if i == len(lines) - 1 else ""
        tail = "" if i == len(lines) - 1 else " "
        out.append('%s"%s%s"%s' % (indent, line, tail, end))
    return "\n".join(out)


def build_header(words, source_name):
    chunks = []
    chunks.append(
        "/*\n"
        " * Comfortaa Bold wordmark outlines for the invoice header bar.\n"
        " *\n"
        " * Font: Comfortaa Bold by Johan Aakerlund, SIL Open Font License 1.1\n"
        " * (https://scripts.sil.org/OFL).  Only the outlines of the two words\n"
        " * below are reproduced; no font file is embedded or needed at runtime.\n"
        " *\n"
        " * Extracted from the #314c59 header bar (page 1, y 53.3-75.7 pt) of\n"
        " * the outgoing invoice PDF %s with scripts/extract-wordmark.py.\n"
        " * Paths are in PDF user space (y up), origin at the left baseline;\n"
        " * the dimensions are the ink width and height in points.\n"
        " *\n"
        " * Generated by scripts/extract-wordmark.py; do not edit by hand.\n"
        " */\n" % source_name
    )
    chunks.append("#ifndef BOKF_WORDMARK_H\n#define BOKF_WORDMARK_H\n")
    for word, (path, w, h, _bbox, uses, unique) in zip(WORDS, words):
        chunks.append(
            "#define WORDMARK_%s_W %s\n#define WORDMARK_%s_H %s\n"
            % (word, fmt(w), word, fmt(h))
        )
        chunks.append(c_literal("WORDMARK_" + word, path))
        chunks.append("")
    chunks.append("#endif\n")
    return "\n".join(chunks)


def main():
    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    parser.add_argument("pdf", help="invoice PDF to extract the wordmark from")
    parser.add_argument(
        "--check",
        action="store_true",
        help="print placements, bounding boxes and path digests, write nothing",
    )
    parser.add_argument(
        "--out", default=DEFAULT_OUT, help="output header (default: src/wordmark.h)"
    )
    args = parser.parse_args()

    svg = render_svg(args.pdf)
    page_height = float(
        re.search(r'<svg[^>]*\bheight="(' + NUMBER + r')"', svg).group(1)
    )
    glyphs = parse_glyphs(svg)
    words = header_words(svg, page_height)
    bar = bar_bbox(svg)
    source_name = os.path.basename(args.pdf)
    results = [compose_word(uses, glyphs, page_height) for uses in words]

    for word, uses, result in zip(WORDS, words, results):
        path, w, h, bbox, count, unique = result
        inside = (
            bar[0] <= bbox[0] and bbox[1] <= bar[2]
            and bar[1] <= bbox[2] and bbox[3] <= bar[3]
        )
        if not inside:
            sys.exit("extract-wordmark: %s escapes the header bar" % word)
        if args.check:
            digest = hashlib.sha256(path.encode()).hexdigest()[:16]
            print(
                "%s %s: %d placements (%d outlines), bbox x %.3f..%.3f y %.3f..%.3f,"
                " %.3f x %.3f pt, sha256 %s"
                % (
                    source_name,
                    word,
                    count,
                    unique,
                    bbox[0],
                    bbox[1],
                    bbox[2],
                    bbox[3],
                    w,
                    h,
                    digest,
                )
            )

    if args.check:
        return
    with open(args.out, "w", encoding="utf-8") as fh:
        fh.write(build_header(results, source_name))
    print("wrote %s" % os.path.relpath(args.out, REPO_ROOT))


if __name__ == "__main__":
    main()