Fixed video trimming.

Saving CSV together with the reconstructed video.

Author: fnunnari

PostProcessing/PostProcessVideos.py

@@ -6,7 +6,7 @@
 import pandas as pd
 import re
 
-from dataframes import compute_time_range, trim_into_interval
+from dataframes import compute_time_range, trim_repaired_into_interval
 from dataframes import repair_dropped_frames, compute_time_step
 
 from video import extract_frames
@@ -96,23 +96,20 @@ def main(input_dir: Path, output_dir: Path):
     # Find time ranges
     min_common, max_common = compute_time_range(repaired_df_list)
     # Trim the data frames to the time range
-    #trimmed_dataframes = trim_into_interval(repaired_df_list, min_common, max_common, THRESHOLD_NS)
-    # TODO - temp to continue
-    trimmed_dataframes = repaired_df_list
+    trimmed_dataframes = trim_repaired_into_interval(repaired_df_list, min_common, max_common, THRESHOLD_NS)
 
     assert len(clientIDs) == len(trimmed_dataframes), f"Expected {len(clientIDs)} trimmed dataframes. Found f{len(trimmed_dataframes)}"
 
     # Check that all the resulting dataframes have the same number of rows
-    if False:
-        client0ID = clientIDs[0]
-        client0size = len(trimmed_dataframes[0])
-        print(f"For client {client0ID}: {client0size} frames")
-        for cID, df in zip(clientIDs[1:], trimmed_dataframes[1:]):
-            dfsize = len(df)
-            if client0size != dfsize:
-                raise Exception(f"For client {cID}: expecting {client0size}, found {dfsize}")
+    client0ID = clientIDs[0]
+    client0size = len(trimmed_dataframes[0])
+    print(f"For client {client0ID}: {client0size} frames")
+    for cID, df in zip(clientIDs[1:], trimmed_dataframes[1:]):
+        dfsize = len(df)
+        if client0size != dfsize:
+            raise Exception(f"For client {cID}: expecting {client0size} frames, found {dfsize}")
 
-        print("Good. All trimmed dataframes have the same number of entries.")
+    print("Good. All trimmed dataframes have the same number of entries.")
 
     #
     # Unpack the original videos, and repack them according to repaired and trimmed dataframes.
@@ -127,9 +124,12 @@ def main(input_dir: Path, output_dir: Path):
             print(f"Extracting {len(orig_df)} frames from '{video_file}'...")
             extract_frames(video_file=video_file, timestamps_df=orig_df, output_dir=tmp_dir)
 
-            # Reconstruct videos (TODO)
-            out_filepath = output_dir / (cID + ".mp4")
-            rebuild_video(dir=Path(tmp_dir), frames=trimmed_df, outfile=out_filepath)
+            # Reconstruct videos
+            video_out_filepath = output_dir / (cID + ".mp4")
+            rebuild_video(dir=Path(tmp_dir), frames=trimmed_df, outfile=video_out_filepath)
+            # And save also the CSV
+            csv_out_filepath = video_out_filepath.with_suffix(".csv")
+            trimmed_df.to_csv(path_or_buf=csv_out_filepath, header=True, index=False)
 
 
 #

PostProcessing/dataframes.py

@@ -1,7 +1,7 @@
 import pandas as pd
 import numpy as np
 
-from typing import Tuple
+from typing import Tuple, List
 
 
 def compute_time_step(video_timestamps: pd.DataFrame) -> float:
@@ -65,7 +65,7 @@ def repair_dropped_frames(df: pd.DataFrame, time_step: float) -> pd.DataFrame:
     return output_df
 
 
-def save_dataframes(dataframes, prefix='df'):
+def save_dataframes(dataframes, prefix='df') -> None:
     # Generate filenames based on a pattern or numbering scheme
     filenames = [f"{prefix}{i}.csv" for i in range(1, len(dataframes) + 1)]
 
@@ -107,17 +107,17 @@ def compute_time_range(dfs) -> Tuple[int, int]:
 
 
 # Function to trim dataframes based on specified values
-def trim_into_interval(dfs, min_common, max_common, threshold):
-    trimmed_dataframes = []
+def trim_repaired_into_interval(dfs, min_common, max_common, threshold) -> List[pd.DataFrame]:
+
+    trimmed_dataframes: List[pd.DataFrame] = []
+
+    lo_threshold = min_common - threshold
+    hi_threshold = max_common + threshold
+
     for df in dfs:
