detection

detect_loops.py

@@ -2,12 +2,34 @@ import cv2
 import numpy as np
 from pathlib import Path
 from PIL import Image
-import time
 import json
 
 shots_dir = Path('data/shots')
 files = sorted(shots_dir.glob('sample-*.webp'))
-    
+
+def sigmoid(x):
+    return 1 / (1 + np.exp(-x))
+
+def evaluate_length_penalty(len, mag = 0.0045):
+    """Length penalty function based on sigmoid curves."""
+    x = len
+    y = mag + -mag * sigmoid(0.58 * (x - 1.5)) + 0.25 * mag * sigmoid(2 * (x - 17))    
+    return y
+
+# Two sigmoids — one dips around x=2, one rises around x=16
+import matplotlib.pyplot as plt
+x = np.linspace(0, 40, 400)
+y = evaluate_length_penalty(x)
+plt.plot(x, y, 'k', lw=3)
+plt.axvline(2, color='k', lw=2)
+plt.axvline(16, color='k', lw=2)
+plt.text(0, -0.06, '0', ha='center', va='top', fontsize=12)
+plt.text(2, -0.06, '2', ha='center', va='top', fontsize=12)
+plt.text(16, -0.06, '16', ha='center', va='top', fontsize=12)
+# save the plot into length_penalty_plot.png
+plt.savefig('length_penalty_plot.png')
+plt.close()
+
 def extract_frames(webp_path):
     frames = []
     with Image.open(webp_path) as im:
@@ -32,12 +54,12 @@ def compute_sim(f1, f2):
     cos_sim = np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2) + eps)
     return cos_sim
 
-def detect_loops(frames, min_len=6, max_len=40, top_k=3):
+def detect_loops(frames, min_len=2, max_len=40, top_k=10):
     n = len(frames)
     candidates = []
-    # Preprocess frames: grayscale float32 and downscale to 32x32 (float32)
+    # Preprocess frames: grayscale float32 and downscale to 128x128 (float32)
     processed_frames = [
-        cv2.resize(cv2.cvtColor(f, cv2.COLOR_BGR2GRAY).astype(np.float32), (32, 32), interpolation=cv2.INTER_AREA)
+        cv2.resize(cv2.cvtColor(f, cv2.COLOR_BGR2GRAY).astype(np.float32), (128, 128), interpolation=cv2.INTER_AREA)
         for f in frames
     ]
     # Build 3-channel composite frames: R=prev, G=curr, B=next (looping)
@@ -53,15 +75,14 @@ def detect_loops(frames, min_len=6, max_len=40, top_k=3):
         composite_frames.append(composite)
     for i in range(n):
         for j in range(i+min_len, min(i+max_len, n)):
-            t0 = time.time()
             # Compare composite frames directly
             start_comp = composite_frames[i].astype(np.float32)
             end_comp = composite_frames[j].astype(np.float32)
             cos_sim = compute_sim(start_comp, end_comp)
-            t1 = time.time()
-            score = cos_sim  # Higher cosine similarity is better
+            length_penalty = evaluate_length_penalty(j - i)
+            score = cos_sim - length_penalty  # Higher cosine similarity is better
             # print(f"Loop ({i},{j}): Cosine similarity={cos_sim:.4f} (t={t1-t0:.3f}s)")
-            candidates.append((score, i, j, cos_sim))
+            candidates.append((score, i, j, cos_sim, length_penalty))
     # Sort by score descending
     candidates.sort(reverse=True)
     return candidates[:top_k]
@@ -89,20 +110,22 @@ if __name__ == "__main__":
         print(f"Extracted {len(frames)} frames from {webp_path}")
         loops = detect_loops(frames)
         loop_json = []
-        for score, i, j, cos_sim in loops:
+        for score, i, j, cos_sim, len_penalty in loops:
             loop_json.append({
                 "start": int(i),
                 "end": int(j),
                 "score": float(score),
-                "cos_sim": float(cos_sim)
+                "cos_sim": float(cos_sim),
+                "length": int(j - i),
+                "length_penalty": float(len_penalty)
             })
         json_name = f"{webp_path.stem}.loop.json"
         json_path = output_dir / json_name
         with open(json_path, "w") as f:
             json.dump(loop_json, f, indent=2)
         print(f"Saved loop candidates: {json_path}")
-        for idx, (score, i, j, cos_sim) in enumerate(loops):
-            print(f"Loop candidate: start={i}, end={j}, score={score:.4f}, COS_SIM={cos_sim:.4f}")
+        for idx, (score, i, j, cos_sim, len_penalty) in enumerate(loops):
+            print(f"Loop candidate: start={i}, end={j}, score={score:.6f}, COS_SIM={cos_sim:.6f}, LEN={int(j - i)}, LEN_PENALTY={len_penalty:.6f}")
             if idx != 0:
                 continue  # For now, only save the top candidate
             # Extract loop frames (seamless looping: frames[i:j])