stuff

data/animations/sample-000.json

@@ -0,0 +1,5 @@
+{
+  "scene_change_indices": [
+    40
+  ]
+}

detect_scene.py

@@ -2,7 +2,13 @@ import torch
 import numpy as np
 from pathlib import Path
 from transnetv2_pytorch import TransNetV2
+import json
+import re
 
+SCENE_CUT_THRESHOLD = 0.09
+data_dir = Path("data/animations")
+files = sorted(data_dir.glob("sample-000.webp"))
+    
 def get_best_device():
     if torch.cuda.is_available():
         return torch.device("cuda")
@@ -12,39 +18,110 @@ def get_best_device():
     else:
         return torch.device("cpu")
 
-device = get_best_device()
-print(f"Using device: {device}")
-model = TransNetV2()
-state_dict = torch.load("transnetv2-pytorch-weights.pth")
-model.load_state_dict(state_dict)
-# model.eval().cuda()
-model.eval().to(device)
-
-# # Sample Code from the original repo
-# with torch.no_grad():
-#     # shape: batch dim x video frames x frame height x frame width x RGB (not BGR) channels
-#     input_video = torch.zeros(1, 100, 27, 48, 3, dtype=torch.uint8)
-#     # single_frame_pred, all_frame_pred = model(input_video.cuda())
-#     single_frame_pred, all_frame_pred = model(input_video)
-    
-#     single_frame_pred = torch.sigmoid(single_frame_pred).cpu().numpy()
-#     all_frame_pred = torch.sigmoid(all_frame_pred["many_hot"]).cpu().numpy()
-    
-#     # plot results
-#     import matplotlib.pyplot as plt
-#     plt.figure(figsize=(12, 4))
-#     plt.subplot(1, 2, 1)
-#     plt.title("Single Frame Predictions")
-#     plt.plot(single_frame_pred[0])
-#     plt.subplot(1, 2, 2)
-#     plt.title("All Frame Predictions")
-#     plt.imshow(all_frame_pred[0].T, aspect="auto", cmap="gray")
-#     plt.show()
-#     # plt.savefig("test_output.png")
-
-# Load sample-*.webp files (each file is an animated webp files with ~120 frames) 
-# from data/animations folder then run detection.
+def save_prediction_plot(single_frame_pred, original_frames, filename, interval=5, title=None):
+    """
+    Save a plot of single frame predictions with thumbnails annotated at regular intervals.
+    """
+    import matplotlib.pyplot as plt
+    from matplotlib.offsetbox import OffsetImage, AnnotationBbox
+    import numpy as np
+
+    plt.figure(figsize=(12, 4))
+    if title:
+        plt.title(title)
+    plt.plot(single_frame_pred)
+    ax = plt.gca()
+    # Add thumbnails at regular intervals
+    for idx in range(0, len(original_frames), interval):
+        thumb = original_frames[idx].resize((64, 64))
+        imagebox = OffsetImage(np.array(thumb), zoom=0.5)
+        ab = AnnotationBbox(imagebox, (idx, single_frame_pred[idx]), frameon=False, box_alignment=(0.5, -0.1))
+        ax.add_artist(ab)
+    plt.xlabel("Frame")
+    plt.ylabel("Prediction")
+    plt.tight_layout()
+    plt.savefig(filename)
+    plt.close()
+
+def load_original_frames(filepath):
+    """Load original frames from an animated webp file as PIL Images."""
+    from PIL import Image
+    im = Image.open(filepath)
+    frames = []
+    try:
+        while True:
+            frames.append(im.convert("RGB"))
+            im.seek(im.tell() + 1)
+    except EOFError:
+        pass
+    return frames
+
+def save_timeline_jpg(frames, scene_change_indices, filename, interval=5, roi_radius=2, title=None):
+    """
+    Save a timeline JPG with thumbnails every `interval` frames and every frame near scene changes.
+    Scene change regions are highlighted. Each thumbnail is annotated with its frame index.
+    """
+    import matplotlib.pyplot as plt
+    from matplotlib.offsetbox import OffsetImage, AnnotationBbox
+    import matplotlib.patches as mpatches
+    import numpy as np
+
+    # Determine frames to render
+    frames_to_render = set(range(0, len(frames), interval))
+    for idx in scene_change_indices:
+        for offset in range(-roi_radius, roi_radius+1):
+            fidx = idx + offset
+            if 0 <= fidx < len(frames):
+                frames_to_render.add(fidx)
+    frames_to_render = sorted(frames_to_render)
 
