simba-uw-tf-dev 4.7.5__py3-none-any.whl → 4.7.6__py3-none-any.whl

simba/assets/.recent_projects.txt

@@ -1,3 +1,4 @@
+C:/troubleshooting/sleap_two_animals/project_folder/project_config.ini
 E:/troubleshooting/mitra_emergence/project_folder/project_config.ini
 C:/troubleshooting/meberled/project_folder/project_config.ini
 C:/troubleshooting/mitra/project_folder/project_config.ini

simba/mixins/feature_extraction_mixin.py

@@ -603,8 +603,6 @@ class FeatureExtractionMixin(object):
                     else:
                         pass
 
-
-
         for cord in [nose_cords, ear_left_cords, ear_right_cords]:
             if len(cord) != len(self.animal_bp_dict.keys()) * 2:
                 direction_viable = False

simba/sandbox/av1.py

@@ -0,0 +1,5 @@
+from simba.video_processors.video_processing import convert_to_webm
+
+
+
+convert_to_webm(path=r"D:\troubleshooting\batch_fps\2025-09-08_13-06-38-AloneH-1.mp4", codec='vp9')

simba/sandbox/denoise_hqdn3d.py

@@ -0,0 +1,266 @@
+"""
+Function to apply hqdn3d (high-quality denoise 3D) filter to a video file using ffmpeg.
+
+The hqdn3d filter is a spatial-temporal denoise filter that reduces noise while preserving
+video quality and details.
+"""
+
+import os
+import subprocess
+from typing import Union, Optional
+
+from simba.utils.checks import (
+    check_ffmpeg_available,
+    check_file_exist_and_readable,
+    check_if_dir_exists,
+    check_nvidea_gpu_available
+)
+from simba.utils.errors import FFMPEGCodecGPUError
+from simba.utils.printing import SimbaTimer, stdout_success
+from simba.utils.read_write import get_fn_ext
+
+
+def denoise_bm3d(file_path: Union[str, os.PathLike],
+                 save_path: Optional[Union[str, os.PathLike]] = None,
+                 gpu: Optional[bool] = False,
+                 quality: int = 60,
+                 sigma: Optional[float] = None,
+                 block: Optional[int] = None,
+                 bstep: Optional[int] = None,
+                 group: Optional[int] = None) -> None:
+    """
+    Apply bm3d (Block-Matching 3D) denoise filter to a video file.
+
+    BM3D is a more advanced denoising algorithm than hqdn3d, often better at removing texture
+    and background noise while preserving details. It's slower but produces better results.
+    
+    **For removing background texture (e.g., sawdust pellets):**
+    - **sigma** is MOST IMPORTANT - controls noise level/denoising strength (higher = more denoising)
+    - **block** - block size (default: 4, larger = more smoothing but slower)
+    - **bstep** - block step (default: 4, smaller = better quality but slower)
+    - **group** - group size (default: 1, larger = better denoising but slower)
+    
+    :param Union[str, os.PathLike] file_path: Path to input video file.
+    :param Optional[Union[str, os.PathLike]] save_path: Optional save location for the denoised video. If None, then the new video is saved in the same directory as the input video with the ``_bm3d_denoised`` suffix.
+    :param Optional[bool] gpu: If True, use NVIDEA GPU codecs. Default False.
+    :param int quality: Video quality percentage (1-100). Higher values = higher quality. Default 60.
+    :param Optional[float] sigma: Noise level/denoising strength (default: 1.0). **MOST IMPORTANT** - higher values = more denoising. For background texture removal, try 5-20.
+    :param Optional[int] block: Block size (default: 4). Larger values = more smoothing but slower processing.
+    :param Optional[int] bstep: Block step (default: 4). Smaller values = better quality but slower.
+    :param Optional[int] group: Group size (default: 1). Larger values = better denoising but slower.
+    :returns: None. If save_path is not passed, the result is stored in the same directory as the input file with the ``_bm3d_denoised.mp4`` suffix.
+    
+    .. note::
+       Codec is automatically selected: libx264 for CPU encoding (ignored if gpu=True).
+       BM3D is slower than hqdn3d but often produces better results for texture removal.
+       For background texture removal, start with sigma=10-15 and adjust from there.
+
+    :example:
+    >>> denoise_bm3d(file_path='project_folder/videos/Video_1.avi', sigma=10)
+    >>> denoise_bm3d(file_path='/Users/simon/Desktop/test/noisy_video.mp4', sigma=15, block=8, quality=80)
+    """
+
+    check_ffmpeg_available(raise_error=True)
+    if gpu and not check_nvidea_gpu_available():
+        raise FFMPEGCodecGPUError(
+            msg="No GPU found (as evaluated by nvidea-smi returning None)",
+            source=denoise_bm3d.__name__
+        )
+    
+    timer = SimbaTimer(start=True)
+    check_file_exist_and_readable(file_path=file_path)
+    
+    dir, file_name, ext = get_fn_ext(filepath=file_path)
+    
+    if save_path is None:
+        save_name = os.path.join(dir, f"{file_name}_bm3d_denoised.mp4")
+    else:
+        check_if_dir_exists(
+            in_dir=os.path.dirname(save_path),
+            source=f'{denoise_bm3d.__name__} save_path',
+            create_if_not_exist=True
+        )
+        save_name = save_path
+    
+    # Set default bm3d parameters if not provided
+    sigma_val = sigma if sigma is not None else 1.0
+    block_val = block if block is not None else 4
+    bstep_val = bstep if bstep is not None else 4
+    group_val = group if group is not None else 1
+    
+    # Check if bm3d filter is available first (may not be compiled into all ffmpeg builds)
+    check_cmd = 'ffmpeg -filters 2>&1 | findstr /i "bm3d"'
+    result = subprocess.run(check_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
+    if not result.stdout.strip():
+        raise FFMPEGCodecGPUError(
+            msg="BM3D filter not available in your ffmpeg build. BM3D may not be compiled into your ffmpeg installation. Try using hqdn3d or nlmeans instead.",
+            source=denoise_bm3d.__name__
+        )
+    
+    # Build bm3d filter string with named parameters
+    # Format: bm3d=sigma=value:block=value:bstep=value:group=value
+    filter_str = f'bm3d=sigma={sigma_val}:block={block_val}:bstep={bstep_val}:group={group_val}'
+    
+    # Build ffmpeg command with bm3d filter
+    if gpu:
+        # GPU encoding with bm3d filter
+        from simba.utils.lookups import quality_pct_to_crf
+        quality_crf = quality_pct_to_crf(pct=int(quality))
+        cmd = f'ffmpeg -hwaccel auto -c:v h264_cuvid -i "{file_path}" -vf {filter_str} -rc vbr -cq {quality_crf} -c:v h264_nvenc -c:a copy "{save_name}" -loglevel error -stats -hide_banner -y'
+    else:
+        # CPU encoding with bm3d filter
+        from simba.utils.lookups import quality_pct_to_crf
+        quality_crf = quality_pct_to_crf(pct=int(quality))
+        cmd = f'ffmpeg -i "{file_path}" -vf {filter_str} -c:v libx264 -crf {quality_crf} -c:a copy "{save_name}" -loglevel error -stats -hide_banner -y'
+    
+    print(f"Applying bm3d denoise filter (sigma={sigma_val}, block={block_val}, bstep={bstep_val}, group={group_val}) to {file_name}...")
+    print(f"Command: {cmd}")
+    
+    process = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
+    if process.returncode != 0:
+        error_msg = process.stderr if process.stderr else (process.stdout if process.stdout else "Unknown error")
+        print(f"Error output: {error_msg}")
+        raise FFMPEGCodecGPUError(
+            msg=f"FFmpeg bm3d filter failed: {error_msg}",
+            source=denoise_bm3d.__name__
+        )
+    timer.stop_timer()
+    stdout_success(
+        msg=f"SIMBA COMPLETE: Video denoised with BM3D! {save_name} generated!",
+        elapsed_time=timer.elapsed_time_str,
+        source=denoise_bm3d.__name__
+    )
+
+
+def denoise_hqdn3d(file_path: Union[str, os.PathLike],
+                   save_path: Optional[Union[str, os.PathLike]] = None,
+                   gpu: Optional[bool] = False,
+                   quality: int = 60,
+                   luma_spatial: Optional[float] = None,
+                   luma_temporal: Optional[float] = None,
+                   chroma_spatial: Optional[float] = None,
+                   chroma_temporal: Optional[float] = None) -> None:
+    """
+    Apply hqdn3d (high-quality denoise 3D) filter to a video file.
+
+    The hqdn3d filter has 4 parameters that control denoising strength:
+    - Higher values = more denoising but may blur details
+    - Lower values = less denoising but preserves more detail
+    
+    **For removing background texture (e.g., sawdust pellets):**
+    - **luma_spatial** and **chroma_spatial** are MOST IMPORTANT - these control spatial smoothing within each frame
+    - **luma_temporal** and **chroma_temporal** are less critical - these smooth across frames (helpful for motion noise, not static background)
+    - For background texture removal, focus on high spatial values (50-200+) and moderate temporal values (10-20)
+    
+    .. note::
+       hqdn3d may not be ideal for removing static background texture. Consider background subtraction or blur filters instead.
+       For background texture removal, try: luma_spatial=100-200, chroma_spatial=100-200, luma_temporal=10-20, chroma_temporal=10-20
+    
+    :param Union[str, os.PathLike] file_path: Path to input video file.
+    :param Optional[Union[str, os.PathLike]] save_path: Optional save location for the denoised video. If None, then the new video is saved in the same directory as the input video with the ``_denoised`` suffix.
+    :param Optional[bool] gpu: If True, use NVIDEA GPU codecs. Default False.
+    :param int quality: Video quality percentage (1-100). Higher values = higher quality. Default 60.
+    :param Optional[float] luma_spatial: Spatial luma strength (default: 4.0). Controls detail preservation in luma channel. **MOST IMPORTANT for background texture removal.**
+    :param Optional[float] luma_temporal: Temporal luma strength (default: 3.0). Controls motion blur artifacts in luma channel. Less critical for static background.
+    :param Optional[float] chroma_spatial: Spatial chroma strength (default: 3.0). Controls detail preservation in chroma channel. **MOST IMPORTANT for background texture removal.**
+    :param Optional[float] chroma_temporal: Temporal chroma strength (default: 6.0). Controls motion blur artifacts in chroma channel. Less critical for static background.
+    :returns: None. If save_path is not passed, the result is stored in the same directory as the input file with the ``_denoised.mp4`` suffix.
+    
+    .. note::
+       Codec is automatically selected: libx264 for CPU encoding (ignored if gpu=True).
+       Default parameters are conservative. For stronger denoising, try: luma_spatial=8, luma_temporal=6, chroma_spatial=6, chroma_temporal=9
+       For very noisy videos, you may need values of 10-15 or higher.
+
+    :example:
+    >>> denoise_hqdn3d(file_path='project_folder/videos/Video_1.avi')
+    >>> denoise_hqdn3d(file_path='/Users/simon/Desktop/test/noisy_video.mp4', luma_spatial=8, luma_temporal=6, quality=80)
+    >>> # For removing background texture (sawdust pellets):
+    >>> denoise_hqdn3d(file_path='video.mp4', luma_spatial=150, chroma_spatial=150, luma_temporal=15, chroma_temporal=15)
+    """
+
+    check_ffmpeg_available(raise_error=True)
+    if gpu and not check_nvidea_gpu_available():
+        raise FFMPEGCodecGPUError(
+            msg="No GPU found (as evaluated by nvidea-smi returning None)",
+            source=denoise_hqdn3d.__name__
+        )
+    
+    timer = SimbaTimer(start=True)
+    check_file_exist_and_readable(file_path=file_path)
+    
+    dir, file_name, ext = get_fn_ext(filepath=file_path)
+    
+    if save_path is None:
+        save_name = os.path.join(dir, f"{file_name}_denoised.mp4")
+    else:
+        check_if_dir_exists(
+            in_dir=os.path.dirname(save_path),
+            source=f'{denoise_hqdn3d.__name__} save_path',
+            create_if_not_exist=True
+        )
+        save_name = save_path
+    
+    # Set default hqdn3d parameters if not provided
+    luma_sp = luma_spatial if luma_spatial is not None else 4.0
+    luma_tmp = luma_temporal if luma_temporal is not None else 3.0
+    chroma_sp = chroma_spatial if chroma_spatial is not None else 3.0
+    chroma_tmp = chroma_temporal if chroma_temporal is not None else 6.0
+    
+    # Build hqdn3d filter string with parameters
+    # Format: hqdn3d=luma_spatial:chroma_spatial:luma_temporal:chroma_temporal
+    filter_str = f'hqdn3d={luma_sp}:{chroma_sp}:{luma_tmp}:{chroma_tmp}'
+    
+    # Build ffmpeg command with hqdn3d filter
+    if gpu:
+        # GPU encoding with hqdn3d filter
+        from simba.utils.lookups import quality_pct_to_crf
+        quality_crf = quality_pct_to_crf(pct=int(quality))
+        cmd = f'ffmpeg -hwaccel auto -c:v h264_cuvid -i "{file_path}" -vf {filter_str} -rc vbr -cq {quality_crf} -c:v h264_nvenc -c:a copy "{save_name}" -loglevel error -stats -hide_banner -y'
+    else:
+        # CPU encoding with hqdn3d filter
+        from simba.utils.lookups import quality_pct_to_crf
+        quality_crf = quality_pct_to_crf(pct=int(quality))
+        cmd = f'ffmpeg -i "{file_path}" -vf {filter_str} -c:v libx264 -crf {quality_crf} -c:a copy "{save_name}" -loglevel error -stats -hide_banner -y'
+    
+    print(f"Applying hqdn3d denoise filter (luma_spatial={luma_sp}, chroma_spatial={chroma_sp}, luma_temporal={luma_tmp}, chroma_temporal={chroma_tmp}) to {file_name}...")
+    
+    subprocess.call(cmd, shell=True, stdout=subprocess.PIPE)
+    timer.stop_timer()
+    stdout_success(
+        msg=f"SIMBA COMPLETE: Video denoised! {save_name} generated!",
+        elapsed_time=timer.elapsed_time_str,
+        source=denoise_hqdn3d.__name__
+    )
+
+#
+# For removing background texture (sawdust pellets):
+# Focus on HIGH spatial values (most important) and moderate temporal values
+# Spatial parameters blur within each frame - critical for static background texture
+# Temporal parameters smooth across frames - less critical for static background
+# denoise_hqdn3d(
+#     file_path=r"E:\open_video\open_field_4\2.mp4",
+#     luma_spatial=200,      # VERY HIGH - most important for background texture removal
+#     luma_temporal=40,     # Moderate - 200 is overkill for static background
+#     chroma_spatial=200,    # VERY HIGH - most important for background texture removal
+#     chroma_temporal=40    # Moderate - 200 is overkill for static background
+# )
+
+# BM3D - Better for texture removal, slower but often produces better results
+# sigma is the most important parameter - controls denoising strength
+# denoise_bm3d(
+#     file_path=r"E:\open_video\open_field_4\2.mp4",
+#     sigma=15,              # High denoising strength for background texture removal
+#     block=8,               # Larger blocks = more smoothing
+#     bstep=2,               # Smaller step = better quality
+#     group=1                # Default group size
+# )
+#
+# # BM3D - Better for texture removal, slower but often produces better results
+# # sigma is the most important parameter - controls denoising strength
+# denoise_bm3d(
+#     file_path=r"E:\open_video\open_field_4\2.mp4",
+#     sigma=15,              # High denoising strength for background texture removal
+#     block=8,               # Larger blocks = more smoothing
+#     bstep=2,               # Smaller step = better quality
+#     group=1                # Default group size
+# )

simba/sandbox/extract_random_frames.py

@@ -0,0 +1,126 @@
+"""
+Function to extract random N frames from all videos in a directory.
+
+Each frame is saved as videoname_framenumber.png in the same directory as the video.
+"""
+
+import os
+import random
+from typing import Union, Optional
+import numpy as np
+import cv2
+
+from simba.utils.checks import (
+    check_if_dir_exists,
+    check_int,
+    check_file_exist_and_readable
+)
+from simba.utils.read_write import (
+    get_video_meta_data,
+    find_all_videos_in_directory,
+    read_frm_of_video,
+    get_fn_ext
+)
+from simba.utils.printing import SimbaTimer, stdout_success
+
+
+def extract_random_frames_from_directory(
+    directory: Union[str, os.PathLike],
+    n_frames: int = 10,
+    save_dir: Optional[Union[str, os.PathLike]] = None,
+    verbose: Optional[bool] = True
+) -> None:
+    """
+    Extract random N frames from all videos in a directory.
+
+    For each video, randomly samples N frames and saves them as individual PNG files.
+    Frames are saved with the naming convention: videoname_framenumber.png
+
+    :param Union[str, os.PathLike] directory: Path to directory containing video files.
+    :param int n_frames: Number of random frames to extract from each video. Default: 10.
+    :param Optional[Union[str, os.PathLike]] save_dir: Optional directory where extracted frames will be saved. 
+        If None, frames are saved in the same directory as each video file. Default: None.
+    :param Optional[bool] verbose: If True, prints progress messages during extraction. Default: True.
+    :return: None. Frames are saved to disk.
+
+    :example:
+    >>> extract_random_frames_from_directory(directory='project_folder/videos', n_frames=20)
+    >>> extract_random_frames_from_directory(directory='/Users/simon/Desktop/videos', n_frames=5, save_dir='/Users/simon/Desktop/frames')
+    """
+
+    timer = SimbaTimer(start=True)
+    check_if_dir_exists(in_dir=directory, source=extract_random_frames_from_directory.__name__)
+    check_int(name="n_frames", value=n_frames, min_value=1)
+    
+    # Find all videos in directory
+    video_paths = find_all_videos_in_directory(
+        directory=directory,
+        as_dict=False,
+        raise_error=True
+    )
+    
+    if not video_paths or video_paths == ["No videos found"]:
+        raise ValueError(f"No videos found in directory: {directory}")
+    
+    total_frames_extracted = 0
+    
+    for video_cnt, video_name in enumerate(video_paths):
+        video_path = os.path.join(directory, video_name)
+        check_file_exist_and_readable(file_path=video_path)
+        
+        # Get video metadata
+        video_meta_data = get_video_meta_data(video_path=video_path)
+        total_frames = video_meta_data["frame_count"]
+        _, video_name_only, _ = get_fn_ext(filepath=video_path)  # Returns (directory, filename, extension)
+        
+        # Determine save directory
+        if save_dir is None:
+            video_save_dir = directory  # Save to the same directory as the videos
+        else:
+            video_save_dir = save_dir
+        
+        # Create save directory if it doesn't exist
+        if not os.path.exists(video_save_dir):
+            os.makedirs(video_save_dir)
+        
+        # Randomly sample N frames (or all frames if video has fewer than N frames)
+        n_samples = min(n_frames, total_frames)
+        if total_frames < n_frames:
+            if verbose:
+                print(f"Video {video_name_only} has only {total_frames} frames. Extracting all {total_frames} frames.")
+            selected_frames = list(range(total_frames))
+        else:
+            selected_frames = sorted(random.sample(range(total_frames), n_samples))
+        
+        # Extract and save frames
+        cap = cv2.VideoCapture(video_path)
+        for frame_idx, frame_number in enumerate(selected_frames):
+            # Seek to the correct frame
+            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
+            ret, frame = cap.read()
+            
+            if not ret:
+                if verbose:
+                    print(f"Warning: Could not read frame {frame_number} from {video_name_only}. Skipping...")
+                continue
+            
+            # Save frame with naming convention: videoname_framenumber.png
+            # video_name_only is the video filename without extension
+            save_path = os.path.join(video_save_dir, f"{video_name_only}_{frame_number}.png")
+            cv2.imwrite(save_path, frame, [cv2.IMWRITE_PNG_COMPRESSION, 3])
+            total_frames_extracted += 1
+            
+            if verbose:
+                print(f"Video {video_cnt + 1}/{len(video_paths)}: Frame {frame_number} saved from {video_name_only} ({frame_idx + 1}/{len(selected_frames)})")
+        
+        cap.release()
+    
+    timer.stop_timer()
+    stdout_success(
+        msg=f"SIMBA COMPLETE: Extracted {total_frames_extracted} random frames from {len(video_paths)} video(s)!",
+        elapsed_time=timer.elapsed_time_str,
+        source=extract_random_frames_from_directory.__name__
+    )
+
+
+extract_random_frames_from_directory(directory=r"D:\maplight_tg2576_yolo\videos", n_frames=35, save_dir=r'D:\maplight_tg2576_yolo\frames')

simba/ui/pop_ups/video_processing_pop_up.py

@@ -2495,7 +2495,7 @@ class Convert2WEBMPopUp(PopUpMixin):
     def __init__(self):
         super().__init__(title="CONVERT VIDEOS TO WEBM", icon='webm')
         settings_frm = CreateLabelFrameWithIcon(parent=self.main_frm, header="SETTINGS", icon_name=Keys.DOCUMENTATION.value, icon_link=Links.VIDEO_TOOLS.value)
-        self.WEBM_CODEC_LK = {'VP8': 'vp8', 'VP9': 'vp9'}
+        self.WEBM_CODEC_LK = {'VP8': 'vp8', 'VP9': 'vp9', 'AV1': 'av1'}
 
         self.quality_dropdown = SimBADropDown(parent=settings_frm, label="OUTPUT VIDEO QUALITY:", dropdown_options=list(range(10, 110, 10)), label_width=25, value=60, img='pct', dropdown_width=30)
         self.codec_dropdown = SimBADropDown(parent=settings_frm, label="COMPRESSION CODEC:", dropdown_options=list(self.WEBM_CODEC_LK.keys()), label_width=25, value='VP9', img='file_type', dropdown_width=30)

simba/video_processors/video_processing.py

@@ -56,7 +56,7 @@ from simba.utils.lookups import (get_current_time, get_ffmpeg_codec,
                                  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)
+                                 video_quality_to_preset_lookup, get_ffmpeg_encoders)
 from simba.utils.printing import SimbaTimer, stdout_information, stdout_success
 from simba.utils.read_write import (
     check_if_hhmmss_timestamp_is_valid_part_of_video,
@@ -440,10 +440,11 @@ def clahe_enhance_video(file_path: Union[str, os.PathLike],
     dir, file_name, file_ext = get_fn_ext(filepath=file_path)
     if out_path is None:
         save_path = os.path.join(dir, f"CLAHE_{file_name}.avi")
+        fourcc = cv2.VideoWriter_fourcc(*Formats.AVI_CODEC.value)
     else:
         check_if_dir_exists(in_dir=os.path.dirname(out_path), source=f'{clahe_enhance_video.__name__} out_path')
+        fourcc = cv2.VideoWriter_fourcc(*Formats.MP4_CODEC.value)
         save_path = out_path
-    fourcc = cv2.VideoWriter_fourcc(*Formats.AVI_CODEC.value)
     if verbose: print(f"Applying CLAHE on video {file_name}, this might take awhile...")
     cap = cv2.VideoCapture(file_path)
     writer = cv2.VideoWriter( save_path, fourcc, video_meta_data["fps"], (video_meta_data["width"], video_meta_data["height"]), 0)
@@ -3265,6 +3266,9 @@ def convert_to_avi(path: Union[str, os.PathLike],
     timer = SimbaTimer(start=True)
     check_ffmpeg_available(raise_error=True)
     check_str(name=f'{convert_to_avi.__name__} codec', value=codec, options=('xvid', 'divx', 'mjpeg'))
+    CODEC_LK = {'mpeg4': 'mpeg4', 'divx': 'libxvid', 'mjpeg': 'mjpeg'}
+    codec = CODEC_LK[codec]
+    check_valid_codec(codec=codec, raise_error=True, source=f'{convert_to_avi.__name__} codec')
     check_instance(source=f'{convert_to_avi.__name__} path', instance=path, accepted_types=(str,))
     check_int(name=f'{convert_to_avi.__name__} quality', value=quality)
     datetime_ = datetime.now().strftime("%Y%m%d%H%M%S")
@@ -3292,18 +3296,18 @@ def convert_to_avi(path: Union[str, os.PathLike],
         _ = get_video_meta_data(video_path=file_path)
         out_path = os.path.join(save_dir, f'{video_name}.avi')
         if codec == 'divx':
-            cmd = f'ffmpeg -i "{file_path}" -c:v mpeg4 -crf {crf} -vtag DIVX "{out_path}" -loglevel error -stats -hide_banner -y'
+            cmd = f'ffmpeg -i "{file_path}" -c:v {codec} -crf {crf} -vtag DIVX "{out_path}" -loglevel error -stats -hide_banner -y'
         elif codec == 'xvid':
-            cmd = f'ffmpeg -i "{file_path}" -c:v libxvid -q:v {qv} "{out_path}" -loglevel error -stats -hide_banner -y'
+            cmd = f'ffmpeg -i "{file_path}" -c:v {codec} -q:v {qv} "{out_path}" -loglevel error -stats -hide_banner -y'
         else:
-            cmd = f'ffmpeg -i "{file_path}" -c:v mjpeg -q:v {qv} "{out_path}" -loglevel error -stats -hide_banner -y'
+            cmd = f'ffmpeg -i "{file_path}" -c:v {codec} -q:v {qv} "{out_path}" -loglevel error -stats -hide_banner -y'
         subprocess.call(cmd, shell=True, stdout=subprocess.PIPE)
     timer.stop_timer()
     stdout_success(msg=f"{len(file_paths)} video(s) converted to AVI and saved in {save_dir} directory.", elapsed_time=timer.elapsed_time_str, source=convert_to_avi.__name__,)
 
 
 def convert_to_webm(path: Union[str, os.PathLike],
-                    codec: Literal['vp8', 'vp9'] = 'vp9',
+                    codec: Literal['vp8', 'vp9', 'av1'] = 'vp9',
                     save_dir: Optional[Union[str, os.PathLike]] = None,
                     quality: Optional[int] = 60) -> None:
 
@@ -3326,7 +3330,10 @@ def convert_to_webm(path: Union[str, os.PathLike],
 
     timer = SimbaTimer(start=True)
     check_ffmpeg_available(raise_error=True)
-    check_str(name=f'{convert_to_webm.__name__} codec', value=codec, options=('vp8', 'vp9'))
+    check_str(name=f'{convert_to_webm.__name__} codec', value=codec, options=('vp8', 'vp9', 'av1'))
+    CODEC_LK = {'vp8': 'libvpx', 'vp9': 'libvpx-vp9', 'av1': 'libaom-av1'}
+    codec = CODEC_LK[codec]
+    check_valid_codec(codec=codec, raise_error=True, source=f'{convert_to_webm.__name__} codec')
     check_instance(source=f'{convert_to_webm.__name__} path', instance=path, accepted_types=(str,))
     check_int(name=f'{convert_to_webm.__name__} quality', value=quality)
     datetime_ = datetime.now().strftime("%Y%m%d%H%M%S")
@@ -3346,17 +3353,13 @@ def convert_to_webm(path: Union[str, os.PathLike],
         os.makedirs(save_dir)
     else:
         raise InvalidInputError(msg=f'Paths is not a valid file or directory path.', source=convert_to_webm.__name__)
+
     for file_cnt, file_path in enumerate(file_paths):
         _, video_name, _ = get_fn_ext(filepath=file_path)
         print(f'Converting video {video_name} to WEBM (Video {file_cnt+1}/{len(file_paths)})...')
         _ = get_video_meta_data(video_path=file_path)
         out_path = os.path.join(save_dir, f'{video_name}.webm')
-        if codec == 'vp8':
-            cmd = f'ffmpeg -i "{file_path}" -c:v libvpx -crf {crf} "{out_path}" -loglevel error -stats -hide_banner -y'
-        elif codec == 'vp9':
-            cmd = f'ffmpeg -i "{file_path}" -c:v libvpx-vp9 -crf {crf} "{out_path}" -loglevel error -stats -hide_banner -y'
-        else:
-            cmd = f'ffmpeg -i "{file_path}" -c:v libaom-av1 -crf {crf} "{out_path}" -loglevel error -stats -hide_banner -y'
+        cmd = f'ffmpeg -i "{file_path}" -c:v {codec} -crf {crf} "{out_path}" -loglevel error -stats -hide_banner -y'
         subprocess.call(cmd, shell=True, stdout=subprocess.PIPE)
     timer.stop_timer()
     stdout_success(msg=f"{len(file_paths)} video(s) converted to WEBM and saved in {save_dir} directory.", elapsed_time=timer.elapsed_time_str, source=convert_to_webm.__name__,)
@@ -3381,6 +3384,10 @@ def convert_to_mov(path: Union[str, os.PathLike],
     timer = SimbaTimer(start=True)
     check_ffmpeg_available(raise_error=True)
     check_str(name=f'{convert_to_mov.__name__} codec', value=codec, options=('prores', 'animation', 'cineform', 'dnxhd'))
+
+
+
+
     check_instance(source=f'{convert_to_mov.__name__} path', instance=path, accepted_types=(str,))
     check_int(name=f'{convert_to_mov.__name__} quality', value=quality)
     datetime_ = datetime.now().strftime("%Y%m%d%H%M%S")

{simba_uw_tf_dev-4.7.5.dist-info → simba_uw_tf_dev-4.7.6.dist-info}/METADATA

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

{simba_uw_tf_dev-4.7.5.dist-info → simba_uw_tf_dev-4.7.6.dist-info}/RECORD

@@ -13,7 +13,7 @@ simba/__init__.py,sha256=Zbw277SaA4dLpF3IDQnIjzOb-GWKgF-V6caod95b4YA,539
 simba/requirements.txt,sha256=Ou1KKYqIsOaqQ10UeqxTPorpHWBH5rTMGzpFif1VRWc,2072
 simba/assets/.DS_Store,sha256=ElS4pjNueynnfN3F6ibhpIe9tS-jrVEx88jASA9_DYo,14340
 simba/assets/.env,sha256=bI_XK4TDnRDnV1M5SyZrEfeayi9ZK7rX2lrYQcJnH0s,538
-simba/assets/.recent_projects.txt,sha256=iUE8T6XQxOEGrK-r53XVeuz3xdjHgxeQPBogS4yZIyk,193
+simba/assets/.recent_projects.txt,sha256=18t7rzwuoVChVyfpME5c11LShZT9Frb8rEj6Puvfba8,265
 simba/assets/TheGoldenLab.PNG,sha256=Dwg7zXASz_XDhJ_gDgKyBmAINxLL-Zkg-3xzy94YEsc,31812
 simba/assets/UbuntuMono-Regular.ttf,sha256=N0xTF4v7xLE_m2rVu8gaQ5OqZSZf_H0zqnvYnxKjDfg,189004
 simba/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -621,7 +621,7 @@ simba/mixins/abstract_classes.py,sha256=umpVIU7EG_jZ1DU8x5zkTb8A-KH46jlCISowfrT4
 simba/mixins/annotator_mixin.py,sha256=TQWqBZ5UVR5blI5CUyr3nuxsB3HyrxYimPg3rXcOHfU,40917
 simba/mixins/circular_statistics.py,sha256=yzYRKsuY3xK_LgDC7rpu4OQnbSQpjXO0EiLv4kH6cp8,77336
 simba/mixins/config_reader.py,sha256=9su8ZGnGWghk5bAl12iaTQdqIOVfcW2ZQcxeEXmXtcI,52362
-simba/mixins/feature_extraction_mixin.py,sha256=rUwHEG3wKpyreme8nXAeBEhktHG_Q75v3OJI2aFOOOA,59587
+simba/mixins/feature_extraction_mixin.py,sha256=kOlU4FsqKxvDQ_UA9RrcvidTKv2sCitx_noZtHc6eyY,59585
 simba/mixins/feature_extraction_supplement_mixin.py,sha256=6dPi1WFi26y-rmccsMgDe5sULm4fTQaBcSiH91DEkN0,44770
 simba/mixins/geometry_mixin.py,sha256=QL16YFqSR0Wtio0v2PE2l41KTP_DKmW_tiGY6ns-Ojg,248630
 simba/mixins/image_mixin.py,sha256=C3FcZGp_kLMYMvbFxOedYPebIYm6KJIRPAB7rcu6J80,125807
@@ -806,6 +806,7 @@ simba/sandbox/append_targets'.py,sha256=f8lB0FFdJy97uZuEyfWsJYOf2Uw05skSGjH3uiLF
 simba/sandbox/apply_offsets.py,sha256=XKqGD3ihq0clkZUFF3JBuZP-KlcRFAPphHV-7VCGnQU,3601
 simba/sandbox/async_frame_writer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 simba/sandbox/async_frm_reader.py,sha256=aPs3RTHfnDuNHeGnKH6yeQmQAO4QestVQbeyMGhrzwU,4694
+simba/sandbox/av1.py,sha256=t5_RS-kJ0wNSkiVIZO9acSeJ5JLApqkqx1feYmFX9Ww,174
 simba/sandbox/average_frm_popup.py,sha256=E1nn5D_P8A8imnES6uskaXw5EMMieYEUL6-RjEl3atQ,9216
 simba/sandbox/baker_huber_gamma_index.py,sha256=Mki6-POmlN09NKAhHdKDIenNRwsbFhRLYXz8aZVn23A,2129
 simba/sandbox/bar_chart.py,sha256=kZCVZPq3Wrmt195NWkpNwdi1beaOxJ945xl1O4gS9Zg,2614
@@ -906,6 +907,7 @@ simba/sandbox/debug_csv_columns.py,sha256=uJwHZ1UQE6vFzTyFMbwf8qrWcL3KM7EafDmvIY
 simba/sandbox/debug_network.py,sha256=niyPStKhIpyom6AVREjYC_7aixnVdErlnz7yMaQxTOk,7125
 simba/sandbox/define_rois.py,sha256=UHxsbfe2b1GjbuNU6jfqXnFy3X_-B0I0CgZVqIw5TlA,1671
 simba/sandbox/denoise_gpu.py,sha256=vDiRuXMv-dyFMgomZMEiKJNPDmT9sinpXILcBOfAn9k,1832
+simba/sandbox/denoise_hqdn3d.py,sha256=dbpFKQSSS84PEkmpoBtX-8Yw6Ogl3iyK4T_Qq_Wx1Zo,14498
 simba/sandbox/denoiser.py,sha256=BXB_YAnUXCDe3csnT3cT5YLes9oRS0immjA5P4YP2hs,10324
 simba/sandbox/detect_scene_changes.py,sha256=P7tmHoFH55ryTXwgY2cVxXQiVNCRaf_4hVi1Nd-ZOCA,561
 simba/sandbox/dir_to_mosaic.py,sha256=rNnxJlEyJMG8jXmWx-NgEcS9hHQ3sqOlLQ-hYTEg7P4,1576
@@ -950,6 +952,7 @@ simba/sandbox/extract_and_convert_videos.py,sha256=nE3ncyoRb8Ac_vdbxSK1D2-Lqr71M
 simba/sandbox/extract_annotation_frames_pop_up.py,sha256=EYHEL5SlpvLpeFPnGmeib5LL97mkkdlb3fhaDcYehAk,5783
 simba/sandbox/extract_aucio_track.py,sha256=tTp0PlTXt76-fDf-E695NZ1cxlS36Wb783dE0ZoF7k0,3092
 simba/sandbox/extract_frames.py,sha256=J4POX21DXP92lYhvZUiYcZAGmT-kp6Y3ICkMb-pjkxA,838
+simba/sandbox/extract_random_frames.py,sha256=pBtJ1WEDNdI9er8LrclxHSCqM7xoZ7ocww48VfnTQm0,5225
 simba/sandbox/ez_path_plot.py,sha256=euSazuxyIRWaHrlhiOMjDugqMba8SvsRWUuOl78M6MI,6409
 simba/sandbox/feature_subset_new.py,sha256=OF-wTPvktqJbyBPctIqMWS1qgyMlMsStX_Ddrn31CCw,23088
 simba/sandbox/fecal_boli.py,sha256=pdInnlZ94sNgVQAmsQRbT0Sw1qz9JPWaowEkscTErkc,1636
@@ -1471,7 +1474,7 @@ simba/ui/pop_ups/subset_feature_extractor_pop_up.py,sha256=M24iJSqh-DpYdpw1pSaIm
 simba/ui/pop_ups/targeted_annotation_clips_pop_up.py,sha256=PFh5ua2f_OMQ1Pth9Ha8Fo5lTPZNQV3bMnRGEoAPhTQ,6997
 simba/ui/pop_ups/third_party_annotator_appender_pop_up.py,sha256=Xnha2UwM-08djObCkL_EXK2L4pernyipzbyNKQvX5aQ,7694
 simba/ui/pop_ups/validation_plot_pop_up.py,sha256=yIo_el2dR_84ZAh_-2fYFg-BJDG0Eip_P_o9vzTQRkk,12174
-simba/ui/pop_ups/video_processing_pop_up.py,sha256=u9AZMY6HcrcputziJ_b16L29HyT3m0arTW02eR1doFg,252005
+simba/ui/pop_ups/video_processing_pop_up.py,sha256=_7nVjWkXoLuvxIjEEAJjzWe7Lf1H_HAWbNp31ZB6AvA,252019
 simba/ui/pop_ups/visualize_pose_in_dir_pop_up.py,sha256=PpFs0zaqF4dnHJ_yH-PqYgsjAyxYPVP427Soj-kYtM0,8838
 simba/ui/pop_ups/yolo_inference_popup.py,sha256=C4_WDvEHLp9JMUTjLZuRpKHxMCGpa_pxXELuj-zerCs,14679
 simba/ui/pop_ups/yolo_plot_results.py,sha256=yi9D3WquDu4L8PWJLZsODulojgakfy7Dzh_CpYK6Vgk,10096
@@ -1541,11 +1544,11 @@ simba/video_processors/multi_cropper.py,sha256=1BI0Ami4kB9rdMUHR0EistmIKqc-E5FK5
 simba/video_processors/roi_selector.py,sha256=5N3s0Bi1Ub6c9gjE_-mV7AWr8Fqg7HQKdBKBF6whurg,8522
 simba/video_processors/roi_selector_circle.py,sha256=SD_lv6V3MGiIQd0VtUFSKe83ySW_qvE1t8xsgAlr2hI,6436
 simba/video_processors/roi_selector_polygon.py,sha256=DMtilt__gGwNu6VV73CWbnPqrPBXkan1_akUqGEzfGw,6742
-simba/video_processors/video_processing.py,sha256=ynHC-9-Pt020GMZa5xPDhfpouHS5i6D26mT-5F9NAY0,327790
+simba/video_processors/video_processing.py,sha256=SOocFxbo5O5TXpH1ClO19-Rhn7CKHQ82wLasfmTUT8M,327985
 simba/video_processors/videos_to_frames.py,sha256=8hltNZpwUfb3GFi-63D0PsySmD5l59pbzQGJx8SscgU,7818
-simba_uw_tf_dev-4.7.5.dist-info/LICENSE,sha256=Sjn362upcvYFypam-b-ziOXU1Wl5GGuTt5ICrGimzyA,1720
-simba_uw_tf_dev-4.7.5.dist-info/METADATA,sha256=JduCaUVbf9SLKDXxS9bVrRblmH2-IMuVU1PQ_LwGhOk,11432
-simba_uw_tf_dev-4.7.5.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-simba_uw_tf_dev-4.7.5.dist-info/entry_points.txt,sha256=Nfh_EbfDGdKftLjCnGWtQrBHENiDYMdgupwLyLpU5dc,44
-simba_uw_tf_dev-4.7.5.dist-info/top_level.txt,sha256=ogtimvlqDxDTOBAPfT2WaQ2pGAAbKRXG8z8eUTzf6TU,14
-simba_uw_tf_dev-4.7.5.dist-info/RECORD,,
+simba_uw_tf_dev-4.7.6.dist-info/LICENSE,sha256=Sjn362upcvYFypam-b-ziOXU1Wl5GGuTt5ICrGimzyA,1720
+simba_uw_tf_dev-4.7.6.dist-info/METADATA,sha256=hp7yO2XbbWvm182wc7TgReqkM40vYpLB591vqNKNlc4,11432
+simba_uw_tf_dev-4.7.6.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+simba_uw_tf_dev-4.7.6.dist-info/entry_points.txt,sha256=Nfh_EbfDGdKftLjCnGWtQrBHENiDYMdgupwLyLpU5dc,44
+simba_uw_tf_dev-4.7.6.dist-info/top_level.txt,sha256=ogtimvlqDxDTOBAPfT2WaQ2pGAAbKRXG8z8eUTzf6TU,14
+simba_uw_tf_dev-4.7.6.dist-info/RECORD,,