git-subtree-dir: vendor/dumas_minimax_h3_refmod git-subtree-split: 517e8c419a8584fbf69fceb487bc39d83e6a6ec8
206 lines
7.3 KiB
Python
206 lines
7.3 KiB
Python
"""
|
|
debug_grid.py — 1024x1024 curve-graph visualization for Apply H3 RefMod.
|
|
|
|
Renders the per-frame strength envelope (direction/shape/value) across the
|
|
full canvas, with the "concept zone" shaded where the concept shows up. It
|
|
is both the Apply's optional debug IMAGE output and the saved graph-preset
|
|
PNG (graph embedded in the image's tEXt metadata).
|
|
|
|
Pure PIL; ``pil_to_tensor`` converts the result to a torch IMAGE tensor.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
from typing import Dict, Optional, Tuple
|
|
|
|
import numpy as np
|
|
import torch
|
|
from PIL import Image, ImageDraw, ImageFont, PngImagePlugin
|
|
|
|
from .core import CURVE_DIRECTIONS, CURVE_SHAPES, curve_strengths
|
|
|
|
SIZE = 1024
|
|
|
|
BG = (18, 20, 24)
|
|
TITLE = (232, 230, 227)
|
|
TEXT = (207, 203, 196)
|
|
DIM = (107, 111, 118)
|
|
GRID_LINE = (42, 46, 54)
|
|
ACCENT = (255, 158, 61)
|
|
ACCENT_FILL = (58, 34, 15)
|
|
ACCENT_DIM = (122, 69, 21)
|
|
|
|
_CURVE_SAMPLES = 160
|
|
|
|
# where the concept shows up in the output, per direction — the envelope is
|
|
# drawn on the same timeline, so it is strong exactly where the zone is
|
|
_ZONES = {
|
|
"concept_at_start": ((0.0, 1.0 / 3.0),),
|
|
"concept_at_middle": ((1.0 / 3.0, 2.0 / 3.0),),
|
|
"concept_at_end": ((2.0 / 3.0, 1.0),),
|
|
"concept_at_ends": ((0.0, 1.0 / 3.0), (2.0 / 3.0, 1.0)),
|
|
}
|
|
|
|
|
|
# ── fonts ────────────────────────────────────────────────────────────────────
|
|
|
|
_FONT_CACHE: Dict[Tuple[int, bool, bool], ImageFont.FreeTypeFont] = {}
|
|
|
|
|
|
def _font(size: int, bold: bool = False, mono: bool = False):
|
|
key = (size, bold, mono)
|
|
if key in _FONT_CACHE:
|
|
return _FONT_CACHE[key]
|
|
candidates = []
|
|
if os.name == "nt":
|
|
base = "C:/Windows/Fonts/"
|
|
name = "consola.ttf" if mono else ("arialbd.ttf" if bold else "arial.ttf")
|
|
candidates = [base + name]
|
|
else:
|
|
if mono:
|
|
candidates = [
|
|
"/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",
|
|
"/System/Library/Fonts/Menlo.ttc",
|
|
]
|
|
else:
|
|
candidates = [
|
|
"/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf" if bold
|
|
else "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
|
|
"/System/Library/Fonts/Supplemental/Arial.ttf",
|
|
]
|
|
for path in candidates:
|
|
if os.path.isfile(path):
|
|
try:
|
|
f = ImageFont.truetype(path, size)
|
|
_FONT_CACHE[key] = f
|
|
return f
|
|
except OSError:
|
|
pass
|
|
try:
|
|
f = ImageFont.load_default(size=size)
|
|
except Exception:
|
|
f = ImageFont.load_default()
|
|
_FONT_CACHE[key] = f
|
|
return f
|
|
|
|
|
|
def _text_w(draw: ImageDraw.ImageDraw, text: str, font) -> int:
|
|
l, _t, r, _b = draw.textbbox((0, 0), text, font=font)
|
|
return r - l
|
|
|
|
|
|
# ── the curve graph ──────────────────────────────────────────────────────────
|
|
|
|
def render_debug_grid(spec, preset_name: str = "") -> Image.Image:
|
|
"""Render the 1024x1024 curve graph for an Apply configuration.
|
|
|
|
``spec`` is the resolved (direction, shape, value) curve tuple and
|
|
``preset_name`` the active graph preset (shown when one is loaded).
|
|
"""
|
|
img = Image.new("RGB", (SIZE, SIZE), BG)
|
|
draw = ImageDraw.Draw(img)
|
|
|
|
draw.text((32, 26), "curve graph", font=_font(28, bold=True), fill=TITLE)
|
|
if preset_name:
|
|
draw.text((SIZE - 32, 34), f"preset: {preset_name}",
|
|
font=_font(20), fill=DIM, anchor="rs")
|
|
|
|
x0, y0, x1, y1 = 90, 120, SIZE - 10, 940
|
|
direction = spec[0]
|
|
|
|
# concept zone shading (where the concept shows up in the output)
|
|
for start, end in _ZONES.get(direction, ()):
|
|
zx0 = x0 + start * (x1 - x0)
|
|
zx1 = x0 + end * (x1 - x0)
|
|
draw.rectangle([zx0, y0, zx1, y1], fill=ACCENT_FILL)
|
|
draw.text((zx0 + 8, y1 + 8), "concept zone", font=_font(20), fill=ACCENT_DIM)
|
|
|
|
# grid + axis labels
|
|
for f in (0.0, 0.25, 0.5, 0.75, 1.0):
|
|
gy = y1 - f * (y1 - y0)
|
|
draw.line([x0, gy, x1, gy], fill=GRID_LINE, width=2)
|
|
draw.text((16, gy - 12), f"{1.0 - f:.2f}", font=_font(20), fill=DIM)
|
|
for fx, label in ((0.0, "0"), (0.25, "0.25"), (0.5, "0.5"),
|
|
(0.75, "0.75"), (1.0, "1")):
|
|
gx = x0 + fx * (x1 - x0)
|
|
draw.line([gx, y0, gx, y1], fill=GRID_LINE, width=2)
|
|
draw.text((gx, y1 + 8), label, font=_font(20), fill=DIM, anchor="ma")
|
|
draw.text((x1 - 6, y1 + 8), "video →", font=_font(20), fill=DIM, anchor="ra")
|
|
|
|
# the envelope
|
|
strengths = curve_strengths(spec, _CURVE_SAMPLES)
|
|
if strengths is None:
|
|
strengths = [1.0] * _CURVE_SAMPLES
|
|
pts = [(x0 + i * (x1 - x0) / (_CURVE_SAMPLES - 1),
|
|
y1 - s * (y1 - y0)) for i, s in enumerate(strengths)]
|
|
draw.polygon([(x0, y1)] + pts + [(x1, y1)], fill=ACCENT_FILL)
|
|
draw.line(pts, fill=ACCENT, width=6)
|
|
|
|
# peak marker
|
|
peak = max(range(_CURVE_SAMPLES), key=lambda i: strengths[i])
|
|
px, py = pts[peak]
|
|
draw.line([px, y0, px, y1], fill=ACCENT_DIM, width=2)
|
|
draw.ellipse([px - 9, py - 9, px + 9, py + 9], fill=ACCENT)
|
|
|
|
# spec readout on a dark backdrop
|
|
lines = [f"direction: {direction}", f"shape: {spec[1]}",
|
|
f"value: {float(spec[2]):.2f}"]
|
|
font = _font(24, mono=True)
|
|
tw = max(_text_w(draw, ln, font) for ln in lines)
|
|
draw.rectangle([x0 + 18, y0 + 18, x0 + 18 + tw + 24, y0 + 18 + 3 * 34 + 12],
|
|
fill=(14, 17, 22))
|
|
for i, ln in enumerate(lines):
|
|
draw.text((x0 + 30, y0 + 28 + i * 34), ln, font=font, fill=TEXT)
|
|
|
|
return img
|
|
|
|
|
|
# ── graph presets (PNG metadata) ────────────────────────────────────────────
|
|
|
|
# The graph spec is embedded in the preset PNG's tEXt chunk, so a saved curve
|
|
# graph IS the preset: share the image, and the curve comes with it.
|
|
GRAPH_META_KEY = "graph"
|
|
|
|
|
|
def graph_pnginfo(spec):
|
|
"""PIL pnginfo carrying the (direction, shape, value) spec as tEXt."""
|
|
info = PngImagePlugin.PngInfo()
|
|
info.add_text(GRAPH_META_KEY, json.dumps({
|
|
"direction": spec[0], "shape": spec[1], "value": float(spec[2])}))
|
|
return info
|
|
|
|
|
|
def read_graph_meta(path: str) -> Optional[tuple]:
|
|
"""Read a (direction, shape, value) spec from a PNG's tEXt metadata.
|
|
|
|
Returns None for a missing file, a missing/empty chunk, or an invalid
|
|
spec (unknown direction/shape, bad value) so callers can fall back.
|
|
"""
|
|
try:
|
|
with Image.open(path) as img:
|
|
raw = img.text.get(GRAPH_META_KEY)
|
|
except Exception:
|
|
return None
|
|
if not raw:
|
|
return None
|
|
try:
|
|
data = json.loads(raw)
|
|
except ValueError:
|
|
return None
|
|
direction, shape = data.get("direction"), data.get("shape")
|
|
if direction not in CURVE_DIRECTIONS or shape not in CURVE_SHAPES:
|
|
return None
|
|
try:
|
|
value = float(data.get("value", 1.0))
|
|
except (TypeError, ValueError):
|
|
return None
|
|
return (direction, shape, value)
|
|
|
|
|
|
def pil_to_tensor(img: Image.Image) -> torch.Tensor:
|
|
"""Convert a rendered PIL graph to a [1, 1024, 1024, 3] float32 tensor."""
|
|
arr = np.asarray(img).copy()
|
|
return torch.from_numpy(arr).float().unsqueeze(0) / 255.0 # [1, 1024, 1024, 3]
|