-        start: pd.DataFrame = df[df.iloc[:, 0].between(min_common-threshold, min_common+threshold, inclusive='both')]
-        end: pd.DataFrame = df[df.iloc[:, 0].between(max_common-threshold, max_common+threshold, inclusive='both')]
-        if not start.empty and not end.empty:
-            df_start = start.stack().iloc[0]
-            df_end = end.stack().iloc[-1]
-            trimmed_df = df[df.iloc[:, 0].between(df_start, df_end, inclusive='both')]
-            trimmed_dataframes.append(trimmed_df)
-        else:
-            raise Exception("No values found within the specified range.")
+
+        selection_mask = df["timestamp"].between(lo_threshold, hi_threshold, inclusive='both')
+        trimmed_df = df[selection_mask]
+        trimmed_dataframes.append(trimmed_df)
 
     return trimmed_dataframes

PostProcessing/video.py

@@ -37,9 +37,6 @@ def video_info(video_path: str) -> Tuple[int, int, int]:
 
 def extract_frames(video_file: str, timestamps_df: pd.DataFrame, output_dir: str):
 
-    #_, _, num_frames = video_info(video_file)
-    #print("NUM:", num_frames, len(timestamps_df))
-
     # Open the video file
     cap = cv2.VideoCapture(video_file)
     if not cap.isOpened():
@@ -50,20 +47,57 @@ def extract_frames(video_file: str, timestamps_df: pd.DataFrame, output_dir: str
 
     # Loop over each timestamp in the CSV file
     for fnum, timestamp in enumerate(timestamps):
-        # Extract the frame using OpenCV
-        #cap.set(cv2.CAP_PROP_POS_MSEC, timestamp * 1000)
+        # Extract the next frame
         ret, frame = cap.read()
         if ret:
             frame_path = os.path.join(output_dir, str(timestamp) + ".jpg")
             cv2.imwrite(frame_path, frame)
+
         else:
             print(f"At frame {fnum}, no more frames to extract from video '{video_file}'. Expected {len(timestamps)} frames.")
-            #raise Exception(f"At frame {fnum}, no more frames to extract from video '{video_file}'. Expected {len(timestamps)} frames.")
-    
+
     # Release the video file
     cap.release()
 
 
+def extract_frames_ffmpeg(video_file: str, timestamps_df: pd.DataFrame, output_dir: str):
+    video_w, video_h, _ = video_info(video_file)
+
+    ffmpeg_read_process = (
+        ffmpeg
+        .input(video_file)
+        .output('pipe:', format='rawvideo', pix_fmt='rgb24')
+        .run_async(pipe_stdout=True)
+    )
+
+    first_col_name = timestamps_df.columns[0]
+    timestamps: pd.Series = timestamps_df[first_col_name]
+
+    # Loop over each timestamp in the CSV file
+    for fnum, timestamp in enumerate(timestamps):
+        in_bytes = ffmpeg_read_process.stdout.read(video_w * video_h * 3)
+        if in_bytes:
+
+            in_frame = (
+                np
+                .frombuffer(in_bytes, np.uint8)
+                .reshape([video_h, video_w, 3])
+            )
+
+            frame_path = os.path.join(output_dir, str(timestamp) + ".jpg")
+            in_frame = cv2.cvtColor(in_frame, cv2.COLOR_RGB2BGR)
+            cv2.imwrite(frame_path, in_frame)
+            #PIL.Image.fromarray(in_frame, 'RGB').save(frame_path)
+
+        else:
+            print(f"At frame {fnum}, no more frames to extract from video '{video_file}'. Expected {len(timestamps)} frames.")
+
+    if ffmpeg_read_process is not None:
+        ffmpeg_read_process.stdout.close()
+        ffmpeg_read_process.wait()
+        ffmpeg_read_process = None
+
+
 def rebuild_video(dir: Path, frames: pd.DataFrame, outfile: Path) -> None:
 
     # We don't know the target video size, yet.
@@ -102,7 +136,6 @@ def rebuild_video(dir: Path, frames: pd.DataFrame, outfile: Path) -> None:
                                                   #x=50, y=50,
                                                   x="(w-tw)/2", y="h-(2*lh)",
                                                   fontfile="Arial.ttf", fontsize=font_width, fontcolor="white",
-                                                  #boxcolor="0x00000099",
                                                   box=1, boxborderw=2, boxcolor="[email protected]")
 
                                         .output(str(outfile), pix_fmt='yuv420p')