Reconstruct repo from Claude Code + codex transcripts
Working tree (including .git) was lost to an rm. Rebuilt by replaying Write/Edit/ Read/attachment events from 25 Claude sessions and 22 successful codex apply_patch blocks into one timestamp-ordered timeline. Verified against ground truth recorded in the transcripts: wc -l on 10 files and ls -l on 5 files at 2026-07-18T13:13:44Z both match exactly; 18 files are byte-identical to their newest ~/.claude/file-history blob. See HANDOFF.md for sources, gaps, and how to rebuild .venv. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
+169
@@ -0,0 +1,169 @@
|
||||
# collage.py — task 183 deterministic layout planner for animated manga collages.
|
||||
# Pure geometry, no ffmpeg/IO: ordered panels (+ aspects, RTL, emphasis, frame) -> a layout state
|
||||
# (template, aspect-correct resting rectangles, entrance vectors, z-order, hold/transition timing).
|
||||
# worker_render turns a state into a clip; this module decides WHERE everything sits so the decision
|
||||
# is testable without rendering. Coordinates are pixels in the output frame, origin top-left.
|
||||
#
|
||||
# ponytail: a bounded template set (n=1..4) covering the reference's common resting layouts, not all 7.
|
||||
# Add templates when a fixture proves a missing one is needed — the fit/RTL/entrance machinery is shared.
|
||||
|
||||
MARGIN = 0.035 # outer + inter-panel gap as a fraction of the frame's short side
|
||||
HOLD_S = 3.0 # reference holds run ~2-4s; #185 overrides per-beat from narration length
|
||||
TRANS_S = 0.45 # reference transitions run ~0.3-0.6s
|
||||
|
||||
|
||||
def _fit(aspect, slot):
|
||||
"""Aspect-correct rect centered inside slot (x,y,w,h). aspect=w/h. No stretch: letterbox to fit."""
|
||||
sx, sy, sw, sh = slot
|
||||
if aspect >= sw / sh: # panel wider than slot -> width-bound
|
||||
w = sw; h = w / aspect
|
||||
else: # taller than slot -> height-bound
|
||||
h = sh; w = h * aspect
|
||||
return (sx + (sw - w) / 2.0, sy + (sh - h) / 2.0, w, h)
|
||||
|
||||
|
||||
def _slots(template, n, W, H, g):
|
||||
"""Slot rectangles (pre-fit) for a template, in READING order (slot[0] = read first).
|
||||
g = gap in pixels. Slots tile the safe area; _fit later letterboxes each panel inside its slot."""
|
||||
x0, y0 = g, g
|
||||
fw, fh = W - 2 * g, H - 2 * g
|
||||
if template == "centered_wide":
|
||||
return [(x0, y0, fw, fh)]
|
||||
if template == "vertical_pair": # two columns
|
||||
cw = (fw - g) / 2.0
|
||||
return [(x0, y0, cw, fh), (x0 + cw + g, y0, cw, fh)]
|
||||
if template == "stacked_wides": # two rows
|
||||
rh = (fh - g) / 2.0
|
||||
return [(x0, y0, fw, rh), (x0, y0 + rh + g, fw, rh)]
|
||||
if template == "strip_over_dominant": # thin top strip (reads first), big bottom
|
||||
sh = fh * 0.32
|
||||
return [(x0, y0, fw, sh), (x0, y0 + sh + g, fw, fh - sh - g)]
|
||||
if template == "supporting_left_dominant_right": # small stack left, one dominant right
|
||||
lw = fw * 0.34
|
||||
k = max(1, n - 1)
|
||||
rh = (fh - (k - 1) * g) / k
|
||||
left = [(x0, y0 + i * (rh + g), lw, rh) for i in range(k)]
|
||||
return left + [(x0 + lw + g, y0, fw - lw - g, fh)]
|
||||
if template == "quad": # 2x2
|
||||
cw, rh = (fw - g) / 2.0, (fh - g) / 2.0
|
||||
return [(x0, y0, cw, rh), (x0 + cw + g, y0, cw, rh),
|
||||
(x0, y0 + rh + g, cw, rh), (x0 + cw + g, y0 + rh + g, cw, rh)]
|
||||
raise ValueError(f"unknown template {template}")
|
||||
|
||||
|
||||
def _pick_template(aspects):
|
||||
"""Choose a resting template from panel count and aspect ratios (w/h)."""
|
||||
n = len(aspects)
|
||||
if n <= 1:
|
||||
return "centered_wide"
|
||||
if n == 2:
|
||||
if all(a < 0.9 for a in aspects): # two tall panels -> side by side
|
||||
return "vertical_pair"
|
||||
if all(a > 1.15 for a in aspects): # two wide panels -> stacked
|
||||
return "stacked_wides"
|
||||
return "vertical_pair"
|
||||
if n == 3:
|
||||
return "supporting_left_dominant_right"
|
||||
return "quad" # 4 (planner caps callers at 4)
|
||||
|
||||
|
||||
def plan_layout(aspects, rtl=True, active=0, frame=(1080, 1920)):
|
||||
"""Deterministic collage layout for one beat.
|
||||
aspects: panel width/height ratios in reading order (len 1..4).
|
||||
rtl: right-to-left reading (manga) -> reading-first panel takes the RIGHTmost horizontal slot.
|
||||
active: index of the dominant/emphasized panel (gets the largest slot where a template has one).
|
||||
returns dict: template, rects[(x,y,w,h)] aligned to input panel order, entrances[(dx,dy)] pixel
|
||||
offset a panel starts at before sliding to rest, z_order, emphasis, hold_s, transition_s.
|
||||
Rects/entrances are indexed to match the INPUT panel order (not slot order)."""
|
||||
n = len(aspects)
|
||||
if n == 0:
|
||||
return {"template": "empty", "rects": [], "entrances": [], "z_order": [],
|
||||
"emphasis": 0, "hold_s": HOLD_S, "transition_s": TRANS_S}
|
||||
W, H = frame
|
||||
g = int(MARGIN * min(W, H))
|
||||
template = _pick_template(aspects)
|
||||
slots = _slots(template, n, W, H, g)
|
||||
|
||||
# Map input panels (reading order) to slots. Templates whose first slots are a horizontal run
|
||||
# honor RTL by reversing that run so the reading-first panel lands on the right.
|
||||
order = list(range(n))
|
||||
if rtl and template in ("vertical_pair", "quad"):
|
||||
if template == "vertical_pair":
|
||||
order = [1, 0]
|
||||
else: # quad: reverse each row
|
||||
order = [1, 0, 3, 2][:n]
|
||||
# dominant panel takes the dominant slot when the template has a distinguished one (last slot).
|
||||
if template in ("strip_over_dominant", "supporting_left_dominant_right") and 0 <= active < n:
|
||||
rest = [i for i in range(n) if i != active]
|
||||
order = rest + [active] # dominant slot is the last one in _slots order
|
||||
|
||||
rects = [None] * n
|
||||
for slot_i, panel_i in enumerate(order):
|
||||
rects[panel_i] = _fit(aspects[panel_i], slots[slot_i])
|
||||
|
||||
# entrances: reading-direction slide for horizontal templates; dominant scales in place (dy=0,dx=0).
|
||||
edge = W if rtl else -W # RTL panels enter from the right (+x), LTR from left
|
||||
entrances = []
|
||||
for i in range(n):
|
||||
if i == active and template in ("centered_wide", "strip_over_dominant",
|
||||
"supporting_left_dominant_right"):
|
||||
entrances.append((0, 0)) # emphasized panel resolves by scale, not slide
|
||||
elif template == "stacked_wides":
|
||||
entrances.append((0, -H if i == 0 else H)) # rows drop/rise into place
|
||||
else:
|
||||
entrances.append((edge, 0))
|
||||
# supporting panels sit above the dominant in z so their shadow reads; dominant drawn first (back).
|
||||
z_order = sorted(range(n), key=lambda i: 0 if i == active else 1)
|
||||
return {"template": template, "rects": rects, "entrances": entrances, "z_order": z_order,
|
||||
"emphasis": active, "hold_s": HOLD_S, "transition_s": TRANS_S}
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
W, H = 1080, 1920
|
||||
|
||||
def _inside(r):
|
||||
x, y, w, h = r
|
||||
return x >= -1 and y >= -1 and x + w <= W + 1 and y + h <= H + 1
|
||||
|
||||
# 1) single panel -> centered_wide, aspect preserved, inside frame.
|
||||
p = plan_layout([1.5], frame=(W, H))
|
||||
assert p["template"] == "centered_wide" and len(p["rects"]) == 1
|
||||
x, y, w, h = p["rects"][0]
|
||||
assert abs(w / h - 1.5) < 1e-3 and _inside(p["rects"][0])
|
||||
|
||||
# 2) two tall panels -> vertical_pair; RTL puts reading-first (panel 0) on the RIGHT.
|
||||
p = plan_layout([0.6, 0.6], rtl=True, frame=(W, H))
|
||||
assert p["template"] == "vertical_pair"
|
||||
assert p["rects"][0][0] > p["rects"][1][0], "RTL: panel 0 is rightmost"
|
||||
# LTR flips it.
|
||||
q = plan_layout([0.6, 0.6], rtl=False, frame=(W, H))
|
||||
assert q["rects"][0][0] < q["rects"][1][0], "LTR: panel 0 is leftmost"
|
||||
|
||||
# 3) two wide panels -> stacked_wides; panel 0 on top.
|
||||
p = plan_layout([1.6, 1.6], frame=(W, H))
|
||||
assert p["template"] == "stacked_wides" and p["rects"][0][1] < p["rects"][1][1]
|
||||
|
||||
# 4) three panels, active=2 -> dominant takes the large right slot (widest rect).
|
||||
p = plan_layout([0.7, 0.7, 1.3], active=2, frame=(W, H))
|
||||
assert p["template"] == "supporting_left_dominant_right"
|
||||
dom = p["rects"][2][2] * p["rects"][2][3]
|
||||
assert all(dom >= p["rects"][i][2] * p["rects"][i][3] for i in (0, 1)), "active is dominant area"
|
||||
assert all(_inside(r) for r in p["rects"])
|
||||
|
||||
# 5) aspect never stretched: fitted rect ratio == input aspect for every panel/template.
|
||||
for asp in ([1.5], [0.6, 0.6], [1.6, 1.6], [0.7, 0.7, 1.3], [1.0, 1.0, 1.0, 1.0]):
|
||||
pl = plan_layout(asp, frame=(W, H))
|
||||
for a, r in zip(asp, pl["rects"]):
|
||||
assert abs(r[2] / r[3] - a) < 1e-3, (asp, a, r)
|
||||
|
||||
# 6) quad RTL reverses each row; all four rects disjoint-ish (tile the frame).
|
||||
p = plan_layout([1, 1, 1, 1], rtl=True, frame=(W, H))
|
||||
assert p["template"] == "quad" and len(p["rects"]) == 4
|
||||
assert p["rects"][0][0] > p["rects"][1][0], "top row RTL: panel0 right of panel1"
|
||||
|
||||
# 7) entrances: RTL horizontal-slide panels start off the right edge; deterministic.
|
||||
p = plan_layout([0.6, 0.6], rtl=True, frame=(W, H))
|
||||
assert any(dx > 0 for dx, _ in p["entrances"]), "RTL entrance from right"
|
||||
assert plan_layout([0.6, 0.6], frame=(W, H)) == plan_layout([0.6, 0.6], frame=(W, H))
|
||||
|
||||
print("collage self-check ok")
|
||||
Reference in New Issue
Block a user