page_writer.py

import numpy as np
from PIL import Image, ImageDraw

from render_sentence import generate_strokes


# ==========================================
# PAGE SETTINGS
# ==========================================

PAGE_W = 2000
PAGE_H = 2800

LEFT_MARGIN = 180
RIGHT_MARGIN = 180

TOP_MARGIN = 180

LINE_BOX_HEIGHT = 120

RULE_GAP = 120

MAX_LINE_WIDTH = PAGE_W - LEFT_MARGIN - RIGHT_MARGIN

INK_COLOR = (20, 20, 20)

STROKE_WIDTH = 2

SHOW_RULES = True


# ==========================================
# HELPERS
# ==========================================

def get_bounds(strokes):

    xs = []
    ys = []

    for stroke in strokes:

        if len(stroke) == 0:
            continue

        xs.extend(stroke[:, 0])
        ys.extend(stroke[:, 1])

    if not xs:
        return None

    return (
        min(xs),
        max(xs),
        min(ys),
        max(ys)
    )


# ==========================================
# RENDER PAGE
# ==========================================

def render_page(lines, output="page.png"):

    img = Image.new(
        "RGB",
        (PAGE_W, PAGE_H),
        "white"
    )

    draw = ImageDraw.Draw(img)

    # ----------------------------------
    # notebook rules
    # ----------------------------------

    if SHOW_RULES:

        y = TOP_MARGIN

        while y < PAGE_H - 100:

            draw.line(
                [(50, y), (PAGE_W - 50, y)],
                fill=(220, 220, 220),
                width=1
            )

            y += RULE_GAP

    # ----------------------------------
    # render lines
    # ----------------------------------

    baseline_y = TOP_MARGIN

    for idx, line in enumerate(lines):

        print(
            f"[{idx+1}/{len(lines)}] {line}"
        )

        strokes = generate_strokes(
            line,
            temperature=0.10
        )

        bounds = get_bounds(strokes)

        if bounds is None:
            continue

        min_x, max_x, min_y, max_y = bounds

        width = max_x - min_x
        height = max_y - min_y

        if width <= 0:
            continue

        # ----------------------------------
        # Fit inside notebook line box
        # ----------------------------------

        scale_x = MAX_LINE_WIDTH / width

        scale_y = (
            LINE_BOX_HEIGHT * 0.70
        ) / max(height, 1)

        scale = min(
            scale_x,
            scale_y
        )

        # ----------------------------------
        # Vertical centering
        # ----------------------------------

        center_y = (
            min_y + max_y
        ) / 2

        target_center = (
            baseline_y
            - LINE_BOX_HEIGHT * 0.30
        )

        for stroke in strokes:

            pts = []

            for x, y in stroke:

                px = (
                    (x - min_x)
                    * scale
                    + LEFT_MARGIN
                )

                py = (
                    -(y - center_y)
                    * scale
                    + target_center
                )

                pts.append(
                    (
                        float(px),
                        float(py)
                    )
                )

            if len(pts) >= 2:

                draw.line(
                    pts,
                    fill=INK_COLOR,
                    width=STROKE_WIDTH
                )

        baseline_y += RULE_GAP

        if baseline_y > PAGE_H - 100:
            break

    img.save(output)

    print(f"\nSaved: {output}")