simba-uw-tf-dev 4.6.2__py3-none-any.whl → 4.7.2__py3-none-any.whl

simba/utils/yolo.py

@@ -47,6 +47,9 @@ def fit_yolo(weights_path: Union[str, os.PathLike],
        `Download initial weights <https://huggingface.co/Ultralytics>`__.
        `Example model_yaml <https://github.com/sgoldenlab/simba/blob/master/misc/ex_yolo_model.yaml>`__.
 
+    .. seealso::
+       For the recommended wrapper class with parameter validation, see :class:`simba.model.yolo_fit.FitYolo`.
+
     :param initial_weights: Path to the pre-trained YOLO model weights (usually a `.pt` file). Example weights can be found [here](https://huggingface.co/Ultralytics).
     :param model_yaml: YAML file containing paths to the training, validation, and testing datasets and the object class mappings. Example YAML file can be found [here](https://github.com/sgoldenlab/simba/blob/master/misc/ex_yolo_model.yaml).
     :param save_path: Directory path where the trained model, logs, and results will be saved.
@@ -55,7 +58,7 @@ def fit_yolo(weights_path: Union[str, os.PathLike],
     :return: None. The trained model and associated training logs are saved in the specified `project_path`.
 
     :example:
-    >>> fit_yolo(initial_weights=r"C:\troubleshooting\coco_data\weights\yolov8n-obb.pt", data=r"C:\troubleshooting\coco_data\model.yaml", save_path=r"C:\troubleshooting\coco_data\mdl", batch=16)
+    >>> fit_yolo(initial_weights=r"C:/troubleshooting/coco_data/weights/yolov8n-obb.pt", data=r"C:/troubleshooting/coco_data/model.yaml", save_path=r"C:/troubleshooting/coco_data/mdl", batch=16)
     """
 
     if not _is_cuda_available()[0]:
@@ -83,6 +86,9 @@ def load_yolo_model(weights_path: Union[str, os.PathLike],
     """
     Load a YOLO model.
 
+    .. seealso::
+       For recommended wrapper classes that use this function, see :class:`simba.model.yolo_fit.FitYolo`, :class:`simba.model.yolo_inference.YoloInference`, :class:`simba.model.yolo_pose_inference.YOLOPoseInference`, :class:`simba.model.yolo_seg_inference.YOLOSegmentationInference`, and :class:`simba.model.yolo_pose_track_inference.YOLOPoseTrackInference`.
+
     :param Union[str, os.PathLike] weights_path: Path to model weights (.pt, .engine, etc).
     :param bool verbose: Whether to print loading info.
     :param Optional[str] format: Export format, one of VALID_FORMATS or None to skip export.
@@ -169,6 +175,9 @@ def yolo_predict(model: YOLO,
     """
     Produce YOLO predictions.
 
+    .. seealso::
+       For recommended wrapper classes that use this function, see :class:`simba.model.yolo_inference.YoloInference`, :class:`simba.model.yolo_pose_inference.YOLOPoseInference`, and :class:`simba.model.yolo_seg_inference.YOLOSegmentationInference`.
+
     :param Union[str, os.PathLike] model: Loaded ultralytics.YOLO model. Returned by :func:`~simba.bounding_box_tools.yolo.model.load_yolo_model`.
     :param Union[str, os.PathLike, np.ndarray] source: Path to video, video stream, directory, image, or image as loaded array.
     :param bool half: Whether to use half precision (FP16) for inference to speed up processing.

simba/video_processors/blob_tracking_executor.py

@@ -87,9 +87,9 @@ class BlobTrackingExecutor():
     :param bool center: If True, compute center coordinates. Default: True.
 
     :example:
-    >>> tracker = BlobTrackingExecutor(data=r"C:\troubleshooting\mitra\test\.temp\blob_definitions.pickle")
+    >>> tracker = BlobTrackingExecutor(data=r"C:/troubleshooting/mitra/test/.temp/blob_definitions.pickle")
     >>> tracker.run()
-    >>> tracker = BlobTrackingExecutor(data=r"C:\troubleshooting\mitra\test\.temp\blob_definitions.pickle", batch_size=5000)
+    >>> tracker = BlobTrackingExecutor(data=r"C:/troubleshooting/mitra/test/.temp/blob_definitions.pickle", batch_size=5000)
     >>> tracker.run()
     """
 

simba/video_processors/clahe_ui.py

@@ -29,7 +29,7 @@ def interactive_clahe_ui(data: Union[str, os.PathLike]) -> Tuple[float, int]:
     :return Tuple[float, int]: Tuple containing the chosen clip limit and tile size.
 
     :example:
-    >>> video = cv2.imread(r"D:\EPM\sample_2\video_1.mp4")
+    >>> video = cv2.imread(r"D:/EPM/sample_2/video_1.mp4")
     >>> interactive_clahe_ui(data=video)
     """
     global original_img, font_size, x_spacer, y_spacer, txt

simba/video_processors/egocentric_video_rotator.py

@@ -9,10 +9,12 @@ import numpy as np
 from simba.utils.checks import (check_file_exist_and_readable,
                                 check_if_dir_exists, check_if_valid_rgb_tuple,
                                 check_int, check_valid_array,
-                                check_valid_boolean, check_valid_tuple)
+                                check_valid_boolean, check_valid_cpu_pool,
+                                check_valid_tuple)
 from simba.utils.data import (align_target_warpaffine_vectors,
                               center_rotation_warpaffine_vectors,
-                              egocentrically_align_pose)
+                              egocentrically_align_pose, get_cpu_pool,
+                              terminate_cpu_pool)
 from simba.utils.enums import Defaults, Formats
 from simba.utils.printing import SimbaTimer, stdout_success
 from simba.utils.read_write import (concatenate_videos_in_folder,
@@ -92,9 +94,9 @@ class EgocentricVideoRotator():
     :param Optional[Union[str, os.PathLike]] save_path: The location where to store the rotated video. If None, saves the video as the same dir as the input video with the `_rotated` suffix.
 
     :example:
-    >>> DATA_PATH = "C:\501_MA142_Gi_Saline_0513.csv"
-    >>> VIDEO_PATH = "C:\501_MA142_Gi_Saline_0513.mp4"
-    >>> SAVE_PATH = "C:\501_MA142_Gi_Saline_0513_rotated.mp4"
+    >>> DATA_PATH = "C:/501_MA142_Gi_Saline_0513.csv"
+    >>> VIDEO_PATH = "C:/501_MA142_Gi_Saline_0513.mp4"
+    >>> SAVE_PATH = "C:/501_MA142_Gi_Saline_0513_rotated.mp4"
     >>> ANCHOR_LOC = np.array([250, 250])
 
     >>> df = read_df(file_path=DATA_PATH, file_type='csv')
@@ -114,7 +116,8 @@ class EgocentricVideoRotator():
                  fill_clr: Tuple[int, int, int] = (0, 0, 0),
                  core_cnt: int = -1,
                  save_path: Optional[Union[str, os.PathLike]] = None,
-                 gpu: Optional[bool] = True):
+                 gpu: Optional[bool] = True,
+                 pool: bool = None):
 
         check_file_exist_and_readable(file_path=video_path)
         self.video_meta_data = get_video_meta_data(video_path=video_path)
@@ -125,10 +128,14 @@ class EgocentricVideoRotator():
         check_valid_boolean(value=[verbose], source=f'{self.__class__.__name__} verbose')
         check_if_valid_rgb_tuple(data=fill_clr)
         check_int(name=f'{self.__class__.__name__} core_cnt', value=core_cnt, min_value=-1, unaccepted_vals=[0])
-        if core_cnt > find_core_cnt()[0] or core_cnt == -1:
-            self.core_cnt = find_core_cnt()[0]
+        if core_cnt > find_core_cnt()[0] or core_cnt == -1: self.core_cnt = find_core_cnt()[0]
+        else: self.core_cnt = core_cnt
+        if pool is not None:
+            check_valid_cpu_pool(value=pool, source=self.__class__.__name__, max_cores=find_core_cnt()[0], min_cores=2, raise_error=True)
+            self.pool_termination_flag = True
         else:
-            self.core_cnt = core_cnt
+            self.pool_termination_flag = False
+        self.pool = get_cpu_pool(core_cnt=self.core_cnt, source=self.__class__.__name__) if pool is None else pool
         video_dir, self.video_name, _ = get_fn_ext(filepath=video_path)
         if save_path is not None:
             self.save_dir = os.path.dirname(save_path)
@@ -151,39 +158,35 @@ class EgocentricVideoRotator():
         frm_list = np.arange(0, self.video_meta_data['frame_count'])
         frm_list = np.array_split(frm_list, self.core_cnt)
         frm_list = [(cnt, x) for cnt, x in enumerate(frm_list)]
-        if self.verbose:
-            print(f"Creating rotated video {self.video_name}, multiprocessing (chunksize: {1}, cores: {self.core_cnt})...")
-        with multiprocessing.Pool(self.core_cnt, maxtasksperchild=Defaults.LARGE_MAX_TASK_PER_CHILD.value) as pool:
-            constants = functools.partial(egocentric_video_aligner,
-                                          temp_dir=temp_dir,
-                                          video_name=self.video_name,
-                                          video_path=self.video_path,
-                                          centers=self.centers,
-                                          rotation_vectors=self.rotation_vectors,
-                                          target=self.anchor_loc,
-                                          verbose=self.verbose,
-                                          fill_clr=self.fill_clr,
-                                          gpu=self.gpu)
-            for cnt, result in enumerate(pool.imap(constants, frm_list, chunksize=1)):
-                if self.verbose:
-                    print(f"Rotate batch {result}/{self.core_cnt} complete...")
-            pool.terminate()
-            pool.join()
-
+        if self.verbose: print(f"Creating rotated video {self.video_name}, multiprocessing (chunksize: {1}, cores: {self.core_cnt})...")
+
+        constants = functools.partial(egocentric_video_aligner,
+                                      temp_dir=temp_dir,
+                                      video_name=self.video_name,
+                                      video_path=self.video_path,
+                                      centers=self.centers,
+                                      rotation_vectors=self.rotation_vectors,
+                                      target=self.anchor_loc,
+                                      verbose=self.verbose,
+                                      fill_clr=self.fill_clr,
+                                      gpu=self.gpu)
+        for cnt, result in enumerate(self.pool.imap(constants, frm_list, chunksize=1)):
+            if self.verbose: print(f"Rotate batch {result}/{self.core_cnt} complete...")
+        if self.pool_termination_flag: terminate_cpu_pool(pool=self.pool, force=False)
         concatenate_videos_in_folder(in_folder=temp_dir, save_path=self.save_path, remove_splits=True, gpu=self.gpu, verbose=self.verbose)
         video_timer.stop_timer()
         stdout_success(msg=f"Egocentric rotation video {self.save_path} complete", elapsed_time=video_timer.elapsed_time_str, source=self.__class__.__name__)
 
-if __name__ == "__main__":
-    DATA_PATH = r"C:\Users\sroni\OneDrive\Desktop\desktop\rotate_ex\data\501_MA142_Gi_Saline_0513.csv"
-    VIDEO_PATH = r"C:\Users\sroni\OneDrive\Desktop\desktop\rotate_ex\videos\501_MA142_Gi_Saline_0513.mp4"
-    SAVE_PATH = r"C:\Users\sroni\OneDrive\Desktop\desktop\rotate_ex\videos\501_MA142_Gi_Saline_0513_rotated.mp4"
-    ANCHOR_LOC = np.array([250, 250])
-
-    df = read_df(file_path=DATA_PATH, file_type='csv')
-    bp_cols = [x for x in df.columns if not x.endswith('_p')]
-    data = df[bp_cols].values.reshape(len(df), int(len(bp_cols)/2), 2).astype(np.int32)
-
-    _, centers, rotation_vectors = egocentrically_align_pose(data=data, anchor_1_idx=5, anchor_2_idx=2, anchor_location=ANCHOR_LOC, direction=0)
-    rotater = EgocentricVideoRotator(video_path=VIDEO_PATH, centers=centers, rotation_vectors=rotation_vectors, anchor_location=(400, 100), save_path=SAVE_PATH, verbose=True, core_cnt=16)
-    rotater.run()
+# if __name__ == "__main__":
+#     DATA_PATH = r"C:\Users\sroni\OneDrive\Desktop\desktop\rotate_ex\data\501_MA142_Gi_Saline_0513.csv"
+#     VIDEO_PATH = r"C:\Users\sroni\OneDrive\Desktop\desktop\rotate_ex\videos\501_MA142_Gi_Saline_0513.mp4"
+#     SAVE_PATH = r"C:\Users\sroni\OneDrive\Desktop\desktop\rotate_ex\videos\501_MA142_Gi_Saline_0513_rotated.mp4"
+#     ANCHOR_LOC = np.array([250, 250])
+#
+#     df = read_df(file_path=DATA_PATH, file_type='csv')
+#     bp_cols = [x for x in df.columns if not x.endswith('_p')]
+#     data = df[bp_cols].values.reshape(len(df), int(len(bp_cols)/2), 2).astype(np.int32)
+#
+#     _, centers, rotation_vectors = egocentrically_align_pose(data=data, anchor_1_idx=5, anchor_2_idx=2, anchor_location=ANCHOR_LOC, direction=0)
+#     rotater = EgocentricVideoRotator(video_path=VIDEO_PATH, centers=centers, rotation_vectors=rotation_vectors, anchor_location=(400, 100), save_path=SAVE_PATH, verbose=True, core_cnt=16)
+#     rotater.run()

simba/video_processors/multi_cropper.py

@@ -49,7 +49,7 @@ class MultiCropper(object):
 
 
     :example:
-    >>> cropper = MultiCropper(file_type='mp4', input_folder=r'C:\troubleshooting\mitra\test', output_folder=r'C:\troubleshooting\mitra\test\cropped', crop_cnt=2, gpu=True)
+    >>> cropper = MultiCropper(file_type='mp4', input_folder=r'C:/troubleshooting/mitra/test', output_folder=r'C:/troubleshooting/mitra/test/cropped', crop_cnt=2, gpu=True)
     >>> cropper.run()
     """
 

simba/video_processors/video_processing.py

@@ -41,7 +41,7 @@ from simba.utils.checks import (check_ffmpeg_available,
                                 check_valid_boolean, check_valid_codec,
                                 check_valid_cpu_pool, check_valid_lst,
                                 check_valid_tuple)
-from simba.utils.data import (find_frame_numbers_from_time_stamp,
+from simba.utils.data import (find_frame_numbers_from_time_stamp, get_cpu_pool,
                               terminate_cpu_pool)
 from simba.utils.enums import OS, ConfigKey, Defaults, Formats, Options, Paths
 from simba.utils.errors import (CountError, DirectoryExistError,
@@ -52,7 +52,8 @@ from simba.utils.errors import (CountError, DirectoryExistError,
                                 NoDataError, NoFilesFoundError,
                                 NotDirectoryError, ResolutionError,
                                 SimBAGPUError)
-from simba.utils.lookups import (get_ffmpeg_crossfade_methods, get_fonts,
+from simba.utils.lookups import (get_current_time,
+                                 get_ffmpeg_crossfade_methods, get_fonts,
                                  get_named_colors, percent_to_crf_lookup,
                                  percent_to_qv_lk, quality_pct_to_crf,
                                  video_quality_to_preset_lookup)
@@ -408,6 +409,9 @@ def clahe_enhance_video(file_path: Union[str, os.PathLike],
     """
     Convert a single video file to clahe-enhanced greyscale .avi file.
 
+    .. seealso::
+       For multicore method, see :func:`simba.video_processors.video_processing.clahe_enhance_video_mp`.
+
     .. image:: _static/img/clahe_enhance_video.gif
        :width: 800
        :align: center
@@ -490,7 +494,7 @@ def _clahe_enhance_video_mp_helper(data: tuple,
                 img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
             clahe_frm = clahe_filter.apply(img)
             writer.write(clahe_frm)
-            print(f"CLAHE converted frame {current_frm}/{video_meta_data['frame_count']} (core batch: {batch_id}, video name: {video_meta_data['video_name']})...")
+            print(f"[{get_current_time()}] CLAHE converted frame {current_frm}/{video_meta_data['frame_count']} (core batch: {batch_id}, video name: {video_meta_data['video_name']})...")
         else:
             FrameRangeWarning(msg=f'Could not read frame {current_frm} in video {video_meta_data["video_name"]}', source=_clahe_enhance_video_mp_helper.__name__)
             break
@@ -508,10 +512,20 @@ def clahe_enhance_video_mp(file_path: Union[str, os.PathLike],
     """
     Convert a single video file to clahe-enhanced greyscale file using multiprocessing.
 
+    .. seealso::
+       For single core method, see :func:`simba.video_processors.video_processing.clahe_enhance_video`.
+
     .. image:: _static/img/clahe_enhance_video.gif
        :width: 800
        :align: center
 
+    .. csv-table::
+       :header: EXPECTED RUNTIMES
+       :file: ../../docs/tables/clahe_enhance_video_mp.csv
+       :widths: 10, 45, 45
+       :align: center
+       :header-rows: 1
+
     :param Union[str, os.PathLike] file_path: Path to video file.
     :param Optional[int] clip_limit: CLAHE amplification limit. Inccreased clip limit reduce noise in output. Default: 2.
     :param Optional[Tuple[int]] tile_grid_size: The histogram kernel size.
@@ -549,20 +563,20 @@ def clahe_enhance_video_mp(file_path: Union[str, os.PathLike],
     frm_idx = list(range(0, video_meta_data['frame_count']))
     frm_idx = np.array_split(frm_idx, core_cnt)
     frm_idx = [(i, list(j)) for i, j in enumerate(frm_idx)]
-    with multiprocessing.Pool(core_cnt, maxtasksperchild=Defaults.LARGE_MAX_TASK_PER_CHILD.value) as pool:
-        constants = functools.partial(_clahe_enhance_video_mp_helper,
-                                      video_path=file_path,
-                                      clip_limit=clip_limit,
-                                      temp_dir=tempdir,
-                                      tile_grid_size=tile_grid_size)
-        for cnt, result in enumerate(pool.imap(constants, frm_idx, chunksize=1)):
-            print(f'Batch {(result + 1)} / {core_cnt} complete...')
-    pool.terminate()
-    pool.join()
+    pool = get_cpu_pool(core_cnt=core_cnt, maxtasksperchild=Defaults.LARGE_MAX_TASK_PER_CHILD.value, source=clahe_enhance_video_mp.__name__)
+    constants = functools.partial(_clahe_enhance_video_mp_helper,
+                                  video_path=file_path,
+                                  clip_limit=clip_limit,
+                                  temp_dir=tempdir,
+                                  tile_grid_size=tile_grid_size)
+    for cnt, result in enumerate(pool.imap(constants, frm_idx, chunksize=1)):
+        print(f'[{get_current_time()}] Batch {(result + 1)} / {core_cnt} complete...')
+
+    terminate_cpu_pool(pool=pool, force=False, source=clahe_enhance_video_mp.__name__)
     print(f"Joining {video_meta_data['video_name']} multiprocessed video...")
     concatenate_videos_in_folder(in_folder=tempdir, save_path=save_path, remove_splits=True, gpu=gpu)
     video_timer.stop_timer()
-    print(f"CLAHE video {video_meta_data['video_name']} complete (elapsed time: {video_timer.elapsed_time_str}s) ...")
+    print(f"[{get_current_time()}] CLAHE video {video_meta_data['video_name']} complete (elapsed time: {video_timer.elapsed_time_str}s) ...")
 
 
 #_ = clahe_enhance_video_mp(file_path= r"D:\EPM_4\original\1.mp4")
@@ -662,7 +676,7 @@ def change_single_video_fps(file_path: Union[str, os.PathLike],
 
     :param Union[str, os.PathLike] file_path: Path to video file
     :param Union[int, float] fps: FPS of the new video file.
-    :param bool gpu: If True, use NVIDEA GPU codecs. Default False.
+    :param bool gpu: If True, use NVIDEA GPU codecs. Default False. GPU can provide significant speedup (3-4x faster) for FPS conversion, especially for longer videos.
     :param Optional[str] codec: Video codec to use. If None, automatically selects based on file extension (libvpx-vp9 for .webm, mpeg4 for .avi, libx264 for others). Default None.
     :param Optional[Union[str, os.PathLike]] save_path: Path where to save the converted video. If None, saves in the same directory as input file with ``_fps_{fps}`` suffix. Default None.
     :param Optional[int] quality: Video quality (CRF value). Lower values = higher quality. Range 0-52. Default 23.
@@ -688,7 +702,7 @@ def change_single_video_fps(file_path: Union[str, os.PathLike],
     else:
         check_if_dir_exists(in_dir=os.path.dirname(save_path), raise_error=True)
     quality = 23 if not check_int(name='quality', value=quality, min_value=0, max_value=52, raise_error=False)[0] else int(quality)
-    if verbose: print(f"Converting the FPS to {fps} for video {file_name} ...")
+    if verbose: print(f"Converting the FPS {video_meta_data['fps']} -> {fps} for video {file_name} ...")
     if codec is None:
         if ext.lower() == '.webm':
             codec = 'libvpx-vp9'
@@ -699,10 +713,14 @@ def change_single_video_fps(file_path: Union[str, os.PathLike],
     if os.path.isfile(save_path):
         FileExistWarning(msg=f"Overwriting existing file at {save_path}...", source=change_single_video_fps.__name__,)
     if gpu:
-        cmd = f'ffmpeg -hwaccel auto -c:v h264_cuvid -i "{file_path}" -vf "fps={fps}" -c:v h264_nvenc -rc vbr -cq {quality} -c:a copy "{save_path}" -loglevel error -stats -hide_banner -y'
-    else:
+        cmd = f'ffmpeg -hwaccel auto -i "{file_path}" -vf "fps={fps}" -c:v h264_nvenc -preset p4 -cq {quality} -c:a copy "{save_path}" -loglevel error -stats -hide_banner -y'
+        result = subprocess.run(cmd, shell=True)
+        if result.returncode != 0:
+            if verbose: SimBAGPUError(msg=f'FPS convertion ({video_meta_data["fps"]}->{fps}) GPU for video {file_name} failed, using CPU instead...')
+            gpu = False
+    if not gpu:
         cmd = f'ffmpeg -i "{file_path}" -filter:v fps=fps={fps} -c:v {codec} -crf {quality} -c:a aac "{save_path}" -loglevel error -stats -hide_banner -y'
-    subprocess.call(cmd, shell=True)
+        subprocess.call(cmd, shell=True)
     timer.stop_timer()
     if verbose: stdout_success(msg=f'SIMBA COMPLETE: FPS of video {file_name} changed from {str(video_meta_data["fps"])} to {str(fps)} and saved in directory {save_path}', elapsed_time=timer.elapsed_time_str, source=change_single_video_fps.__name__)
 
@@ -711,7 +729,8 @@ def change_fps_of_multiple_videos(path: Union[str, os.PathLike, List[Union[str,
                                   fps: int,
                                   quality: int = 23,
                                   save_dir: Optional[Union[str, os.PathLike]] = None,
-                                  gpu: Optional[bool] = False) -> None:
+                                  gpu: Optional[bool] = False,
+                                  verbose: bool = True) -> None:
     """
     Change the fps of all video files in a folder. Results are stored in the same directory as in the input files with
     the suffix ``_fps_new_fps``.
@@ -721,6 +740,7 @@ def change_fps_of_multiple_videos(path: Union[str, os.PathLike, List[Union[str,
     :param int quality: Video quality (CRF value). Lower values = higher quality. Range 0-52. Default 23.
     :param Optional[Union[str, os.PathLike]] save_dir: If not None, then the directory where to store converted videos. If None, then stores the new videos in the same directory as the input video with the ``_fps_{fps}.file_extension`` suffix.
     :param Optional[bool] gpu: If True, use NVIDEA GPU codecs. Default False.
+    :param bool verbose: If True, prints conversion progress. Default True.
     :returns: None.
 
     :example:
@@ -750,7 +770,7 @@ def change_fps_of_multiple_videos(path: Union[str, os.PathLike, List[Union[str,
         video_meta_data = get_video_meta_data(video_path=file_path)
         if int(fps) == int(video_meta_data["fps"]):
             SameInputAndOutputWarning(msg=f"The new FPS ({fps}) is the same or lower than the original FPS ({video_meta_data['fps']}) for video {file_name}", source=change_fps_of_multiple_videos.__name__)
-        print(f"Converting FPS from {video_meta_data['fps']} to {fps} for {file_name}...")
+        if verbose: print(f"Converting the FPS {video_meta_data['fps']} -> {fps} for video {file_name} ...")
         if save_dir is None:
             save_path = os.path.join(dir_name, file_name + f"_fps_{fps}{ext}")
         else:
@@ -758,15 +778,26 @@ def change_fps_of_multiple_videos(path: Union[str, os.PathLike, List[Union[str,
         if ext.lower() == '.webm': codec = 'libvpx-vp9'
         elif ext.lower() == '.avi': codec = 'mpeg4'
         else: codec = 'libx264'
+        if os.path.isfile(save_path):
+            FileExistWarning(msg=f"Overwriting existing file at {save_path}...", source=change_single_video_fps.__name__, )
+        if gpu:
+            cmd = f'ffmpeg -hwaccel auto -i "{file_path}" -vf "fps={fps}" -c:v h264_nvenc -preset p4 -cq {quality} -c:a copy "{save_path}" -loglevel error -stats -hide_banner -y'
+            result = subprocess.run(cmd, shell=True)
+            if result.returncode != 0:
+                if verbose: SimBAGPUError(msg=f'FPS convertion ({video_meta_data["fps"]}->{fps}) GPU for video {file_name} failed, using CPU instead...')
+                gpu = False
+        if not gpu:
+            cmd = f'ffmpeg -i "{file_path}" -filter:v fps=fps={fps} -c:v {codec} -crf {quality} -c:a aac "{save_path}" -loglevel error -stats -hide_banner -y'
+            subprocess.call(cmd, shell=True)
         if gpu:
             command = f'ffmpeg -hwaccel auto -c:v h264_cuvid -i "{file_path}" -vf "fps={fps}" -c:v h264_nvenc -rc vbr -cq {quality} -c:a copy "{save_path}" -loglevel error -stats -hide_banner -y'
         else:
             command = f'ffmpeg -i "{file_path}" -filter:v fps=fps={fps} -c:v {codec} -crf {quality} -c:a aac "{save_path}" -loglevel error -stats -hide_banner -y'
         subprocess.call(command, shell=True)
         video_timer.stop_timer()
-        print(f"Video {file_name} complete (saved at {save_path})... (elapsed time: {video_timer.elapsed_time_str}s)")
+        if verbose: print(f"Video {file_name} complete (saved at {save_path})... (elapsed time: {video_timer.elapsed_time_str}s)")
     timer.stop_timer()
-    stdout_success(msg=f"SIMBA COMPLETE: FPS of {len(video_paths)} video(s) changed to {fps}", elapsed_time=timer.elapsed_time_str, source=change_fps_of_multiple_videos.__name__,)
+    if verbose: stdout_success(msg=f"SIMBA COMPLETE: FPS of {len(video_paths)} video(s) changed to {fps}", elapsed_time=timer.elapsed_time_str, source=change_fps_of_multiple_videos.__name__,)
 
 
 def convert_video_powerpoint_compatible_format(file_path: Union[str, os.PathLike], gpu: Optional[bool] = False) -> None:
@@ -1102,7 +1133,7 @@ def clip_video_in_range(file_path: Union[str, os.PathLike],
                         end_time: str,
                         out_dir: Optional[Union[str, os.PathLike]] = None,
                         save_path: Optional[Union[str, os.PathLike]] = None,
-                        codec: str = 'libvpx-vp9',
+                        codec: str = 'libx264',
                         quality: int = 60,
                         verbose: bool = True,
                         overwrite: Optional[bool] = False,
@@ -1145,6 +1176,7 @@ def clip_video_in_range(file_path: Union[str, os.PathLike],
     check_if_hhmmss_timestamp_is_valid_part_of_video(timestamp=end_time, video_path=file_path)
     quality = 60 if not check_int(name='quality', value=quality, min_value=0, max_value=100, raise_error=False)[0] else int(quality)
     quality_crf = quality_pct_to_crf(pct=quality)
+    codec = 'libvpx-vp9' if ext.lower() == '.webm' else codec
     if not include_clip_time_in_filename:
         save_name = os.path.join(dir, file_name + "_clipped.mp4")
     else:
@@ -1154,13 +1186,12 @@ def clip_video_in_range(file_path: Union[str, os.PathLike],
         save_name = deepcopy(save_path)
     if os.path.isfile(save_name) and (not overwrite):
         raise FileExistError(msg=f"SIMBA ERROR: The outfile file already exist: {save_name}.", source=clip_video_in_range.__name__)
-
     if gpu:
-        cmd = f'ffmpeg -hwaccel auto -c:v h264_cuvid -i "{file_path}" -ss {start_time} -to {end_time} -async 1 -rc vbr -cq {quality_crf} "{save_name}" -loglevel error -stats -hide_banner -y'
+        cmd = f'ffmpeg -hwaccel auto -c:v h264_cuvid -i "{file_path}" -ss {start_time} -to {end_time} -async 1 -c:v h264_nvenc -rc vbr -cq {quality_crf} "{save_name}" -loglevel error -stats -hide_banner -y'
     else:
         cmd = f'ffmpeg -i "{file_path}" -ss {start_time} -to {end_time} -async 1 -c:v {codec} -crf {quality_crf} "{save_name}" -loglevel error -stats -hide_banner -y'
     if verbose: print(f"Clipping video {file_name} between {start_time} and {end_time}... ")
-    subprocess.call(cmd, shell=True, stdout=subprocess.PIPE)
+    subprocess.call(cmd, shell=True)
     timer.stop_timer()
     if verbose: stdout_success(msg=f"Video converted! {save_name} generated!", elapsed_time=timer.elapsed_time_str, source=clip_video_in_range.__name__)
 
@@ -3857,6 +3888,18 @@ def create_average_frm(video_path: Union[str, os.PathLike],
     """
     Create an image representing the average frame of a segment in a video or an entire video.
 
+    .. seealso::
+       See :func:`simba.data_processors.cuda.image.create_average_frm_cupy`, :func:`simba.data_processors.cuda.image.create_average_frm_cuda` for GPU acceleration.
+       This one appears quicker than the GPU implementations...
+
+    .. csv-table::
+       :header: EXPECTED RUNTIMES
+       :file: ../../docs/tables/create_average_frame.csv
+       :widths: 10, 45, 45
+       :align: center
+       :class: simba-table
+       :header-rows: 1
+
     .. video:: _static/img/create_average_frm_1.webm
        :width: 800
        :autoplay:
@@ -3882,10 +3925,6 @@ def create_average_frm(video_path: Union[str, os.PathLike],
        Either pass ``start_frm`` and ``end_frm`` OR ``start_time`` and ``end_time`` OR pass all four arguments as None.
        If all are None, then the entire video will be used to create the average frame.
 
-    .. seealso:
-       See :func:`simba.data_processors.cuda.image.create_average_frm_cupy`, :func:`simba.data_processors.cuda.image.create_average_frm_cuda` for GPU acceleration.
-       This one appears quicker than the GPU implementations...
-
     :param Union[str, os.PathLike] video_path: The path to the video to create the average frame from. Default: None.
     :param Optional[int] start_frm: The first frame in the segment to create the average frame from. Default: None.
     :param Optional[int] end_frm: The last frame in the segment to create the average frame from. Default: None.
@@ -4844,8 +4883,7 @@ def get_video_slic(video_path: Union[str, os.PathLike],
                                       sigma=sigma)
         for cnt, core_batch in enumerate(pool.map(constants, frm_ranges, chunksize=1)):
             print(f'Core batch {core_batch} complete...')
-    pool.join()
-    pool.terminate()
+    terminate_cpu_pool(pool=pool, force=False)
     timer.stop_timer()
     concatenate_videos_in_folder(in_folder=temp_folder, save_path=save_path)
     stdout_success(msg=f'SLIC video saved at {save_path}', elapsed_time=timer.elapsed_time_str)
@@ -5159,6 +5197,10 @@ def change_playback_speed_dir(data_dir: Union[str, os.PathLike],
 
 
 
+
+#x = create_average_frm(video_path=r"D:\troubleshooting\mitra\project_folder\videos\average_cpu_test\20min.mp4", verbose=True)
+
+
 #change_playback_speed_dir(data_dir=r'E:\open_video\barnes_maze\test', speed=5)
 
 

simba/video_processors/videos_to_frames.py

@@ -6,17 +6,17 @@ except:
     from typing_extensions import Literal
 
 import functools
-import multiprocessing
 import os
+from datetime import datetime
 
 import cv2
 
 from simba.utils.checks import (check_if_dir_exists, check_int, check_str,
                                 check_valid_boolean)
+from simba.utils.data import get_cpu_pool, terminate_cpu_pool
 from simba.utils.printing import SimbaTimer, stdout_success
-from simba.utils.read_write import (find_core_cnt, get_video_meta_data,
-                                    read_frm_of_video)
-from simba.utils.data import terminate_cpu_pool
+from simba.utils.read_write import (find_core_cnt, get_fn_ext,
+                                    get_video_meta_data, read_frm_of_video)
 
 JPEG, PNG, WEBP = 'jpeg', 'png', 'webp'
 
@@ -40,7 +40,7 @@ def _video_to_frms_helper(img_batch: Tuple[int, List[int]],
         else:
             save_path = os.path.join(save_dir, f'{frm_idx}.{img_format}')
         if verbose:
-            print(f"Saving image {save_path} ...")
+            print(f"Saving image {save_path} ({frm_idx}/{video_meta_data['frame_count']})...")
         img = read_frm_of_video(video_path=cap, frame_index=frm_idx, greyscale=greyscale, clahe=clahe, black_and_white=black_and_white)
         if img_format == WEBP:
             cv2.imwrite(save_path, img, [cv2.IMWRITE_WEBP_QUALITY, quality])
@@ -51,7 +51,7 @@ def _video_to_frms_helper(img_batch: Tuple[int, List[int]],
     return batch_cnt
 
 def video_to_frames(video_path: Union[str, os.PathLike],
-                    save_dir: Union[str, os.PathLike],
+                    save_dir: Optional[Union[str, os.PathLike]] = None,
                     quality: Optional[int] = 95,
                     img_format: Literal['png', 'webp'] = 'png',
                     verbose: bool = True,
@@ -61,10 +61,16 @@ def video_to_frames(video_path: Union[str, os.PathLike],
                     black_and_white: bool = False,
                     include_video_name_in_filename: bool = True):
 
-
     """
     Extract all frames from a video file and save them as individual image files.
 
+    .. csv-table::
+       :header: EXPECTED RUNTIMES
+       :file: ../../docs/tables/video_to_frames.csv
+       :widths: 10, 45, 45
+       :align: center
+       :header-rows: 1
+
     .. note::
        Uses multiprocessing for faster frame extraction. Frames are saved with sequential numbering (0, 1, 2, ...).
 
@@ -81,8 +87,8 @@ def video_to_frames(video_path: Union[str, os.PathLike],
     :return: None. Frames are saved to disk in the specified directory.
 
     :example:
-    >>> video_to_frames(video_path=r"C:\troubleshooting\SDS_pre_post\project_folder\videos\SDI100 x ALR2 post_d7.mp4", 
-    ...                save_dir=r'C:\troubleshooting\SDS_pre_post\project_folder\videos\test', 
+    >>> video_to_frames(video_path=r"C:/troubleshooting/SDS_pre_post/project_folder/videos/SDI100 x ALR2 post_d7.mp4", 
+    ...                save_dir=r'C:/troubleshooting/SDS_pre_post/project_folder/videos/test', 
     ...                black_and_white=False, 
     ...                verbose=True, 
     ...                img_format='webp', 
@@ -91,7 +97,11 @@ def video_to_frames(video_path: Union[str, os.PathLike],
 
     timer = SimbaTimer(start=True)
     video_meta_data = get_video_meta_data(video_path=video_path)
-    check_if_dir_exists(in_dir=save_dir, source=video_to_frames.__name__, raise_error=True)
+    if save_dir is not None:
+        check_if_dir_exists(in_dir=save_dir, source=video_to_frames.__name__, raise_error=True)
+    else:
+        save_dir = os.path.join(get_fn_ext(filepath=video_path)[0], f'{video_meta_data["video_name"]}_frames_{datetime.now().strftime("%Y%m%d%H%M%S")}')
+        os.makedirs(save_dir)
     check_valid_boolean(value=verbose, source=f'{video_to_frames.__name__} verbose')
     check_valid_boolean(value=clahe, source=f'{video_to_frames.__name__} clahe')
     check_valid_boolean(value=greyscale, source=f'{video_to_frames.__name__} greyscale')
@@ -99,35 +109,35 @@ def video_to_frames(video_path: Union[str, os.PathLike],
     check_valid_boolean(value=include_video_name_in_filename, source=f'{video_to_frames.__name__} include_video_name_in_filename')
     check_int(name=f'{video_to_frames.__name__} core_cnt', value=core_cnt, min_value=-1, unaccepted_vals=[0], raise_error=True)
     check_int(name=f'{video_to_frames.__name__} quality', value=quality, min_value=1, max_value=100, raise_error=True)
-    core_cnt = find_core_cnt()[0] if core_cnt -1 or core_cnt > find_core_cnt()[0] else core_cnt
+    core_cnt = find_core_cnt()[0] if core_cnt == -1 or core_cnt > find_core_cnt()[0] else core_cnt
     check_str(name=f'{video_to_frames.__name__} img_format', value=img_format, options=('jpeg', 'png', 'webp'))
     frm_ids = list(range(0, video_meta_data['frame_count']))
     frm_ids = [frm_ids[i * len(frm_ids) // core_cnt: (i + 1) * len(frm_ids) // core_cnt] for i in range(core_cnt)]
     frm_ids = [(i, j) for i, j in enumerate(frm_ids)]
-    with multiprocessing.Pool(core_cnt, maxtasksperchild=100) as pool:
-        constants = functools.partial(_video_to_frms_helper,
-                                          verbose=verbose,
-                                          img_format=img_format,
-                                          quality=quality,
-                                          greyscale=greyscale,
-                                          black_and_white=black_and_white,
-                                          include_video_name_in_filename=include_video_name_in_filename,
-                                          video_path=video_path,
-                                          clahe=clahe,
-                                          save_dir=save_dir)
-        for cnt, batch_id in enumerate(pool.imap(constants, frm_ids, chunksize=1)):
-            if verbose:
-                print(f'Video frame batch {batch_id} (of {core_cnt}) complete...')
-
-    terminate_cpu_pool(pool=pool, force=True)
+    pool = get_cpu_pool(core_cnt=core_cnt, source=video_to_frames.__name__)
+    constants = functools.partial(_video_to_frms_helper,
+                                      verbose=verbose,
+                                      img_format=img_format,
+                                      quality=quality,
+                                      greyscale=greyscale,
+                                      black_and_white=black_and_white,
+                                      include_video_name_in_filename=include_video_name_in_filename,
+                                      video_path=video_path,
+                                      clahe=clahe,
+                                      save_dir=save_dir)
+    for cnt, batch_id in enumerate(pool.imap(constants, frm_ids, chunksize=1)):
+        if verbose:
+            print(f'Video frame batch {batch_id} (of {core_cnt}) complete...')
+
+    terminate_cpu_pool(pool=pool, force=True, source=video_to_frames.__name__)
     timer.stop_timer()
-    if verbose:
-        stdout_success(msg=f'All frames for video {video_path} saved in {save_dir}', elapsed_time=timer.elapsed_time_str)
+    if verbose: stdout_success(msg=f'All frames ({video_meta_data["frame_count"]}) for video {video_path} saved in {save_dir}', elapsed_time=timer.elapsed_time_str)
 
 # if __name__ == "__main__":
-#     video_to_frames(video_path=r"C:\troubleshooting\SDS_pre_post\project_folder\videos\SDI100 x ALR2 post_d7.mp4",
-#                     save_dir=r'C:\troubleshooting\SDS_pre_post\project_folder\videos\test',
+#     video_to_frames(video_path=r"D:\troubleshooting\mitra\project_folder\videos\average_cpu_test\15min.mp4",
+#                     save_dir=None,
 #                     black_and_white=False,
 #                     verbose=True,
-#                     img_format='webp',
-#                     clahe=True)
+#                     img_format='png',
+#                     clahe=False,
+#                     core_cnt=18)

{simba_uw_tf_dev-4.6.2.dist-info → simba_uw_tf_dev-4.7.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba-uw-tf-dev
-Version: 4.6.2
+Version: 4.7.2
 Summary: Toolkit for computer classification and analysis of behaviors in experimental animals
 Home-page: https://github.com/sgoldenlab/simba
 Author: Simon Nilsson, Jia Jie Choong, Sophia Hwang
@@ -79,7 +79,7 @@ Requires-Dist: yellowbrick (==1.5.0) ; python_version >= "3.9"
 Requires-Dist: kaleido ; python_version >= "3.9"
 Requires-Dist: psutil ; python_version >= "3.9"
 Requires-Dist: h5py (==3.11.0) ; python_version >= "3.9"
-Requires-Dist: numba (==0.59.1) ; python_version >= "3.9"
+Requires-Dist: numba (==0.63.1) ; python_version >= "3.9"
 Requires-Dist: numexpr (==2.10.0) ; python_version >= "3.9"
 Requires-Dist: statsmodels (==0.14.2) ; python_version >= "3.9"
 Requires-Dist: shap (==0.42.0) ; python_version >= "3.9"
@@ -138,11 +138,12 @@ Requires-Dist: numexpr (==2.10.0) ; (python_version >= "3.9") and extra == 'arm'
 Requires-Dist: statsmodels (==0.14.2) ; (python_version >= "3.9") and extra == 'arm'
 Requires-Dist: tables (==3.9.2) ; (python_version >= "3.9") and extra == 'arm'
 Provides-Extra: gpu
-Requires-Dist: cupy-cuda12x (==13.3.0) ; extra == 'gpu'
+Requires-Dist: cupy-cuda12x (>=13.6.0) ; extra == 'gpu'
 Requires-Dist: shap (==0.46.1.dev78) ; extra == 'gpu'
 Requires-Dist: cuml-cu12 (==24.12.0) ; extra == 'gpu'
 Requires-Dist: torch (==2.5.0) ; extra == 'gpu'
 Requires-Dist: ultralytics (==8.3.156) ; extra == 'gpu'
+Requires-Dist: nvidia-cuda-runtime-cu12 ; extra == 'gpu'
 
 # SimBA (Simple Behavioral Analysis)
 ![SimBA Splash](https://raw.githubusercontent.com/sgoldenlab/simba/master/docs/tutorials_rst/img/index/landing_page_1.png)