generator/render.py

"""
render.py
---------
Draws a trajectory record as a PNG.

VALID records: uses the dense "smooth_x"/"smooth_y" curve (60 points) for the
line, so it reads as a real, smooth physical arc — with the 6 official labeled
points marked on top as numbered dots.

INVALID records: drawn using straight segments between the 6 points, same as
before. Keeping violations sparse/angular is intentional — a sharp discontinuity
should look sharp; smoothing it would hide exactly what makes it invalid.
"""

import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
from scipy.interpolate import CubicSpline


def render_trajectory(record, save_path, image_size=6):
    x = record["x"]
    y = record["y"]
    is_valid = record.get("valid", record.get("violation_type") is None)

    fig, ax = plt.subplots(figsize=(image_size, image_size))
    ax.axhline(0, color="saddlebrown", linewidth=3)

    if is_valid and "smooth_x" in record and "smooth_y" in record:
        # Real physics-based dense curve (60 points from the actual equations)
        curve_x, curve_y = record["smooth_x"], record["smooth_y"]
        ax.plot(curve_x, curve_y, linestyle="-", color="gray", linewidth=1.3, alpha=0.8, zorder=1)
    elif "jump_idx" in record:
        # Teleport: two genuinely separate smooth segments, no line connecting
        # them. A spline across the whole path would visually paper over the
        # exact thing this violation is testing — that no continuous path
        # connects the two positions. Leaving a real gap is the honest render.
        j = record["jump_idx"]
        seg1_x, seg1_y = x[:j], y[:j]      # points before the jump, unshifted
        seg2_x, seg2_y = x[j:], y[j:]      # points at/after the jump, shifted
        curve_x, curve_y = list(x), list(y)  # for axis limits below
        for seg_x, seg_y in [(seg1_x, seg1_y), (seg2_x, seg2_y)]:
            if len(seg_x) >= 2:
                s = np.arange(len(seg_x))
                s_fine = np.linspace(0, len(seg_x) - 1, 30)
                sx = CubicSpline(s, seg_x)(s_fine)
                sy = CubicSpline(s, seg_y)(s_fine)
                ax.plot(sx, sy, linestyle="-", color="gray", linewidth=1.3, alpha=0.8, zorder=1)
    else:
        # Parametric cubic spline through the 6 labeled points, using index
        # as the parameter (not x) so it stays well-behaved even when x
        # isn't monotonic (rewind case goes backward in x).
        s = np.arange(len(x))
        s_fine = np.linspace(0, len(x) - 1, 60)
        spline_x = CubicSpline(s, x)
        spline_y = CubicSpline(s, y)
        curve_x = spline_x(s_fine).tolist()
        curve_y = spline_y(s_fine).tolist()
        ax.plot(curve_x, curve_y, linestyle="-", color="gray", linewidth=1.3, alpha=0.8, zorder=1)

    # The 6 official labeled points, always marked the same way
    ax.scatter(x, y, color="crimson", s=80, zorder=2)
    for i, (px, py) in enumerate(zip(x, y)):
        ax.annotate(str(i + 1), (px, py), textcoords="offset points",
                    xytext=(0, 8), ha="center", fontsize=9)

    all_x = x + curve_x
    all_y = y + curve_y
    ax.set_xlim(min(all_x) - 1, max(all_x) + 2)
    ax.set_ylim(min(-3, min(all_y) - 1), max(all_y) + 2)
    ax.set_xticks([])
    ax.set_yticks([])
    for spine in ax.spines.values():
        spine.set_visible(False)

    plt.tight_layout()
    plt.savefig(save_path, dpi=100)
    plt.close(fig)