Adds rerun timelapse preview with brightness thresholding.

previews/041/composite.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b08f25875abcea892b11133651a2fbb0f549af7e22c51acaa209d48aa2c0c088
+size 225181744

previews/041/galvo.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cfe94971f66a9bdd46a4bf7e15f8b0c71f65788d16043dd21f93790a146df824
+size 6418940

previews/041/thermal.mp4

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9bfe39130ad0dd20ec6cebf0f7ecd516096b095ea109d258d52bd42f3f8889b7
-size 310378544
+oid sha256:8377f08d39ca245d797065c62bd1c9f3dc63b5735d52f028f36bf6bae2aace9c
+size 532242896

scripts/previews/02_timelapse.py

@@ -32,7 +32,7 @@ import sys
 from pathlib import Path
 
 import pyarrow.parquet as pq
-from PIL import Image
+from PIL import Image, ImageStat
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
 from _lib import DATA_DIR
@@ -50,6 +50,15 @@ LAYER_QUANTIZE_UM  = 100                    # z2 bucket size in microns
 GIF_PANEL_HEIGHT   = 240                    # panel height in pixels for GIF canvas
 BATCH_ROWS         = 1000                   # pyarrow streaming batch size
 
+# Halogen brightness filter — applies to chamber frames only.
+# The halogens pulse on/off throughout a build; dark frames (halogens off) are
+# uninformative for viewing. A frame is kept if its mean grayscale brightness is
+# at least this fraction of the brightest frame seen in the same build.
+# For the individual chamber GIF dark frames are dropped entirely; for the
+# composite they are forward-filled from the last bright frame so thermal/galvo
+# stay in layer-sync.
+CHAMBER_BRIGHTNESS_RATIO = 0.25
+
 
 # ---------------------------------------------------------------------------
 # Image helpers (mirrors 01_render.py exactly)
@@ -89,6 +98,18 @@ def _placeholder(canvas_w: int) -> Image.Image:
     return Image.new("RGB", (canvas_w, GIF_PANEL_HEIGHT), (20, 20, 20))
 
 
+def _mean_brightness(img: Image.Image) -> float:
+    """Mean grayscale pixel value 0–255 (uses PIL ImageStat, no numpy)."""
+    return ImageStat.Stat(img.convert("L")).mean[0]
+
+
+def _chamber_threshold(decoded_frames: list[Image.Image | None]) -> float:
+    """Return the brightness threshold for a build's chamber frames.
+    25 % of the brightest frame seen; 0 if no frames (no filtering applied)."""
+    brightnesses = [_mean_brightness(f) for f in decoded_frames if f is not None]
+    return max(brightnesses) * CHAMBER_BRIGHTNESS_RATIO if brightnesses else 0.0
+
+
 def _canvas_width_from_bytes(b: bytes, kind: str) -> int:
     """Decode one frame to determine the locked canvas width for this kind."""
     img = _decode_raw(b, kind)
@@ -218,30 +239,64 @@ def _write_gif(frames: list[Image.Image], out_path: Path) -> None:
 # ---------------------------------------------------------------------------
 
 def render_timelapse_kind(parquet_path: Path, kind: str, out_path: Path) -> int:
-    """Write timelapse_{kind}.gif. Returns number of GIF frames written."""
+    """Write timelapse_{kind}.gif. Returns number of GIF frames written.
+
+    Chamber only: dark frames (halogens off) are dropped entirely so the GIF
+    shows only moments where the part is visible. Thermal and galvo are
+    unaffected — they don't depend on halogen lighting.
+    """
     layer_bytes = collect_layer_bytes(parquet_path, kind)
     if not layer_bytes:
         print(f"  {kind:8s}: no printing-phase frames (z2 > 0), skipping")
         return 0
 
