editing tracker

full_tracked_output.mp4

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0a40a50c5a05f63a00cefd584874fa87e2346d89d6e5c40f5065c2000af0453f
-size 1343470
+oid sha256:d2279854fb8576c214c8c149b62a085ae6fd17407d51cde7be57d8ae6a016b9d
+size 1421621

mask_output.mp4

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7fa9d49423d0da4aad10d35e12f8b1f672d27607dbf2c9a9d64bf526b66afc12
-size 363292
+oid sha256:d606f04cd29d4d71677020403774296c6cfbaf6b9151423eef8f982eecf2bf6f
+size 432686

stabilized_mask_output.mp4

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:36201117ba3818d6d3356312485bc62a64a0f7f709dd9fbdbb1f9e856465a48c
-size 953497
+oid sha256:9d6392f0c333a98e46aa72e81651cc9785bb0360db1b55c25d7485f34bb542a8
+size 1009136

track-pixels_gradio.py

@@ -449,16 +449,49 @@ REVERSED_INPUT = "/app/reversed_input.mp4"
 # === VIDEO UTILITIES =====================================
 # ==========================================================
 
+# def reverse_video(input_path, output_path):
+#     cap = cv2.VideoCapture(input_path)
+#     if not cap.isOpened():
+#         raise FileNotFoundError(f"❌ Could not open video: {input_path}")
+    
+#     fps = cap.get(cv2.CAP_PROP_FPS)
+#     width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+#     height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+#     fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+#     out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+
+#     frames = []
+#     while True:
+#         ret, frame = cap.read()
+#         if not ret:
+#             break
+#         frames.append(frame)
+#     cap.release()
+
+#     for frame in reversed(frames):
+#         out.write(frame)
+#     out.release()
+#     print(f"🔁 Video reversed and saved: {output_path}")
+#     return output_path
+
+# def reverse_video_file_inplace(path_in):
+#     tmp_path = path_in.replace(".mp4", "_tmp.mp4")
+#     reverse_video(path_in, tmp_path)
+#     os.replace(tmp_path, path_in)
+
 def reverse_video(input_path, output_path):
+    """
+    Reverse frames robustly — preserves all readable frames
+    even if OpenCV metadata is off by one.
+    """
     cap = cv2.VideoCapture(input_path)
     if not cap.isOpened():
         raise FileNotFoundError(f"❌ Could not open video: {input_path}")
-    
+
     fps = cap.get(cv2.CAP_PROP_FPS)
     width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
     height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
     fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
 
     frames = []
     while True:
@@ -468,16 +501,27 @@ def reverse_video(input_path, output_path):
         frames.append(frame)
     cap.release()
 
+    if len(frames) == 0:
+        raise ValueError("No frames read from video!")
+
+    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
     for frame in reversed(frames):
         out.write(frame)
     out.release()
-    print(f"🔁 Video reversed and saved: {output_path}")
+    cv2.destroyAllWindows()
+
+    print(f"✅ Reversed {len(frames)} frames → {output_path}")
     return output_path
 
+
 def reverse_video_file_inplace(path_in):
+    """
+    Reverse a video in-place without losing frames.
+    """
     tmp_path = path_in.replace(".mp4", "_tmp.mp4")
     reverse_video(path_in, tmp_path)
     os.replace(tmp_path, path_in)
+    print(f"🔁 Overwrote {path_in} with reversed version (same frame count).")
 
 # ==========================================================
 # === RAFT LOADING =========================================
@@ -642,20 +686,145 @@ def stabilize_black_regions(input_video):
 # === TRACKING =============================================
 # ==========================================================
 
