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

simba/ui/tkinter_functions.py

@@ -156,6 +156,7 @@ class SimBAScaleBar(Frame):
     def __init__(self,
                  parent: Union[Frame, Canvas, LabelFrame, Toplevel, Tk],
                  label: Optional[str] = None,
+                 label_width: Optional[int] = None,
                  orient: Literal['horizontal', 'vertical'] = HORIZONTAL,
                  length: int = 200,
                  value: Optional[int] = 95,
@@ -194,7 +195,7 @@ class SimBAScaleBar(Frame):
                            showvalue=showvalue)
 
         if label is not None:
-            self.lbl = SimBALabel(parent=self, txt=label, font=lbl_font, txt_clr=label_clr)
+            self.lbl = SimBALabel(parent=self, txt=label, font=lbl_font, txt_clr=label_clr, width=label_width)
             self.lbl.grid(row=0, column=1, sticky=SW)
 
         self.scale.grid(row=0, column=2, sticky=NW)
@@ -207,6 +208,11 @@ class SimBAScaleBar(Frame):
     def get_value(self) -> Union[int, float]:
         return self.scale.get()
 
+    def get(self) -> Union[int, float]:
+        ## Alternative for ``get_value`` for legacy reasons.
+        return self.scale.get()
+
+
 
 
 class Entry_Box(Frame):

simba/video_processors/clahe_ui.py

@@ -1,4 +1,6 @@
 import os
+import threading
+import time
 from typing import Tuple, Union
 
 import cv2