-    sorted_levels  = sorted(layer_bytes)
-    target_levels  = _subsample(sorted_levels)
-    fill_bytes     = _forward_fill(layer_bytes, target_levels)
-    canvas_w       = _canvas_width_from_bytes(next(b for b in fill_bytes if b), kind)
-
-    pil_frames: list[Image.Image] = []
-    for b in fill_bytes:
-        img = _decode_raw(b, kind) if b else None
-        pil_frames.append(
-            _fit_to_canvas(img, canvas_w) if img else _placeholder(canvas_w)
+    sorted_levels = sorted(layer_bytes)
+    target_levels = _subsample(sorted_levels)
+    fill_bytes    = _forward_fill(layer_bytes, target_levels)
+    canvas_w      = _canvas_width_from_bytes(next(b for b in fill_bytes if b), kind)
+
+    # Decode all selected frames up front (needed for brightness scan on chamber).
+    decoded = [_decode_raw(b, kind) if b else None for b in fill_bytes]
+
+    if kind == "chamber":
+        # Compute brightness once per decoded frame, then threshold and filter.
+        brightnesses = [_mean_brightness(img) if img is not None else None
+                        for img in decoded]
+        threshold = _chamber_threshold(decoded)
+        pil_frames = [
+            _fit_to_canvas(img, canvas_w)
+            for img, b in zip(decoded, brightnesses)
+            if img is not None and b is not None and b >= threshold
+        ]
+        dark_dropped = sum(
+            1 for img, b in zip(decoded, brightnesses)
+            if img is not None and b is not None and b < threshold
         )
+        if dark_dropped:
+            print(f"  {kind:8s}: dropped {dark_dropped} dark frames "
+                  f"(threshold {threshold:.1f}/255)")
+    else:
+        pil_frames = [
+            _fit_to_canvas(img, canvas_w) if img else _placeholder(canvas_w)
+            for img in decoded
+        ]
+
+    if not pil_frames:
+        print(f"  {kind:8s}: no frames survived brightness filter, skipping")
+        return 0
 
     _write_gif(pil_frames, out_path)
     return len(pil_frames)
 
 
 def render_timelapse_composite(parquet_path: Path, out_path: Path) -> int:
-    """Write timelapse_composite.gif (1×3 panel). Single parquet pass."""
+    """Write timelapse_composite.gif (1×3 panel). Single parquet pass.
+
+    Thermal and galvo show the actual frame for every layer (unaffected by
+    halogens). The chamber panel forward-fills from the last *bright* frame
+    when the current layer's chamber frame is dark — this keeps all three
+    panels in layer-sync while never displaying a dark chamber view.
+    """
     all_bytes = collect_all_kinds(parquet_path)
 
     all_levels = sorted(set().union(*(set(d) for d in all_bytes.values())))
@@ -260,16 +315,34 @@ def render_timelapse_composite(parquet_path: Path, out_path: Path) -> int:
         )
     total_w = sum(canvas_widths.values())
 
+    # Pre-decode chamber frames once; compute adaptive brightness threshold.
+    chamber_decoded = [
+        _decode_raw(b, "chamber") if b else None
+        for b in fill_per_kind["chamber"]
+    ]
+    chamber_threshold = _chamber_threshold(chamber_decoded)
+
+    last_bright_chamber: Image.Image | None = None
     pil_frames: list[Image.Image] = []
     for i in range(len(target_levels)):
         composite = Image.new("RGB", (total_w, GIF_PANEL_HEIGHT), (20, 20, 20))
         x = 0
         for kind in FRAME_KINDS:
-            b   = fill_per_kind[kind][i]
-            img = _decode_raw(b, kind) if b else None
+            if kind == "chamber":
+                img = chamber_decoded[i]
+                # Update the running bright-chamber reference when this frame is bright.
+                if img is not None and _mean_brightness(img) >= chamber_threshold:
+                    last_bright_chamber = img
+                # Always use the last bright frame (forward-fill); placeholder until
+                # the first bright frame arrives.
+                panel_img = last_bright_chamber
+            else:
+                b = fill_per_kind[kind][i]
+                panel_img = _decode_raw(b, kind) if b else None
+
             panel = (
-                _fit_to_canvas(img, canvas_widths[kind])
-                if img else _placeholder(canvas_widths[kind])
+                _fit_to_canvas(panel_img, canvas_widths[kind])
+                if panel_img else _placeholder(canvas_widths[kind])
             )
             composite.paste(panel, (x, 0))
             x += canvas_widths[kind]