don't know

detect_loops.py

@@ -16,28 +16,48 @@ def extract_frames(webp_path):
             pass
     return frames
 
-def compute_flow_magnitude(f1, f2):
-    prev = cv2.cvtColor(f1, cv2.COLOR_BGR2GRAY)
-    curr = cv2.cvtColor(f2, cv2.COLOR_BGR2GRAY)
-    flow = cv2.calcOpticalFlowFarneback(prev, curr, None, 0.5, 3, 15, 3, 5, 1.2, 0)
-    mag, _ = cv2.cartToPolar(flow[...,0], flow[...,1])
-    return np.mean(mag)
 
-def compute_ssim(f1, f2):
-    # Convert to grayscale for SSIM
-    g1 = cv2.cvtColor(f1, cv2.COLOR_BGR2GRAY)
-    g2 = cv2.cvtColor(f2, cv2.COLOR_BGR2GRAY)
-    return ssim(g1, g2)
+
+def compute_sim(f1, f2):
+    # f1 and f2 are already grayscale and downscaled
+    mse = np.mean((f1.astype(np.float32) - f2.astype(np.float32)) ** 2)
+    return mse
 
 def detect_loops(frames, min_len=6, max_len=40, top_k=3):
+    import time
     n = len(frames)
     candidates = []
+    composite_window = 3
+    # Preprocess frames: grayscale float32 and downscale to 32x32 (float32)
+    processed_frames = [
+        cv2.resize(cv2.cvtColor(f, cv2.COLOR_BGR2GRAY).astype(np.float32), (32, 32), interpolation=cv2.INTER_AREA)
+        for f in frames
+    ]
+    # Build 3-channel composite frames: R=prev, G=curr, B=next (looping)
+    n = len(processed_frames)
+    composite_frames = []
+    for idx in range(n):
+        prev_idx = (idx - 1) % n
+        next_idx = (idx + 1) % n
+        r = processed_frames[prev_idx]
+        g = processed_frames[idx]
+        b = processed_frames[next_idx]
+        composite = np.stack([r, g, b], axis=-1)
+        composite_frames.append(composite)
     for i in range(n):
         for j in range(i+min_len, min(i+max_len, n)):
-            sim = compute_ssim(frames[i], frames[j])
-            flow = compute_flow_magnitude(frames[i], frames[j])
-            score = sim - flow  # Higher is better
-            candidates.append((score, i, j, sim, flow))
+            t0 = time.time()
+            # Composite start: average composite frames i, i+1, ..., i+composite_window-1
+            start_idxs = range(i, min(i+composite_window, n))
+            end_idxs = range(max(j-composite_window+1, i), j+1)
+            start_comp = np.mean([composite_frames[idx].astype(np.float32) for idx in start_idxs], axis=0)
+            end_comp = np.mean([composite_frames[idx].astype(np.float32) for idx in end_idxs], axis=0)
+            # No uint8 conversion; keep float32 for MSE
+            sim = compute_sim(start_comp, end_comp)
+            t1 = time.time()
+            score = -sim  # Lower MSE is better, so negate for sorting
+            print(f"Loop ({i},{j}): Composite MSE={sim:.1f} (t={t1-t0:.3f}s)")
+            candidates.append((score, i, j, sim))
     # Sort by score descending
     candidates.sort(reverse=True)
     return candidates[:top_k]
@@ -60,15 +80,46 @@ if __name__ == "__main__":
     output_dir = Path('data/loops')
     output_dir.mkdir(parents=True, exist_ok=True)
 
+    # import matplotlib.pyplot as plt
     for webp_path in files:
         print(f"Processing {webp_path}")
         frames = extract_frames(webp_path)
         print(f"Extracted {len(frames)} frames from {webp_path}")
+        # # Show composite image for first frame (3-channel: R=prev, G=curr, B=next)
+        # processed_frames = [cv2.resize(cv2.cvtColor(f, cv2.COLOR_BGR2GRAY), (64, 64), interpolation=cv2.INTER_AREA) for f in frames]
+        # n = len(processed_frames)
+        # if n > 0:
+        #     prev_idx = (0 - 1) % n
+        #     next_idx = (0 + 1) % n
+        #     r = processed_frames[prev_idx]
+        #     g = processed_frames[0]
+        #     b = processed_frames[next_idx]
+        #     composite = np.stack([r, g, b], axis=-1)
+        #     plt.imshow(composite)
+        #     plt.title('Composite: R=prev, G=curr, B=next (grayscale, downscaled)')
+        #     plt.axis('off')
+        #     plt.show()
+        # Unindent following code to match main block
         loops = detect_loops(frames)
-        for idx, (score, i, j, sim, flow) in enumerate(loops):
-            print(f"Loop candidate: start={i}, end={j}, score={score:.3f}, SSIM={sim:.3f}, flow={flow:.3f}")
-            # Extract loop frames
-            loop_frames = frames[i:j+1]
+        # Save all candidates and their scores to JSON
+        import json
+        loop_json = []
+        for score, i, j, sim in loops:
+            loop_json.append({
+                "start": int(i),
+                "end": int(j),
+                "score": float(score),
+                "sim": float(sim)
+            })
+        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, sim) in enumerate(loops):
+            print(f"Loop candidate: start={i}, end={j}, score={score:.3f}, SIM={sim:.3f}")
+            # Extract loop frames (seamless looping: frames[i:j])
+            loop_frames = frames[i:j]
             # Convert BGR (OpenCV) to RGB for PIL
             pil_frames = [Image.fromarray(cv2.cvtColor(f, cv2.COLOR_BGR2RGB)) for f in loop_frames]
             # Save as animated webp