+    # Map frames to evenly spaced positions
+    n = len(frames_to_render)
+    x_positions = list(range(n))
+
+    fig, ax = plt.subplots(figsize=(max(8, n*0.5), 3))
+    ax.set_xlim(-1, n)
+    ax.set_ylim(0, 1)
+    ax.axis('off')
+
+    # Highlight scene change regions
+    for idx in scene_change_indices:
+        region = [i for i, fidx in enumerate(frames_to_render) if abs(fidx-idx) <= roi_radius]
+        if region:
+            start, end = region[0], region[-1]
+            rect = mpatches.Rectangle((start-0.5, 0.05), end-start+1, 0.9, color='yellow', alpha=0.2)
+            ax.add_patch(rect)
+
+    # Prepare sets for quick lookup
+    last_frames = set(scene_change_indices)
+    first_frames = set(idx + 1 for idx in scene_change_indices if idx + 1 < len(frames))
+
+    # Draw thumbnails and annotate
+    for i, fidx in enumerate(frames_to_render):
+        thumb = frames[fidx].resize((32, 32))
+        imagebox = OffsetImage(np.array(thumb), zoom=0.7)
+        # Determine border color
+        if fidx in last_frames:
+            bboxprops = dict(edgecolor='red', linewidth=2, boxstyle='round,pad=0.2')
+        elif fidx in first_frames:
+            bboxprops = dict(edgecolor='green', linewidth=2, boxstyle='round,pad=0.2')
+        else:
+            bboxprops = None
+        ab = AnnotationBbox(
+            imagebox,
+            (x_positions[i], 0.6),
+            frameon=True,
+            box_alignment=(0.5, 0.5),
+            bboxprops=bboxprops
+        )
+        ax.add_artist(ab)
+        ax.text(x_positions[i], 0.25, str(fidx), ha='center', va='center', fontsize=9, color='black', bbox=dict(facecolor='white', edgecolor='none', alpha=0.8, boxstyle='round,pad=0.2'))
+
+    if title:
+        ax.text(0, 0.95, title, fontsize=12, ha='left', va='top', color='navy')
+    plt.tight_layout()
+    plt.savefig(filename, dpi=150)
+    plt.close(fig)
 
 def load_webp_animation(filepath):
     from PIL import Image
@@ -70,7 +147,7 @@ def detect_scene_changes(filepath):
         single_frame_pred = torch.sigmoid(single_frame_pred).cpu().numpy()[0]
         all_frame_pred_np = torch.sigmoid(all_frame_pred["many_hot"]).cpu().numpy()[0]
     # Get frame indices where scene changes occur (threshold at 0.5)
-    scene_change_indices = [i for i, p in enumerate(single_frame_pred) if p >= 0.5]
+    scene_change_indices = [i for i, p in enumerate(single_frame_pred) if p >= SCENE_CUT_THRESHOLD]
     return {
         "single_frame_pred": single_frame_pred,
         "all_frame_pred": all_frame_pred_np,
@@ -78,49 +155,39 @@ def detect_scene_changes(filepath):
         "num_frames": video_tensor.shape[1]
     }
 
-data_dir = Path("data/animations")
-
-# Get all sample-*.webp files
-files = sorted(data_dir.glob("sample-000.webp"))
-
-import matplotlib.pyplot as plt
-import re
-
-for file in files:
-    result = detect_scene_changes(file)
-    # Extract sample number from filename
-    match = re.search(r"sample-(\d+)", file.name)
-    sample_num = match.group(1) if match else "unknown"
-    plot_filename = file.parent / f"sample-{sample_num}.plot.jpg"
-
-    # Load original frames for thumbnails
-    from PIL import Image
-    im = Image.open(file)
-    original_frames = []
-    try:
-        while True:
-            original_frames.append(im.convert("RGB"))
-            im.seek(im.tell() + 1)
-    except EOFError:
-        pass
-
-    import matplotlib.pyplot as plt
-    from matplotlib.offsetbox import OffsetImage, AnnotationBbox
-
-    plt.figure(figsize=(12, 4))
-    plt.title(f"Single Frame Predictions: {file.name}")
-    plt.plot(result["single_frame_pred"])
-    ax = plt.gca()
-    # Add thumbnails at regular intervals (e.g., every 20 frames)
-    interval = 5
-    for idx in range(0, len(original_frames), interval):
-        thumb = original_frames[idx].resize((64, 64))
-        imagebox = OffsetImage(np.array(thumb), zoom=0.5)
-        ab = AnnotationBbox(imagebox, (idx, result["single_frame_pred"][idx]), frameon=False, box_alignment=(0.5, -0.1))
-        ax.add_artist(ab)
-    plt.xlabel("Frame")
-    plt.ylabel("Prediction")
-    plt.tight_layout()
-    plt.savefig(plot_filename)
-    plt.close()
+if __name__ == "__main__":
+    device = get_best_device()
+    print(f"Using device: {device}")
+    model = TransNetV2()
+    state_dict = torch.load("transnetv2-pytorch-weights.pth")
+    model.load_state_dict(state_dict)
+    model.eval().to(device)
+    for file in files:
+        match = re.search(r"sample-(\d+)", file.name)
+        sample_num = match.group(1) if match else "unknown"
+        result = detect_scene_changes(file)
+        # Save results to JSON
+        json_filename = file.parent / f"sample-{sample_num}.json"
+        with open(json_filename, "w") as f:
+            json.dump({"scene_change_indices": result["scene_change_indices"]}, f, indent=2)
+        # Save timeline JPG
+        timeline_filename = file.parent / f"sample-{sample_num}.timeline.jpg"
+        plot_filename = file.parent / f"sample-{sample_num}.plot.jpg"
+        original_frames = load_original_frames(file)
+        save_timeline_jpg(
+            frames=original_frames,
+            scene_change_indices=result["scene_change_indices"],
+            filename=timeline_filename,
+            interval=5,
+            roi_radius=2,
+            title=f"Timeline: {file.name}"
+        )
+        # Save prediction plot with thumbnails
+        save_prediction_plot(
+            single_frame_pred=result["single_frame_pred"],
+            original_frames=original_frames,
+            filename=plot_filename,
+            interval=5,
+            title=f"Single Frame Predictions: {file.name}"
+        )