+# def run_tracking(video_path, mask_path, selection_mode="All Pixels"):
+#     BLACK_THRESH = 1
+#     HISTORY_LEN = 5
+
+#     reversed_path = reverse_video(video_path, REVERSED_INPUT)
+#     cap = cv2.VideoCapture(reversed_path)
+#     model = load_raft_model(MODEL_PATH)
+
+#     fps = cap.get(cv2.CAP_PROP_FPS)
+#     ret, first_frame = cap.read()
+#     if not ret:
+#         return "❌ Could not read first frame.", None, None, None
+#     H, W = first_frame.shape[:2]
+
+#     x0, y0, x1, y1 = compute_crop_box_from_mask_dynamic(first_frame, mask_path, pad=200)
+#     cw, ch = x1 - x0, y1 - y0
+
+#     fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+#     out_vis = cv2.VideoWriter(OUTPUT_VIDEO, fourcc, fps, (W, H))
+#     out_mask = cv2.VideoWriter(OUTPUT_MASK_VIDEO, fourcc, fps, (W, H), isColor=False)
+
+#     full_mask = cv2.imread(mask_path, cv2.IMREAD_GRAYSCALE)
+#     full_mask = cv2.resize(full_mask, (W, H), interpolation=cv2.INTER_NEAREST)
+#     crop_mask = full_mask[y0:y1, x0:x1]
+
+#     if selection_mode == "All Pixels":
+#         ys, xs = np.where(crop_mask > 0)
+#     else:
+#         gray_first = cv2.cvtColor(first_frame, cv2.COLOR_BGR2GRAY)
+#         black_pixels = (gray_first[y0:y1, x0:x1] < BLACK_THRESH)
+#         combined = (crop_mask > 0) & black_pixels
+#         ys, xs = np.where(combined)
+
+#     tracked_points = np.vstack((xs, ys)).T.astype(np.float32)
+#     prev_full_rgb = cv2.cvtColor(first_frame, cv2.COLOR_BGR2RGB)
+#     prev_crop_rgb = prev_full_rgb[y0:y1, x0:x1]
+
+#     history = deque([True]*HISTORY_LEN, maxlen=HISTORY_LEN)
+#     stopped = False
+
+#     frame_idx = 0
+#     while True:
+#         ret, curr_frame = cap.read()
+#         if not ret:
+#             break
+#         frame_idx += 1
+#         curr_full_rgb = cv2.cvtColor(curr_frame, cv2.COLOR_BGR2RGB)
+#         curr_crop_rgb = curr_full_rgb[y0:y1, x0:x1]
+#         gray_crop = cv2.cvtColor(curr_crop_rgb, cv2.COLOR_RGB2GRAY)
+
+#         flow_crop = compute_flow(model, prev_crop_rgb, curr_crop_rgb)
+
+#         vis_full = curr_full_rgb.copy()
+#         mask_full = np.full((H, W), 255, dtype=np.uint8)
+
+#         new_points = []
+#         for pt in tracked_points:
+#             px, py = int(pt[0]), int(pt[1])
+#             if 0 <= px < cw and 0 <= py < ch:
+#                 dx, dy = flow_crop[py, px]
+#                 nx, ny = pt[0] + dx, pt[1] + dy
+#                 nx = np.clip(nx, 0, cw-1)
+#                 ny = np.clip(ny, 0, ch-1)
+#                 new_points.append([nx, ny])
+#         tracked_points = np.array(new_points, dtype=np.float32)
+
+#         black_mask = gray_crop < BLACK_THRESH
+#         black_indices = tracked_points.astype(int)
+#         has_black = any(
+#             0 <= px < cw and 0 <= py < ch and black_mask[py, px]
+#             for px, py in black_indices
+#         )
+#         history.append(has_black)
+
+#         if stopped:
+#             paint = False
+#         elif has_black:
+#             paint = True
+#         elif not any(history):
+#             stopped = True
+#             paint = False
+#         else:
+#             paint = True
+
+#         if paint:
+#             for pt in tracked_points:
+#                 fx, fy = int(pt[0] + x0), int(pt[1] + y0)
+#                 if 0 <= fx < W and 0 <= fy < H:
+#                     cv2.circle(vis_full, (fx, fy), 1, (0,255,0), -1)
+#                     mask_full[fy, fx] = 0
+
+#         out_vis.write(cv2.cvtColor(vis_full, cv2.COLOR_RGB2BGR))
+#         out_mask.write(mask_full)
+#         prev_crop_rgb = curr_crop_rgb
+
+#         if frame_idx % 10 == 0:
+#             print(f"Frame {frame_idx}: {'PAINT' if paint else 'NO-PAINT'} | has_black={has_black} | stopped={stopped}")
+
+#     cap.release()
+#     out_vis.release()
+#     out_mask.release()
+
+#     stabilize_black_regions(OUTPUT_MASK_VIDEO)
+
+#     reverse_video_file_inplace(OUTPUT_VIDEO)
+#     reverse_video_file_inplace(OUTPUT_MASK_VIDEO)
+#     reverse_video_file_inplace(STABILIZED_MASK)
+
+#     return (
+#         f"✅ Tracking complete ({selection_mode}).\n"
+#         f"Square Crop {cw}x{ch} @ ({x0},{y0}) with padding=100\n"
+#         f"Painting stopped={'Yes' if stopped else 'No'} after {frame_idx} frames.\n"
+#         "Saved outputs reversed back to forward order.",
+#         OUTPUT_VIDEO,
+#         OUTPUT_MASK_VIDEO,
+#         STABILIZED_MASK
+#     )
+
+
+
 def run_tracking(video_path, mask_path, selection_mode="All Pixels"):
     BLACK_THRESH = 1
     HISTORY_LEN = 5
 
+    # --- Reverse input for backward tracking ---
     reversed_path = reverse_video(video_path, REVERSED_INPUT)
     cap = cv2.VideoCapture(reversed_path)
     model = load_raft_model(MODEL_PATH)
 
     fps = cap.get(cv2.CAP_PROP_FPS)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    print(f"🎞️ Input video: {total_frames} frames at {fps:.2f} FPS")
