Add TJA chart image preview

README.md

@@ -25,7 +25,11 @@ from the Hugging Face Hub via `from_pretrained`.
 - **SoftChart v15** ([softchart-v15](https://huggingface.co/JacobLinCool/softchart-v15)) — unified slot + time + beat model; slot mode emits exact TJA lattice indices when the beat grid is trusted
 - **Planner** ([softchart-planner](https://huggingface.co/JacobLinCool/softchart-planner)) — audio → song-level plan (density envelope, breathing gaps, climax)
 
-Upload a song, pick a difficulty, and get a preview plus a `.tja` playable in
-TJAPlayer3 / OpenTaiko.
+Upload a song, pick a difficulty, and get a full-song mel/plan preview, a
+full TJA chart image, and a `.tja` playable in TJAPlayer3 / OpenTaiko. The
+generated TJA keeps the uploaded audio filename in its `WAVE` field.
+The chart image uses a server-side renderer modeled on the row layout used by
+MIT-licensed [tja-tools](https://github.com/WHMHammer/tja-tools), without
+shipping its browser/webpack runtime.
 
 > Code and weights are **MIT-licensed**.

app.py

@@ -8,6 +8,7 @@ All models load from the Hub via from_pretrained. MIT licensed.
 """
 
 import os
+import re
 import tempfile
 
 import gradio as gr
@@ -19,6 +20,7 @@ from softchart.grid import debias_to_grid, fit_grid_fixed_bpm, fit_grid_piecewis
 from softchart.hf import SoftChartPlanner
 from softchart.rhythm import snap_chart
 from softchart.tja import write_tja_slots
+from softchart.tja_image import render_tja_image
 from softchart.vocab import FPS, HOP, N_FFT, N_MELS, SR
 
 V15_REPO = os.environ.get("SC_V15", "JacobLinCool/softchart-v15")
@@ -26,12 +28,8 @@ PLAN_REPO = os.environ.get("SC_PLAN", "JacobLinCool/softchart-planner")
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
 COURSE_DENS = {"easy": 1, "normal": 2, "hard": 4, "oni": 7}
-DEFAULT_LEVEL = {"easy": 3, "normal": 5, "hard": 7, "oni": 9}
 CHAR = {"don": "1", "ka": "2", "don_big": "3", "ka_big": "4",
         "roll": "5", "roll_big": "6", "balloon": "7"}
-STYLE = {"don": ("#e8453c", 55), "ka": ("#4aa8c0", 55),
-         "don_big": ("#e8453c", 150), "ka_big": ("#4aa8c0", 150),
-         "roll": ("#e8b23a", 80), "roll_big": ("#e8b23a", 150), "balloon": ("#d47fda", 100)}
 SUB = 96
 
 _MODELS = {}
@@ -133,7 +131,19 @@ def group_quantize(times, phase, grid, min_run=3):
     return slots
 
 
-def write_tja(gen, bpm, title, course, level, downbeats=None, grid_fit=None):
+def upload_wave_name(audio_path):
+    name = os.path.basename(str(audio_path)).strip()
+    name = re.sub(r"[\r\n]+", " ", name)
+    return name or "song.ogg"
+
+
+def output_tja_path(wave_name, course):
+    stem = os.path.splitext(os.path.basename(wave_name))[0].strip() or "softchart"
+    stem = re.sub(r"[^0-9A-Za-z._ -]+", "_", stem).strip(" ._") or "softchart"
+    return os.path.join(tempfile.mkdtemp(), f"{stem}_{course}.tja")
+
+
+def write_tja(gen, bpm, title, course, level, wave, downbeats=None, grid_fit=None):
     hits = sorted((h["t"], CHAR[h["type"]]) for h in gen["hits"])
     beat = 60.0 / bpm
     grid = beat / (SUB / 4)
@@ -188,69 +198,44 @@ def write_tja(gen, bpm, title, course, level, downbeats=None, grid_fit=None):
     lines = ["".join(slots.get(m * SUB + k, "0") for k in range(SUB)) + "," for m in range(n_meas)]
     balloons = [10] * sum(1 for s in gen["spans"] if s["type"] == "balloon")
     return "\n".join([
-        f"TITLE:{title} (SoftChart)", f"BPM:{bpm:g}", "WAVE:song.ogg",
+        f"TITLE:{title} (SoftChart)", f"BPM:{bpm:g}", f"WAVE:{wave}",
         f"OFFSET:{-phase:.3f}", f"COURSE:{'Oni' if course == 'oni' else course.capitalize()}",
         f"LEVEL:{level}", f"BALLOON:{','.join(map(str, balloons))}" if balloons else "BALLOON:",
         "", "#START", *lines, "#END"]) + "\n"
 
 
-def render(mel, gen, title, course, plan=None):
+def render_audio_plan(mel, title, course, plan=None):
     import matplotlib
     matplotlib.use("Agg")
     import matplotlib.pyplot as plt
 
     dur = mel.shape[1] / FPS
-    # frame-exact window: extent matches the sliced pixels exactly, so the
-    # mel image, the note axis, and the plan shading share one clock
-    f0 = int(dur * 0.33 * FPS)
-    f1 = min(f0 + int(26 * FPS), mel.shape[1])
-    t0, t1 = f0 / FPS, f1 / FPS
-    fig = plt.figure(figsize=(13, 5.2 if plan else 4))
-    gs = fig.add_gridspec(3 if plan else 2, 1,
-                          height_ratios=[2.3, 1, 0.8] if plan else [2.3, 1],
-                          hspace=0.16 if plan else 0.1)
+    fig = plt.figure(figsize=(13, 4.4 if plan else 3.2))
+    gs = fig.add_gridspec(2 if plan else 1, 1,
+                          height_ratios=[3.0, 1.0] if plan else [1],
+                          hspace=0.14 if plan else 0.0)
     ax0 = fig.add_subplot(gs[0])
-    ax0.imshow(mel[:, f0:f1], aspect="auto", origin="lower",
-               cmap="magma", extent=[t0, t1, 0, N_MELS])
-    ax0.set_xticks([])
+    ax0.imshow(mel, aspect="auto", origin="lower",
+               cmap="magma", extent=[0, dur, 0, N_MELS])
     ax0.set_ylabel("mel")
-    ax0.set_title(f"{title} — {course}  |  red=don blue=ka big=large yellow=roll purple=balloon")
-    ax1 = fig.add_subplot(gs[1])
-    if plan:  # in-window plan shading: density = grey depth, gap/climax tinted
-        for a, b, d, f in plan:
-            if b < t0 or a > t1:
-                continue
-            c, al = ("#4a90d9", 0.16) if f == 1 else (
-                ("#d64545", 0.16) if f == 2 else ("#000000", 0.03 + d / 7 * 0.09))
-            ax1.axvspan(max(a, t0), min(b, t1), color=c, alpha=al, lw=0)
-    for h in gen["hits"]:
-        if t0 <= h["t"] <= t1:
-            c, sz = STYLE.get(h["type"], ("#999", 40))
-            ax1.scatter(h["t"], 0, c=c, s=sz, edgecolors="k",
-                        linewidths=1.2 if "big" in h["type"] else 0.5, zorder=3)
-    for s in gen["spans"]:
-        if s["t1"] >= t0 and s["t0"] <= t1:
-            ax1.plot([max(s["t0"], t0), min(s["t1"], t1)], [0, 0],
-                     c=STYLE.get(s["type"], ("#e8b23a",))[0], lw=6, alpha=0.45, zorder=2)
-    ax1.set_xlim(t0, t1)
-    ax1.set_ylim(-1, 1)
-    ax1.set_yticks([])
-    ax1.set_xlabel("" if plan else "time (s)")
-    ax1.grid(axis="x", alpha=0.25)
+    ax0.set_title(f"{title} — {course}  |  full-song mel spectrogram")
+    ax0.set_xlim(0, dur)
+    ax0.grid(axis="x", alpha=0.18)
     if plan:
-        # full-song plan strip: what the planner asked for (density envelope,
-        # gaps, climax), with the zoomed preview window marked
-        ax2 = fig.add_subplot(gs[2])
+        ax0.set_xticklabels([])
+        ax1 = fig.add_subplot(gs[1], sharex=ax0)
         for a, b, d, f in plan:
             c = "#d64545" if f == 2 else ("#4a90d9" if f == 1 else "#999999")
-            ax2.bar((a + b) / 2, max(d, 0.15), width=(b - a) * 0.92, color=c, alpha=0.85)
-        ax2.axvspan(t0, t1, color="#e8b23a", alpha=0.18, lw=0)
-        ax2.set_xlim(0, dur)
-        ax2.set_ylim(0, 8)
-        ax2.set_yticks([0, 4, 8])
-        ax2.set_ylabel("plan", fontsize=8)
-        ax2.set_xlabel("time (s)  —  plan: grey=density blue=gap red=climax, "
-                       "yellow band = preview window above")
+            ax1.bar((a + b) / 2, max(d, 0.15), width=max((b - a) * 0.92, 0.01),
+                    color=c, alpha=0.85)
+        ax1.set_xlim(0, dur)
+        ax1.set_ylim(0, 8)
+        ax1.set_yticks([0, 4, 8])
+        ax1.set_ylabel("plan", fontsize=8)
+        ax1.set_xlabel("time (s)  —  plan: grey=density blue=gap red=climax")
+        ax1.grid(axis="x", alpha=0.18)
+    else:
+        ax0.set_xlabel("time (s)")
     out = tempfile.mktemp(suffix=".png")
     fig.savefig(out, dpi=130, bbox_inches="tight")
     plt.close(fig)
@@ -316,7 +301,8 @@ def generate(audio, course, level, bpm_override, auto_plan_on, use_beat, use_pla
         elif auto_plan_on:
             plan = auto_plan(mel, bpm, dbs)
 
-    title = os.path.splitext(os.path.basename(audio))[0]
+    wave_name = upload_wave_name(audio)
+    title = os.path.splitext(wave_name)[0]
     slot_used = False
     if grid is not None and M["slot"] is not None:
         # slot-exact path: the decoder emits TJA lattice indices directly —
@@ -327,7 +313,7 @@ def generate(audio, course, level, bpm_override, auto_plan_on, use_beat, use_pla
             device=DEVICE, plan=plan,
             on_progress=lambda d, t: P(0.32 + 0.58 * d / max(t, 1),
                                        f"Generating notes (slot-exact)… {d}/{t} windows"))
-        tja = write_tja_slots(g, grid, title, course, int(level), "song.ogg")
+        tja = write_tja_slots(g, grid, title, course, int(level), wave_name)
         slot_used = True
     else:
         g = generate_song(
@@ -337,13 +323,14 @@ def generate(audio, course, level, bpm_override, auto_plan_on, use_beat, use_pla
             on_progress=lambda d, t: P(0.32 + 0.58 * d / max(t, 1),
                                        f"Generating notes… {d}/{t} windows"))
         g = snap_chart(g, bpm)
-        tja = write_tja(g, bpm, title, course, int(level), dbs, grid_fit=grid)
+        tja = write_tja(g, bpm, title, course, int(level), wave_name, dbs, grid_fit=grid)
     P(0.92, "Writing TJA…")
-    tja_path = tempfile.mktemp(suffix=f"_{course}.tja")
-    with open(tja_path, "w") as f:
+    tja_path = output_tja_path(wave_name, course)
+    with open(tja_path, "w", encoding="utf-8") as f:
         f.write(tja)
     P(0.95, "Rendering preview…")
-    img = render(mel, g, title, course, plan=plan)
+    audio_plan_img = render_audio_plan(mel, title, course, plan=plan)
+    tja_img = render_tja_image(tja)
     if grid is not None:
         grid_info = (f" · grid: rms {grid['rms_ms']:.1f}ms ({grid['inlier_frac']:.0%} inlier)"
                      + (f" · {grid['n_segments']} tempo segs" if grid.get("piecewise") else "")
@@ -354,7 +341,7 @@ def generate(audio, course, level, bpm_override, auto_plan_on, use_beat, use_pla
         grid_info = ""
     info = (f"BPM {bpm:.1f} · {len(g['hits'])} notes · {len(g['spans'])} spans" + grid_info
             + (f" · plan: {sum(1 for b in plan if b[3]==1)} gaps, {sum(1 for b in plan if b[3]==2)} climax" if plan else ""))
-    return img, tja_path, info
+    return audio_plan_img, tja_img, tja_path, info
 
 
 with gr.Blocks(title="SoftChart — AI Taiko chart generator") as demo:
@@ -362,7 +349,7 @@ with gr.Blocks(title="SoftChart — AI Taiko chart generator") as demo:
         "# 🥁 SoftChart\n"
         "Generate a **Taiko no Tatsujin** chart from any song. 8M-param plan-conditioned "
         "model + learned planner + beat-anchoring — all MIT-licensed.\n\n"
-        "Outputs a preview and a playable `.tja`. "
+        "Outputs a full-song mel/plan preview, a full TJA chart image, and a playable `.tja`. "
         "*MIT-licensed.*"
     )
     with gr.Row():
@@ -379,11 +366,12 @@ with gr.Blocks(title="SoftChart — AI Taiko chart generator") as demo:
                 sampling = gr.Checkbox(label="Sampling (diverse) vs greedy (best)", value=False)
             btn = gr.Button("Generate chart", variant="primary")
         with gr.Column():
-            out_img = gr.Image(label="Preview (mel + chart)")
+            out_img = gr.Image(label="Full-song mel + plan")
+            out_chart = gr.Image(label="TJA chart")
             out_info = gr.Textbox(label="Result", interactive=False)
             out_tja = gr.File(label="Download .tja")
     btn.click(generate, [audio, course, level, bpm, auto_plan_on, use_beat, use_planner, sampling],
-              [out_img, out_tja, out_info])
+              [out_img, out_chart, out_tja, out_info])
 
 if __name__ == "__main__":
     # show_api=False avoids a gradio_client schema-introspection bug

requirements.txt

@@ -5,6 +5,7 @@ librosa>=0.10
 numba>=0.60
 soundfile
 matplotlib
+pillow
 gradio==5.9.1
 gradio_client==1.5.2
 pydantic==2.10.6

softchart/tja_image.py

@@ -0,0 +1,285 @@
+"""Server-side TJA chart image rendering for the Space.
+
+The layout follows the same practical convention as tja-tools: full-chart rows
+with 16 beats per row, measure barlines, colored note heads, and long-note
+spans. SoftChart emits simple single-course TJAs, so this renderer intentionally
+supports the generated subset instead of bundling the browser/webpack canvas
+app at runtime.
+"""
+
+from __future__ import annotations
+
+import math
+import os
+import tempfile
+from dataclasses import dataclass
+
+from PIL import Image, ImageDraw, ImageFont
+
+
+_NOTE_CHARS = set("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+_COURSE_NAME = {
+    "0": "Easy",
+    "1": "Normal",
+    "2": "Hard",
+    "3": "Oni",
+    "4": "Ura",
+}
+
+
+@dataclass
+class ParsedTJA:
+    headers: dict[str, str]
+    measures: list[str]
+    bpm_changes: dict[int, str]
+
+
+def _font(size: int, bold: bool = False) -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
+    names = (
+        "DejaVuSans-Bold.ttf" if bold else "DejaVuSans.ttf",
+        "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf" if bold else
+        "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+        "/System/Library/Fonts/Supplemental/Arial Bold.ttf" if bold else
+        "/System/Library/Fonts/Supplemental/Arial.ttf",
+        "/System/Library/Fonts/Supplemental/Helvetica Bold.ttf" if bold else
+        "/System/Library/Fonts/Supplemental/Helvetica.ttf",
+    )
+    for name in names:
+        try:
+            return ImageFont.truetype(name, size=size)
+        except OSError:
+            pass
+    return ImageFont.load_default()
+
+
+def _strip_comment(line: str) -> str:
+    return line.split("//", 1)[0].strip()
+
+
+def parse_tja(tja_text: str) -> ParsedTJA:
+    headers: dict[str, str] = {}
+    measures: list[str] = []
+    bpm_changes: dict[int, str] = {}
+    in_chart = False
+    measure_buf: list[str] = []
+
+    def flush_measure() -> None:
+        measure = "".join(measure_buf).strip()
+        measures.append(measure or "0")
+        measure_buf.clear()
+
+    for raw_line in tja_text.splitlines():
+        line = _strip_comment(raw_line)
+        if not line:
+            continue
+        upper = line.upper()
+        if upper.startswith("#START"):
+            in_chart = True
+            continue
+        if not in_chart:
+            if ":" in line and not line.startswith("#"):
+                key, value = line.split(":", 1)
+                headers[key.strip().upper()] = value.strip()
+            continue
+        if upper.startswith("#END"):
+            break
+        if upper.startswith("#BPMCHANGE"):
+            parts = line.split(maxsplit=1)
+            if len(parts) == 2:
+                bpm_changes[len(measures)] = parts[1].strip()
+            continue
+        if line.startswith("#"):
+            continue
+        for ch in line:
+            if ch == ",":
+                flush_measure()
+            elif ch.upper() in _NOTE_CHARS:
+                measure_buf.append(ch.upper())
+
+    if measure_buf:
+        flush_measure()
+    if not measures:
+        measures.append("0")
+    return ParsedTJA(headers=headers, measures=measures, bpm_changes=bpm_changes)
+
+
+def _course_label(value: str) -> str:
+    return _COURSE_NAME.get(value, value[:1].upper() + value[1:].lower() if value else "")
+
+
+def _text_right(draw: ImageDraw.ImageDraw, xy: tuple[int, int], text: str,
+                font: ImageFont.ImageFont, fill: str) -> None:
+    x, y = xy
+    bbox = draw.textbbox((0, 0), text, font=font)
+    draw.text((x - (bbox[2] - bbox[0]), y), text, font=font, fill=fill)
+
+
+def _beat_xy(beat: float, row_beats: float, beat_width: int, left: int,
+             top: int, row_h: int, note_y: int, rows: int) -> tuple[int, int, int]:
+    row = max(0, min(rows - 1, int(math.floor(beat / row_beats))))
+    x = int(round(left + (beat - row * row_beats) * beat_width))
+    y = top + row * row_h + note_y
+    return row, x, y
+
+
+def _note_events(measures: list[str]) -> tuple[list[tuple[float, str]], list[tuple[float, float, str]]]:
+    events: list[tuple[float, str]] = []
+    rolls: list[tuple[float, float, str]] = []
+    open_roll: tuple[float, str] | None = None
+
+    for midx, measure in enumerate(measures):
+        div = max(len(measure), 1)
+        for pos, symbol in enumerate(measure):
+            if symbol == "0":
+                continue
+            beat = midx * 4.0 + 4.0 * pos / div
+            if symbol in {"5", "6", "7", "9"}:
+                if open_roll is not None:
+                    rolls.append((open_roll[0], beat, open_roll[1]))
+                open_roll = (beat, symbol)
+                events.append((beat, symbol))
+            elif symbol == "8":
+                if open_roll is not None:
+                    rolls.append((open_roll[0], beat, open_roll[1]))
+                    open_roll = None
+                else:
+                    events.append((beat, symbol))
+            else:
+                events.append((beat, symbol))
+
+    if open_roll is not None:
+        rolls.append((open_roll[0], max(4.0 * len(measures), open_roll[0] + 0.25), open_roll[1]))
+    return events, rolls
+
+
+def _draw_roll(draw: ImageDraw.ImageDraw, start: float, end: float, symbol: str,
+               row_beats: float, beat_width: int, left: int, top: int, row_h: int,
+               note_y: int, rows: int) -> None:
+    color = "#b77de1" if symbol in {"7", "9"} else "#e9b83e"
+    edge = "#6f5520" if symbol not in {"7", "9"} else "#6c4388"
+    start_row = max(0, int(math.floor(start / row_beats)))
+    end_row = max(0, int(math.floor(max(end - 1e-6, start) / row_beats)))
+    for row in range(start_row, min(end_row, rows - 1) + 1):
+        seg0 = max(start, row * row_beats)
+        seg1 = min(end, (row + 1) * row_beats)
+        if seg1 <= seg0:
+            continue
+        x0 = int(round(left + (seg0 - row * row_beats) * beat_width))
+        x1 = int(round(left + (seg1 - row * row_beats) * beat_width))
+        y = top + row * row_h + note_y
+        draw.rounded_rectangle((x0, y - 8, max(x1, x0 + 3), y + 8),
+                               radius=8, fill=color, outline=edge, width=2)
+
+
+def _draw_note(draw: ImageDraw.ImageDraw, x: int, y: int, symbol: str,
+               label_font: ImageFont.ImageFont) -> None:
+    if symbol in {"1", "3", "A"}:
+        fill = "#e34b3f"
+    elif symbol in {"2", "4", "B"}:
+        fill = "#4aa8c0"
+    elif symbol in {"5", "6"}:
+        fill = "#e9b83e"
+    elif symbol in {"7", "9"}:
+        fill = "#b77de1"
+    elif symbol == "8":
+        fill = "#555555"
+    else:
+        fill = "#8d96a0"
+
+    radius = 16 if symbol in {"3", "4", "6", "A", "B"} else 12
+    if symbol == "8":
+        draw.rectangle((x - 5, y - 12, x + 5, y + 12), fill=fill)
+        return
+
+    draw.ellipse((x - radius, y - radius, x + radius, y + radius),
+                 fill=fill, outline="#202020", width=2)
+    draw.ellipse((x - radius + 4, y - radius + 4, x - radius + 9, y - radius + 9),
+                 fill="#ffffff")
+    label = "B" if symbol in {"3", "4", "6", "A", "B"} else ("R" if symbol in {"5", "6"} else ("P" if symbol in {"7", "9"} else ""))
+    if label:
+        bbox = draw.textbbox((0, 0), label, font=label_font)
+        draw.text((x - (bbox[2] - bbox[0]) / 2, y - (bbox[3] - bbox[1]) / 2 - 1),
+                  label, font=label_font, fill="#1e1e1e")
+
+
+def render_tja_image(tja_text: str, out_path: str | None = None) -> str:
+    parsed = parse_tja(tja_text)
+    headers = parsed.headers
+    row_beats = 16.0
+    try:
+        row_beats = float(headers.get("TTROWBEAT", row_beats))
+    except ValueError:
+        row_beats = 16.0
+    row_beats = min(max(row_beats, 4.0), 32.0)
+
+    title = headers.get("TITLE", "SoftChart")
+    course = _course_label(headers.get("COURSE", ""))
+    level = headers.get("LEVEL", "")
+    bpm = headers.get("BPM", "")
+    wave = headers.get("WAVE", "")
+    measures = parsed.measures
+    total_beats = max(4.0 * len(measures), 4.0)
+    rows = max(1, int(math.ceil(total_beats / row_beats)))
+
+    left = 72
+    right = 30
+    beat_width = 56
+    header_h = 90
+    row_h = 74
+    note_y = 45
+    footer_h = 22
+    width = int(left + row_beats * beat_width + right)
+    height = int(header_h + rows * row_h + footer_h)
+
+    img = Image.new("RGB", (width, height), "#f5f3ee")
+    draw = ImageDraw.Draw(img)
+    title_font = _font(24, bold=True)
+    meta_font = _font(14)
+    small_font = _font(11)
+    note_font = _font(10, bold=True)
+
+    draw.rectangle((0, 0, width, header_h - 8), fill="#23272f")
+    draw.text((24, 16), title, font=title_font, fill="#ffffff")
+    meta = " · ".join(p for p in (course, f"Lv.{level}" if level else "", f"BPM {bpm}" if bpm else "") if p)
+    draw.text((24, 51), meta or "Generated TJA chart", font=meta_font, fill="#d8dde7")
+    if wave:
+        _text_right(draw, (width - 24, 52), f"WAVE {os.path.basename(wave)}", meta_font, "#d8dde7")
+    _text_right(draw, (width - 24, 18), "red=don  blue=ka  yellow=roll  purple=balloon",
+                small_font, "#b8c0cc")
+
+    for row in range(rows):
+        y0 = header_h + row * row_h
+        y1 = y0 + row_h - 12
+        fill = "#d8d8d3" if row % 2 == 0 else "#cecec9"
+        draw.rounded_rectangle((14, y0, width - 14, y1), radius=8, fill=fill)
+        cy = y0 + note_y
+        draw.line((left, cy, width - right, cy), fill="#6d6d68", width=1)
+        for b in range(int(row_beats) + 1):
+            x = int(round(left + b * beat_width))
+            is_bar = b % 4 == 0
+            draw.line((x, y0 + 8, x, y1 - 6),
+                      fill="#5c5c58" if is_bar else "#eeeeea",
+                      width=2 if is_bar else 1)
+            if is_bar:
+                measure_idx = int(row * row_beats / 4 + b / 4)
+                if measure_idx < len(measures):
+                    draw.text((x + 3, y0 + 9), str(measure_idx + 1),
+                              font=small_font, fill="#4a4a46")
+
+    for measure_idx, bpm_value in parsed.bpm_changes.items():
+        beat = measure_idx * 4.0
+        row, x, _ = _beat_xy(beat, row_beats, beat_width, left, header_h, row_h, note_y, rows)
+        draw.text((x + 4, header_h + row * row_h + 26), f"BPM {bpm_value}",
+                  font=small_font, fill="#8b3d3d")
+
+    events, rolls = _note_events(measures)
+    for start, end, symbol in rolls:
+        _draw_roll(draw, start, end, symbol, row_beats, beat_width, left, header_h, row_h, note_y, rows)
+    for beat, symbol in events:
+        _, x, y = _beat_xy(beat, row_beats, beat_width, left, header_h, row_h, note_y, rows)
+        _draw_note(draw, x, y, symbol, note_font)
+
+    if out_path is None:
+        out_path = tempfile.mktemp(suffix="_tja.png")
+    img.save(out_path)
+    return out_path