@@ -32,29 +34,66 @@ def interactive_clahe_ui(data: Union[str, os.PathLike]) -> Tuple[float, int]:
     """
     global original_img, font_size, x_spacer, y_spacer, txt
 
+    callback_lock = threading.Lock()
+    last_update_time = [0]
+    update_delay = 0.05
+
     def _get_trackbar_values(v):
         global original_img, font_size, x_spacer, y_spacer, txt
-        clip_limit = cv2.getTrackbarPos(CLIP_LIMIT, WIN_NAME) / 10.0
-        tile_size = cv2.getTrackbarPos(TILE_SIZE, WIN_NAME)
-        if tile_size % 2 == 0: tile_size += 1
-        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=(tile_size, tile_size))
-        img_clahe = clahe.apply(original_img)
-        cv2.putText(img_clahe, txt,(TextOptions.BORDER_BUFFER_X.value, TextOptions.BORDER_BUFFER_Y.value + y_spacer), TextOptions.FONT.value, font_size, (255, 255, 255), 3)
-        cv2.imshow(WIN_NAME, img_clahe)
-        cv2.waitKey(100)
+        nonlocal callback_lock, last_update_time, update_delay
+        current_time = time.time()
+        if current_time - last_update_time[0] < update_delay:
+            return
+        
+        if not callback_lock.acquire(blocking=False):
+            return
+        
+        try:
+            if cv2.getWindowProperty(WIN_NAME, cv2.WND_PROP_VISIBLE) < 1:
+                return
+            try:
+                clip_limit = cv2.getTrackbarPos(CLIP_LIMIT, WIN_NAME) / 10.0
+                tile_size = cv2.getTrackbarPos(TILE_SIZE, WIN_NAME)
+                if tile_size % 2 == 0: tile_size += 1
+                clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=(tile_size, tile_size))
+                img_clahe = clahe.apply(original_img)
+                cv2.putText(img_clahe, txt,(TextOptions.BORDER_BUFFER_X.value, TextOptions.BORDER_BUFFER_Y.value + y_spacer), TextOptions.FONT.value, font_size, (255, 255, 255), 3)
+                cv2.imshow(WIN_NAME, img_clahe)
+                cv2.waitKey(1)
+                last_update_time[0] = current_time
+            except cv2.error:
+                pass
+        finally:
+            callback_lock.release()
 
     def _change_img(v):
         global original_img, font_size, x_spacer, y_spacer, txt
-        new_frm_id = cv2.getTrackbarPos(SELECT_VIDEO_FRAME, WIN_NAME)
-        original_img = read_frm_of_video(video_path=data, frame_index=new_frm_id, greyscale=True)
-        clip_limit = cv2.getTrackbarPos(CLIP_LIMIT, WIN_NAME) / 10.0
-        tile_size = cv2.getTrackbarPos(TILE_SIZE, WIN_NAME)
-        if tile_size % 2 == 0: tile_size += 1
-        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=(tile_size, tile_size))
-        img_clahe = clahe.apply(original_img)
-        cv2.putText(img_clahe, txt,(TextOptions.BORDER_BUFFER_X.value, TextOptions.BORDER_BUFFER_Y.value + y_spacer), TextOptions.FONT.value, font_size, (255, 255, 255), 3)
-        cv2.imshow(WIN_NAME, img_clahe)
-        cv2.waitKey(100)
+        current_time = time.time()
+        if current_time - last_update_time[0] < update_delay:
+            return
+        
+        if not callback_lock.acquire(blocking=False):
+            return
+        
+        try:
+            if cv2.getWindowProperty(WIN_NAME, cv2.WND_PROP_VISIBLE) < 1:
+                return
+            try:
+                new_frm_id = cv2.getTrackbarPos(SELECT_VIDEO_FRAME, WIN_NAME)
+                original_img = read_frm_of_video(video_path=data, frame_index=new_frm_id, greyscale=True)
+                clip_limit = cv2.getTrackbarPos(CLIP_LIMIT, WIN_NAME) / 10.0
+                tile_size = cv2.getTrackbarPos(TILE_SIZE, WIN_NAME)
+                if tile_size % 2 == 0: tile_size += 1
+                clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=(tile_size, tile_size))
+                img_clahe = clahe.apply(original_img)
+                cv2.putText(img_clahe, txt,(TextOptions.BORDER_BUFFER_X.value, TextOptions.BORDER_BUFFER_Y.value + y_spacer), TextOptions.FONT.value, font_size, (255, 255, 255), 3)
+                cv2.imshow(WIN_NAME, img_clahe)
+                cv2.waitKey(1)
+                last_update_time[0] = current_time
+            except cv2.error:
+                pass
+        finally:
+            callback_lock.release()
 
     check_instance(source=interactive_clahe_ui.__name__, instance=data, accepted_types=(np.ndarray, str))
     if isinstance(data, str):
@@ -80,14 +119,18 @@ def interactive_clahe_ui(data: Union[str, os.PathLike]) -> Tuple[float, int]:
             break
         k = cv2.waitKey(1) & 0xFF
         if k == 27:
-            clip_limit = cv2.getTrackbarPos(CLIP_LIMIT, WIN_NAME) / 10.0
-            tile_size = cv2.getTrackbarPos(TILE_SIZE, WIN_NAME)
-            if tile_size % 2 == 0: tile_size += 1
+            try:
+                clip_limit = cv2.getTrackbarPos(CLIP_LIMIT, WIN_NAME) / 10.0
+                tile_size = cv2.getTrackbarPos(TILE_SIZE, WIN_NAME)
+                if tile_size % 2 == 0: tile_size += 1
+            except cv2.error:
+                clip_limit = 1.0
+                tile_size = 8
             cv2.destroyAllWindows()
             return clip_limit, tile_size
 
 
-#interactive_clahe_ui(data=r"D:\EPM\sample_2\video_1.mp4")
+#interactive_clahe_ui(data=r"C:\troubleshooting\cue_light\t1\project_folder\videos\2025-05-21 16-10-06_cropped.mp4")
 
 # # Function to update CLAHE
 # def update_clahe(x):

simba/video_processors/egocentric_video_rotator.py

@@ -35,7 +35,6 @@ def egocentric_video_aligner(frm_range: np.ndarray,
                              gpu: bool = True):
 
     video_meta = get_video_meta_data(video_path=video_path)
-
     batch, frm_range = frm_range[0], frm_range[1]
     save_path = os.path.join(temp_dir, f'{batch}.mp4')
     fourcc = cv2.VideoWriter_fourcc(*f'{Formats.MP4_CODEC.value}')
@@ -57,7 +56,7 @@ def egocentric_video_aligner(frm_range: np.ndarray,
                 final_frame = cv2.warpAffine(rotated_frame, m_translations[img_counter],(video_meta['width'], video_meta['height']), borderValue=fill_clr)
                 writer.write(final_frame)
                 if verbose:
-                    print(f'Creating frame {frame_id} ({video_name}, CPU core: {batch + 1}).')
+                    print(f'Creating frame {frame_id}/{video_meta["frame_count"]} ({video_name}, CPU core: {batch + 1}).')
                 img_counter+=1
     else:
         cap = cv2.VideoCapture(video_path)
@@ -67,7 +66,7 @@ def egocentric_video_aligner(frm_range: np.ndarray,
             final_frame = cv2.warpAffine(rotated_frame, m_translations[frm_idx], (video_meta['width'], video_meta['height']), borderValue=fill_clr)
             writer.write(final_frame)
             if verbose:
-                print(f'Creating frame {frm_id} ({video_name}, CPU core: {batch + 1}).')
+                print(f'Creating frame {frm_id}/{video_meta["frame_count"]} ({video_name}, CPU core: {batch + 1}).')
     writer.release()
     return batch + 1
 
@@ -176,9 +175,9 @@ class EgocentricVideoRotator():
         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\rotate_ex\data\501_MA142_Gi_Saline_0513.csv"
-    VIDEO_PATH = r"C:\Users\sroni\OneDrive\Desktop\rotate_ex\videos\501_MA142_Gi_Saline_0513.mp4"
-    SAVE_PATH = r"C:\Users\sroni\OneDrive\Desktop\rotate_ex\videos\501_MA142_Gi_Saline_0513_rotated.mp4"
+    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')
@@ -186,5 +185,5 @@ if __name__ == "__main__":
     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)
+    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/video_processing.py

@@ -166,7 +166,7 @@ def convert_to_jpeg(path: Union[str, os.PathLike, List[Union[str, os.PathLike]]]
         dir, file_name, _ = get_fn_ext(filepath=file_path)
         save_path = os.path.join(save_dir, f'{file_name}.jpeg')
         if verbose:
-            print(f"Converting file {file_cnt+1}/{len(file_paths)} ...")
+            print(f"Converting file {file_cnt+1}/{len(file_paths)} ({file_name}) ...")
         img = Image.open(file_path)
         if img.mode in ('RGBA', 'LA'): img = img.convert('RGB')
         img.save(save_path, format='JPEG', quality=quality)
@@ -218,7 +218,7 @@ def convert_to_bmp(path: Union[str, os.PathLike, List[Union[str, os.PathLike]]],
         dir, file_name, _ = get_fn_ext(filepath=file_path)
         save_path = os.path.join(save_dir, f'{file_name}.bmp')
         if verbose:
-            print(f"Converting file {file_cnt + 1}/{len(file_paths)} ...")
+            print(f"Converting file {file_cnt + 1}/{len(file_paths)} ({file_name}) ...")
         img = Image.open(file_path)
         if img.mode in ('RGBA', 'LA'): img = img.convert('RGB')
         img.save(save_path, format='BMP')
@@ -2578,14 +2578,13 @@ def create_blank_video(path: Union[str, os.PathLike],
         )
 
 
-def horizontal_video_concatenator(
-    video_paths: List[Union[str, os.PathLike]],
-    save_path: Union[str, os.PathLike],
-    height_px: Optional[Union[int, str]] = None,
-    height_idx: Optional[Union[int, str]] = None,
-    gpu: Optional[bool] = False,
-    verbose: Optional[bool] = True,
-) -> None:
+def horizontal_video_concatenator(video_paths: List[Union[str, os.PathLike]],
+                                  save_path: Union[str, os.PathLike],
+                                  height_px: Optional[Union[int, str]] = None,
+                                  height_idx: Optional[Union[int, str]] = None,
+                                  gpu: bool = False,
+                                  quality: int = 23,
+                                  verbose: Optional[bool] = True) -> None:
     """
     Concatenates multiple videos horizontally.
 