+
     ret, first_frame = cap.read()
     if not ret:
         return "❌ Could not read first frame.", None, None, None
     H, W = first_frame.shape[:2]
 
+    # --- Compute dynamic square crop from mask ---
     x0, y0, x1, y1 = compute_crop_box_from_mask_dynamic(first_frame, mask_path, pad=200)
     cw, ch = x1 - x0, y1 - y0
 
@@ -681,8 +850,10 @@ def run_tracking(video_path, mask_path, selection_mode="All Pixels"):
 
     history = deque([True]*HISTORY_LEN, maxlen=HISTORY_LEN)
     stopped = False
-
     frame_idx = 0
+    curr_full_rgb = None
+
+    # === Main tracking loop ===
     while True:
         ret, curr_frame = cap.read()
         if not ret:
@@ -692,11 +863,13 @@ def run_tracking(video_path, mask_path, selection_mode="All Pixels"):
         curr_crop_rgb = curr_full_rgb[y0:y1, x0:x1]
         gray_crop = cv2.cvtColor(curr_crop_rgb, cv2.COLOR_RGB2GRAY)
 
+        # --- Optical flow between prev and curr ---
         flow_crop = compute_flow(model, prev_crop_rgb, curr_crop_rgb)
 
         vis_full = curr_full_rgb.copy()
         mask_full = np.full((H, W), 255, dtype=np.uint8)
 
+        # --- Move tracked points ---
         new_points = []
         for pt in tracked_points:
             px, py = int(pt[0]), int(pt[1])
@@ -708,6 +881,7 @@ def run_tracking(video_path, mask_path, selection_mode="All Pixels"):
                 new_points.append([nx, ny])
         tracked_points = np.array(new_points, dtype=np.float32)
 
+        # --- Detect black pixels ---
         black_mask = gray_crop < BLACK_THRESH
         black_indices = tracked_points.astype(int)
         has_black = any(
@@ -716,16 +890,18 @@ def run_tracking(video_path, mask_path, selection_mode="All Pixels"):
         )
         history.append(has_black)
 
+        # --- Painting logic ---
         if stopped:
             paint = False
         elif has_black:
             paint = True
-        elif not any(history):
+        elif not any(history):  # last N all False
             stopped = True
             paint = False
         else:
             paint = True
 
+        # --- Paint or skip ---
         if paint:
             for pt in tracked_points:
                 fx, fy = int(pt[0] + x0), int(pt[1] + y0)
@@ -740,21 +916,37 @@ def run_tracking(video_path, mask_path, selection_mode="All Pixels"):
         if frame_idx % 10 == 0:
             print(f"Frame {frame_idx}: {'PAINT' if paint else 'NO-PAINT'} | has_black={has_black} | stopped={stopped}")
 
+    # === Add final static frame to preserve frame count ===
+    try:
+        if curr_full_rgb is not None:
+            out_vis.write(cv2.cvtColor(curr_full_rgb, cv2.COLOR_RGB2BGR))
+            out_mask.write(mask_full)
+            print("🧩 Added final frame to preserve total frame count.")
+    except Exception as e:
+        print(f"⚠️ Could not add final frame: {e}")
+
     cap.release()
     out_vis.release()
     out_mask.release()
 
+    # === Post-process: stabilization + reversal ===
     stabilize_black_regions(OUTPUT_MASK_VIDEO)
-
     reverse_video_file_inplace(OUTPUT_VIDEO)
     reverse_video_file_inplace(OUTPUT_MASK_VIDEO)
     reverse_video_file_inplace(STABILIZED_MASK)
 
+    # === Verify output frame counts ===
+    for path in [OUTPUT_VIDEO, OUTPUT_MASK_VIDEO, STABILIZED_MASK]:
+        cap_test = cv2.VideoCapture(path)
+        n = int(cap_test.get(cv2.CAP_PROP_FRAME_COUNT))
+        cap_test.release()
+        print(f"✅ Verified {os.path.basename(path)} → {n} frames")
+
     return (
         f"✅ Tracking complete ({selection_mode}).\n"
-        f"Square Crop {cw}x{ch} @ ({x0},{y0}) with padding=100\n"
-        f"Painting stopped={'Yes' if stopped else 'No'} after {frame_idx} frames.\n"
-        "Saved outputs reversed back to forward order.",
+        f"Square Crop {cw}x{ch} @ ({x0},{y0}) with padding=200\n"
+        f"Painting stopped={'Yes' if stopped else 'No'} after {frame_idx} processed frames.\n"
+        f"All outputs now match input frame count ({total_frames}).",
         OUTPUT_VIDEO,
         OUTPUT_MASK_VIDEO,
         STABILIZED_MASK
@@ -818,4 +1010,4 @@ def build_app():
 
 if __name__ == "__main__":
     app = build_app()
-    app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
+    app.launch(server_name="0.0.0.0", server_port=7861, debug=True)