Upload 2 files

watermark/video.py

@@ -205,7 +205,26 @@ def process_video(
     skip = max(1, int(detection_skip))
     print(f"[Video] Detection interval: every {skip} frame(s)")
 
-    work = Path(tempfile.mkdtemp(prefix="wm_video_v3_"))
+    # ------------------------------------------------------------
+    # V4 detection strategy
+    # ------------------------------------------------------------
+    # We keep the cheap periodic Florence scan, but when a watermark is
+    # detected for the first time in a sampling interval, we immediately
+    # scan the preceding frames in that interval. This recovers the actual
+    # appearance frame instead of waiting until the next sampled frame.
+    #
+    # Example with skip=5:
+    #   sampled: 0,5,10,15...
+    #   watermark appears at 7
+    #   frame 10 is detected -> retrospectively scan 6,7,8,9
+    #   first positive frame becomes 7
+    #
+    # This is much cheaper than running Florence on every video frame and
+    # fixes the user's "watermark exists at the beginning, then disappears"
+    # symptom without creating a watermark before it actually appears.
+    # ------------------------------------------------------------
+
+    work = Path(tempfile.mkdtemp(prefix="wm_video_v4_"))
     input_dir = work / "input"
     output_dir = work / "output"
     input_dir.mkdir(parents=True, exist_ok=True)
@@ -214,11 +233,30 @@ def process_video(
     detections = {}
     cap = None
 
+    def detect_frame(frame_index, frame):
+        """Run Florence on one BGR frame and cache the result."""
+        if frame_index in detections:
+            return detections[frame_index]
+
+        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        image = Image.fromarray(rgb)
+        boxes = _valid_boxes(_boxes(image, detection_prompt))
+        detections[frame_index] = boxes
+
+        print(
+            f"[Florence] Frame {frame_index}: "
+            f"{len(boxes)} bounding box(es)"
+        )
+        return boxes
+
     try:
         # ========================================================
-        # Phase 1: extract frames + Florence detection
+        # Phase 1: extract frames + periodic Florence detection
         # ========================================================
-        print("[Video] Phase 1: extracting frames and detecting watermarks...")
+        print(
+            "[Video] Phase 1: extracting frames and detecting watermarks..."
+        )
+
         cap = cv2.VideoCapture(video_path)
         if not cap.isOpened():
             raise ValueError("Unable to reopen uploaded video.")
@@ -238,19 +276,74 @@ def process_video(
             if not saved:
                 raise RuntimeError(f"Failed to save frame {frame_index}.")
 
+            # Periodic detection.
             if frame_index % skip == 0:
-                rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                image = Image.fromarray(rgb)
-                boxes = _valid_boxes(
-                    _boxes(image, detection_prompt)
-                )
-                detections[frame_index] = boxes
                 print(
-                    f"[Florence] Frame {frame_index}: "
-                    f"{len(boxes)} bounding box(es)"
+                    f"[Florence] Detecting sampled frame "
+                    f"{frame_index}/{total}"
+                )
+                sampled_boxes = detect_frame(frame_index, frame)
+
+                # ------------------------------------------------
+                # BACKWARD LOOKUP
+                # ------------------------------------------------
+                # Only back-scan when the previous sampled frame was
+                # negative. If the previous sample was already positive,
+                # the watermark is known to be present and another full
+                # interval scan would waste ZeroGPU time.
+                # ------------------------------------------------
+                previous_sample = frame_index - skip
+                previous_boxes = (
+                    detections.get(previous_sample, [])
+                    if previous_sample >= 0
+                    else []
                 )
 
+                if (
+                    sampled_boxes
+                    and skip > 1
+                    and not previous_boxes
+                ):
+                    start = max(0, frame_index - skip)
+
+                    print(
+                        f"[Video] Positive detection at frame {frame_index}; "
+                        f"back-scanning frames {start}-{frame_index - 1} "
+                        "to locate watermark onset..."
+                    )
+
+                    # Read only the preceding frames from disk. We have
+                    # already written every frame above, so no second video
+                    # decode pass is required.
+                    first_positive = None
+                    for candidate in range(start, frame_index):
+                        candidate_path = (
+                            input_dir / f"{candidate:08d}.png"
+                        )
+                        candidate_bgr = cv2.imread(
+                            str(candidate_path),
+                            cv2.IMREAD_COLOR,
+                        )
+                        if candidate_bgr is None:
+                            continue
+
+                        candidate_boxes = detect_frame(
+                            candidate,
+                            candidate_bgr,
+                        )
+
+                        if candidate_boxes:
+                            first_positive = candidate
+                            break
+
+                    if first_positive is not None:
+                        print(
+                            f"[Video] Watermark onset located at frame "
+                            f"{first_positive} ({first_positive / max(fps, 1):.3f}s)."
+                        )
+
             frame_index += 1
+
             _update_progress(
                 progress,
                 0.35 * frame_index / max(1, total),
@@ -264,16 +357,75 @@ def process_video(
             raise ValueError("The uploaded video contains no readable frames.")
 
         print(f"[Video] Extracted {frame_index} frames.")
-        print(f"[Video] Detection samples: {len(detections)}")
+        print(f"[Video] Florence detections cached: {len(detections)}")
 
         # ========================================================
-        # Phase 2: build temporal detection track
+        # Phase 2: build exact per-frame detection track
         # ========================================================
         print("[Video] Phase 2: building per-frame watermark tracks...")
-        per_frame_boxes = _build_per_frame_detections(
-            detections,
-            frame_index,
-        )
+
+        detection_keys = sorted(detections.keys())
+        per_frame_boxes = {}
+
+        # The detection dictionary now contains extra frames around the
+        # first appearance of each sampled positive interval. We still use
+        # the conservative V3 temporal rules so a negative interval does not
+        # leak a previous watermark backward into frames where it was absent.
+        for i in range(frame_index):
+            if i in detections:
+                per_frame_boxes[i] = _valid_boxes(detections[i])
+                continue
+
+            prev_key = None
+            next_key = None
+
+            # Find nearest known samples on each side.
+            for key in detection_keys:
+                if key < i:
+                    prev_key = key
+                elif key > i:
+                    next_key = key
+                    break
+
+            # Nothing detected yet -> keep original frame.
+            if prev_key is None:
+                per_frame_boxes[i] = []
+                continue
+
+            prev_boxes = _valid_boxes(detections.get(prev_key, []))
+
+            # No future sample -> keep the last known state.
+            if next_key is None:
+                per_frame_boxes[i] = prev_boxes
+                continue
+
+            next_boxes = _valid_boxes(detections.get(next_key, []))
+
+            # Positive -> negative transition: only carry the old box to
+            # the midpoint. This prevents a stale watermark from persisting
+            # long after it disappeared.
+            if prev_boxes and not next_boxes:
+                midpoint = (prev_key + next_key) / 2.0
+                per_frame_boxes[i] = (
+                    prev_boxes if i <= midpoint else []
+                )
+                continue
+
+            # Negative -> positive transition: do not remove anything before
+            # the first known positive frame. This is the key fix for the
+            # user's original problem.
+            if not prev_boxes and next_boxes:
+                per_frame_boxes[i] = []
+                continue
+
+            # Both sides positive -> interpolate box movement.
+            per_frame_boxes[i] = _interpolate_boxes(
+                prev_boxes,
+                prev_key,
+                next_boxes,
+                next_key,
+                i,
+            )
 
         # ========================================================
         # Phase 3: LaMa inpainting
@@ -294,7 +446,6 @@ def process_video(
                     max_bbox_percent,
                 )
 
-                # Avoid calling LaMa when the filtered mask is empty.
                 if np.asarray(mask, dtype=np.uint8).any():
                     result = _lama(
                         image,