@@ -2596,10 +2595,14 @@ def horizontal_video_concatenator(
     .. seealso::
        :func:`simba.video_processors.video_processing.vertical_video_concatenator`
 
+    .. note::
+       Set the height of each video in the moseic by passing **EITHER** ``height_px`` or ``height_idx``.
+
     :param List[Union[str, os.PathLike]] video_paths: List of input video file paths.
     :param Union[str, os.PathLike] save_path: File path to save the concatenated video.
     :param Optional[int] height_px: Height of the output video in pixels.
     :param Optional[int] height_idx: Index of the video to use for determining Height.
+    :param int quality: Video quality (CRF value). Lower values = higher quality. Range 0-52. Default 23.
     :param Optional[bool] gpu: Whether to use GPU-accelerated codec (default: False).
     :param Optional[bool] verbose:Whether to print progress messages (default: True).
 
@@ -2609,69 +2612,41 @@ def horizontal_video_concatenator(
     """
     check_ffmpeg_available()
     if gpu and not check_nvidea_gpu_available():
-        raise FFMPEGCodecGPUError(
-            msg="NVIDEA GPU not available (as evaluated by nvidea-smi returning None)",
-            source=horizontal_video_concatenator.__name__,
-        )
+        raise FFMPEGCodecGPUError(msg="NVIDEA GPU not available (as evaluated by nvidea-smi returning None)", source=horizontal_video_concatenator.__name__)
     timer = SimbaTimer(start=True)
-    check_valid_lst(
-        data=video_paths, source=horizontal_video_concatenator.__name__, min_len=2
-    )
-    check_if_dir_exists(
-        in_dir=os.path.dirname(save_path), source=horizontal_video_concatenator.__name__
-    )
-    video_meta_data = [
-        get_video_meta_data(video_path=video_path) for video_path in video_paths
-    ]
-    if ((height_px is None) and (height_idx is None)) or (
-        (height_px is not None) and (height_idx is not None)
-    ):
-        raise InvalidInputError(
-            msg="Provide a height_px OR height_idx",
-            source=horizontal_video_concatenator.__name__,
-        )
+    check_valid_lst(data=video_paths, source=horizontal_video_concatenator.__name__, min_len=2)
+    check_if_dir_exists(in_dir=os.path.dirname(save_path), source=horizontal_video_concatenator.__name__)
+    video_meta_data = [get_video_meta_data(video_path=video_path) for video_path in video_paths]
+    if ((height_px is None) and (height_idx is None)) or ((height_px is not None) and (height_idx is not None)):
+        raise InvalidInputError(msg="Provide a height_px OR height_idx",source=horizontal_video_concatenator.__name__)
     if height_idx is not None:
-        check_int(
-            name=f"{horizontal_video_concatenator.__name__} height",
-            value=height_idx,
-            min_value=0,
-            max_value=len(video_paths) - 1,
-        )
+        check_int(name=f"{horizontal_video_concatenator.__name__} height", value=height_idx, min_value=0, max_value=len(video_paths) - 1)
         height = int(video_meta_data[height_idx]["height"])
     else:
-        check_int(
-            name=f"{horizontal_video_concatenator.__name__} height",
-            value=height_px,
-            min_value=1,
-        )
+        check_int(name=f"{horizontal_video_concatenator.__name__} height", value=height_px,min_value=1)
         height = int(height_px)
     video_path_str = " ".join([f'-i "{path}"' for path in video_paths])
+    quality = 23 if not check_int(name='quality', value=quality, min_value=0, max_value=52, raise_error=False)[0] else int(quality)
+    quality_cmd = f'-crf {quality}' if not gpu else f'-rc vbr -cq {quality}'
     codec = "h264_nvenc" if gpu else "libvpx-vp9"
-    filter_complex = ";".join(
-        [f"[{idx}:v]scale=-1:{height}[v{idx}]" for idx in range(len(video_paths))]
-    )
+    filter_complex = ";".join([f"[{idx}:v]scale=-1:{height}[v{idx}]" for idx in range(len(video_paths))])
     filter_complex += f";{''.join([f'[v{idx}]' for idx in range(len(video_paths))])}hstack=inputs={len(video_paths)}[v]"
     if verbose:
-        print(
-            f"Concatenating {len(video_paths)} videos horizontally with a {height} pixel height... "
-        )
-    cmd = f'ffmpeg {video_path_str} -filter_complex "{filter_complex}" -map "[v]" -c:v {codec} -loglevel error -stats "{save_path}" -y'
+        print(f"Concatenating {len(video_paths)} videos horizontally with a {height} pixel height... ")
+    cmd = f'ffmpeg {video_path_str} -filter_complex "{filter_complex}" -map "[v]" -c:v {codec} {quality_cmd} -loglevel error -stats "{save_path}" -y'
     subprocess.call(cmd, shell=True, stdout=subprocess.PIPE)
     timer.stop_timer()
     if verbose:
-        print(
-            f"Horizontal concatenation complete, saved at {save_path} (elapsed time: {timer.elapsed_time_str}s.)"
-        )
+        print(f"Horizontal concatenation complete, saved at {save_path} (elapsed time: {timer.elapsed_time_str}s.)")
 
 
-def vertical_video_concatenator(
-    video_paths: List[Union[str, os.PathLike]],
-    save_path: Union[str, os.PathLike],
-    width_px: Optional[int] = None,
-    width_idx: Optional[int] = None,
-    gpu: Optional[bool] = False,
-    verbose: Optional[bool] = True,
-) -> None:
+def vertical_video_concatenator(video_paths: List[Union[str, os.PathLike]],
+                                save_path: Union[str, os.PathLike],
+                                width_px: Optional[int] = None,
+                                width_idx: Optional[int] = None,
+                                gpu: bool = False,
+                                quality: int = 23,
+                                verbose: bool = True) -> None:
     """
     Concatenates multiple videos vertically.
 
@@ -2738,22 +2713,18 @@ def vertical_video_concatenator(
         width = int(width_px)
     video_path_str = " ".join([f'-i "{path}"' for path in video_paths])
     codec = "h264_nvenc" if gpu else "libvpx-vp9"
-    filter_complex = ";".join(
-        [f"[{idx}:v]scale={width}:-1[v{idx}]" for idx in range(len(video_paths))]
-    )
+    quality = 23 if not check_int(name='quality', value=quality, min_value=0, max_value=52, raise_error=False)[0] else int(quality)
+    quality_cmd = f'-crf {quality}' if not gpu else f'-rc vbr -cq {quality}'
+    filter_complex = ";".join([f"[{idx}:v]scale={width}:-1[v{idx}]" for idx in range(len(video_paths))])
     filter_complex += f";{''.join([f'[v{idx}]' for idx in range(len(video_paths))])}"
     filter_complex += f"vstack=inputs={len(video_paths)}[v]"
     if verbose:
-        print(
-            f"Concatenating {len(video_paths)} videos vertically with a {width} pixel width..."
-        )
-    cmd = f'ffmpeg {video_path_str} -filter_complex "{filter_complex}" -map "[v]" -c:v {codec} -loglevel error -stats "{save_path}" -y'
+        print(f"Concatenating {len(video_paths)} videos vertically with a {width} pixel width...")
+    cmd = f'ffmpeg {video_path_str} -filter_complex "{filter_complex}" -map "[v]" -c:v {codec} {quality_cmd} "{save_path}" -loglevel error -stats -y'
     subprocess.call(cmd, shell=True, stdout=subprocess.PIPE)
     timer.stop_timer()
     if verbose:
-        print(
-            f"Vertical concatenation complete. Saved at {save_path} (Elapsed time: {timer.elapsed_time_str}s.)"
-        )
+        print(f"Vertical concatenation complete. Saved at {save_path} (Elapsed time: {timer.elapsed_time_str}s.)")
 
 
 def mosaic_concatenator(
@@ -2763,8 +2734,9 @@ def mosaic_concatenator(
     width_px: Optional[Union[int, str]] = None,
     height_idx: Optional[Union[int, str]] = None,
     height_px: Optional[Union[int, str]] = None,
-    gpu: Optional[bool] = False,
-    verbose: Optional[bool] = True,
+    gpu: bool = False,
+    quality: int = 23,
+    verbose: bool = True,
     uneven_fill_color: Optional[str] = "black",
 ) -> None:
     """
@@ -2789,6 +2761,7 @@ def mosaic_concatenator(
     :param Optional[int] height_px: Height of the output video panels in pixels.
     :param Optional[int] height_idx: Height of the video to use for determining width.
     :param Optional[bool] gpu: Whether to use GPU-accelerated codec (default: False).
+    :param int quality: Video quality (CRF value). Lower values = higher quality. Range 0-52. Default 23.
     :param Optional[bool] verbose: Whether to print progress messages (default: True).
 
     :example:
@@ -2799,49 +2772,24 @@ def mosaic_concatenator(
 
     check_ffmpeg_available()
     if gpu and not check_nvidea_gpu_available():
-        raise FFMPEGCodecGPUError(
-            msg="NVIDIA GPU not available", source=mosaic_concatenator.__name__
-        )
+        raise FFMPEGCodecGPUError(msg="NVIDIA GPU not available", source=mosaic_concatenator.__name__)
     timer = SimbaTimer(start=True)
     dt = datetime.now().strftime("%Y%m%d%H%M%S")
-    check_valid_lst(
-        data=video_paths,
-        source=f"{mosaic_concatenator.__name__} video_paths",
-        min_len=3,
-    )
-    video_meta_data = [
-        get_video_meta_data(video_path=video_path) for video_path in video_paths
-    ]
+    check_valid_lst(data=video_paths, source=f"{mosaic_concatenator.__name__} video_paths", min_len=3)
+    video_meta_data = [get_video_meta_data(video_path=video_path) for video_path in video_paths]
     max_video_length = max([x["video_length_s"] for x in video_meta_data])
-    if ((width_px is None) and (width_idx is None)) or (
-        (width_px is not None) and (width_idx is not None)
-    ):
-        raise InvalidInputError(
-            msg="Provide a width_px OR width_idx", source=mosaic_concatenator.__name__
-        )
-    if ((height_px is None) and (height_idx is None)) or (
-        (height_px is not None) and (height_idx is not None)
-    ):
-        raise InvalidInputError(
-            msg="Provide a height_px OR height_idx", source=mosaic_concatenator.__name__
-        )
+    quality = 23 if not check_int(name='quality', value=quality, min_value=0, max_value=52, raise_error=False)[0] else int(quality)
+    if ((width_px is None) and (width_idx is None)) or ((width_px is not None) and (width_idx is not None)):
+        raise InvalidInputError(msg="Provide a width_px OR width_idx", source=mosaic_concatenator.__name__)
+    if ((height_px is None) and (height_idx is None)) or ((height_px is not None) and (height_idx is not None)):
+        raise InvalidInputError(msg="Provide a height_px OR height_idx", source=mosaic_concatenator.__name__)
     if width_idx is not None:
-        check_int(
-            name=f"{vertical_video_concatenator.__name__} width index",
-            value=width_idx,
-            min_value=1,
-            max_value=len(video_paths) - 1,
-        )
+        check_int(name=f"{vertical_video_concatenator.__name__} width index", value=width_idx, min_value=1, max_value=len(video_paths) - 1)
         width = int(video_meta_data[width_idx]["width"])
     else:
         width = width_px
     if height_idx is not None:
-        check_int(
-            name=f"{vertical_video_concatenator.__name__} height index",
-            value=width_idx,
-            min_value=1,
-            max_value=len(video_paths) - 1,
-        )
+        check_int(name=f"{vertical_video_concatenator.__name__} height index", value=width_idx, min_value=1, max_value=len(video_paths) - 1)
         height = int(video_meta_data[width_idx]["height"])
     else:
         height = height_px
@@ -2851,73 +2799,40 @@ def mosaic_concatenator(
     os.makedirs(temp_dir)
     if not (len(video_paths) % 2) == 0:
         blank_path = os.path.join(temp_dir, f"{dt}.mp4")
-        create_blank_video(
-            path=blank_path,
-            length=max_video_length,
-            width=width,
-            height=height,
-            gpu=gpu,
-            verbose=verbose,
-            color=uneven_fill_color,
-        )
+        create_blank_video(path=blank_path, length=max_video_length, width=width, height=height, gpu=gpu, verbose=verbose, color=uneven_fill_color)
         video_paths.append(blank_path)
-    upper_videos, lower_videos = (
-        video_paths[: len(video_paths) // 2],
-        video_paths[len(video_paths) // 2 :],
-    )
+    upper_videos, lower_videos = (video_paths[: len(video_paths) // 2], video_paths[len(video_paths) // 2 :])
     if verbose:
         print("Creating upper mosaic... (Step 1/3)")
     if len(upper_videos) > 1:
         upper_path = os.path.join(temp_dir, "upper.mp4")
-        horizontal_video_concatenator(
-            video_paths=upper_videos,
-            save_path=upper_path,
-            gpu=gpu,
-            height_px=height,
-            verbose=verbose,
-        )
+        horizontal_video_concatenator(video_paths=upper_videos, save_path=upper_path, gpu=gpu, quality=quality, height_px=height, verbose=verbose)
     else:
         upper_path = upper_videos[0]
     if verbose:
         print("Creating lower mosaic... (Step 2/3)")
     if len(lower_videos) > 1:
         lower_path = os.path.join(temp_dir, "lower.mp4")
-        horizontal_video_concatenator(
-            video_paths=lower_videos,
-            save_path=lower_path,
-            gpu=gpu,
-            height_px=height,
-            verbose=verbose,
-        )
+        horizontal_video_concatenator(video_paths=lower_videos, save_path=lower_path, gpu=gpu, quality=quality, height_px=height, verbose=verbose)
     else:
         lower_path = lower_videos[0]
-    panels_meta = [
-        get_video_meta_data(video_path=video_path)
-        for video_path in [lower_path, upper_path]
-    ]
+    panels_meta = [get_video_meta_data(video_path=video_path) for video_path in [lower_path, upper_path]]
     if verbose:
-        print("Joining upper and lower mosaic... (Step 2/3)")
-    vertical_video_concatenator(
-        video_paths=[upper_path, lower_path],
-        save_path=save_path,
-        verbose=verbose,
-        gpu=gpu,
-        width_px=max([x["width"] for x in panels_meta]),
-    )
+        print("Joining upper and lower mosaic... (Step 3/3)")
+    vertical_video_concatenator(video_paths=[upper_path, lower_path], save_path=save_path, verbose=verbose, gpu=gpu, quality=quality, width_px=max([x["width"] for x in panels_meta]))
     timer.stop_timer()
     shutil.rmtree(temp_dir)
     if verbose:
-        print(
-            f"Mosaic concatenation complete. Saved at {save_path} (Elapsed time: {timer.elapsed_time_str}s.)"
-        )
+        print(f"Mosaic concatenation complete. Saved at {save_path} (Elapsed time: {timer.elapsed_time_str}s.)")
 
 
 def mixed_mosaic_concatenator(
     video_paths: List[Union[str, os.PathLike]],
     save_path: Union[str, os.PathLike],
-    gpu: Optional[bool] = False,
-    verbose: Optional[bool] = True,
-    uneven_fill_color: Optional[str] = "black",
+    gpu: bool = False,
+    quality: int = 23,
+    verbose: bool = True,
+    uneven_fill_color: str = "black",
 ) -> None:
     """
     Create a mixed mosaic video by concatenating multiple input videos in a mosaic layout of various sizes.
@@ -2939,6 +2854,7 @@ def mixed_mosaic_concatenator(
     :param List[Union[str, os.PathLike]] video_paths: List of input video file paths.
     :param Union[str, os.PathLike] save_path: File path to save the concatenated video.
     :param Optional[bool] gpu: Whether to use GPU-accelerated codec (default: False).
+    :param int quality: Video quality (CRF value). Lower values = higher quality. Range 0-52. Default 23.
     :param Optional[bool] verbose: Whether to print progress messages (default: True).
 
     :example:
@@ -2962,6 +2878,8 @@ def mixed_mosaic_concatenator(
         print("Creating mixed mosaic video... ")
     temp_dir = os.path.join(os.path.dirname(large_mosaic_path), f"temp_{dt}")
     os.makedirs(temp_dir)
+    quality = 23 if not check_int(name='quality', value=quality, min_value=0, max_value=52, raise_error=False)[0] else int(quality)
+
     if not (len(video_paths) % 2) == 0:
         blank_path = os.path.join(temp_dir, f"{dt}.mp4")
         create_blank_video(
@@ -2986,6 +2904,7 @@ def mixed_mosaic_concatenator(
             video_paths=upper_videos,
             save_path=upper_path,
             gpu=gpu,
+            quality=quality,
             height_px=mosaic_height,
             verbose=verbose,
         )
@@ -2999,6 +2918,7 @@ def mixed_mosaic_concatenator(
             video_paths=lower_videos,
             save_path=lower_path,
             gpu=gpu,
+            quality=quality,
             verbose=verbose,
             height_px=mosaic_height,
         )
@@ -3016,6 +2936,7 @@ def mixed_mosaic_concatenator(
         width_px=max([x["width"] for x in panels_meta]),
         save_path=mosaic_path,
         gpu=gpu,
+        quality=quality,
         verbose=verbose,
     )
     if verbose:
@@ -3025,6 +2946,7 @@ def mixed_mosaic_concatenator(
         height_idx=0,
         save_path=save_path,
         gpu=gpu,
+        quality=quality,
     )
     timer.stop_timer()
     shutil.rmtree(temp_dir)

simba/video_processors/videos_to_frames.py

@@ -16,6 +16,7 @@ from simba.utils.checks import (check_if_dir_exists, check_int, check_str,
 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
 
 JPEG, PNG, WEBP = 'jpeg', 'png', 'webp'
 
@@ -117,8 +118,8 @@ def video_to_frames(video_path: Union[str, os.PathLike],
         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...')
-    pool.join()
-    pool.terminate()
+
+    terminate_cpu_pool(pool=pool, force=True)
     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)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba-uw-tf-dev
-Version: 4.5.8
+Version: 4.6.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