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

simba/assets/.recent_projects.txt

@@ -1,3 +1,5 @@
+E:/troubleshooting/mitra_pbn/mitra_pbn/project_folder/project_config.ini
+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/assets/lookups/tooptips.json

@@ -5,7 +5,7 @@
   "batch_dropdown": "Number of frames processed at once. Larger batches speed up inference but require more GPU RAM.",
   "verbose_dropdown": "Toggle console printouts for progress and timings. Keep TRUE while tuning, FALSE for quiet runs.",
   "workers_dropdown": "How many CPU worker threads to use for pre/post-processing. Set <= available cores.",
-  "format_dropdown": "Model serialization format (None = auto-detect from file extension). Match the format used when exporting the weights.",
+  "format_dropdown": "Export/serialization format. Training: export the trained model to this format after training (None = PyTorch .pt only). Inference: match the format of your weights file, or None to auto-detect from file extension. Options: onnx, engine, torchscript, onnxsimplify, coreml, openvino, pb, tf, tflite, torch.",
   "img_size_dropdown": "Resize shorter image side to this many pixels before inference. Larger sizes improve accuracy but slow down processing.",
   "devices_dropdown": "Compute device to run on. Select CUDA device ID for GPU or CPU.",
   "interpolate_dropdown": "Fill missing detections by interpolating coordinates over time. Recommended for cleaner trajectories.",
@@ -43,5 +43,27 @@
   "KLEINBERG_GAMMA": "Higher values (e.g., 0.5-1.0) reduce total burst count by making downward transitions costly; lower values (e.g., 0.1-0.3) allow more flexible state changes",
   "KLEINBERG_HIERARCHY": "Hierarchy level to extract bursts from (0=lowest, higher=more selective).\n Level 0 captures all bursts; level 1-2 typically filters noise; level 3+ selects only the most prominent, sustained bursts.\nHigher levels yield fewer but more confident detections",
   "KLEINBERG_HIERARCHY_SEARCH": "If True, searches for target hierarchy level within detected burst periods,\n falling back to lower levels if target not found. If False, extracts only bursts at the exact specified hierarchy level.\n Recommended when target hierarchy may be sparse.",
-  "KLEINBERG_SAVE_ORIGINALS": "If True, saves the original data in a new sub-directory of \nthe project_folder/csv/machine_results directory"
+  "KLEINBERG_SAVE_ORIGINALS": "If True, saves the original data in a new sub-directory of \nthe project_folder/csv/machine_results directory",
+  "yolo_map_path": "Path to the YOLO dataset YAML file. Defines class names, paths to train/val images and labels, and number of keypoints.",
+  "yolo_initial_weights_path": "Optional path to pretrained weights (.pt) to start training from (e.g. yolo11n-pose.pt). Leave blank to train from scratch.",
+  "epochs_dropdown": "Number of training epochs. More epochs can improve accuracy but increase overfitting risk and training time.",
+  "plots_dropdown": "If TRUE, generate and save training curves (loss, mAP, etc.) in the save directory.",
+  "patience_dropdown": "Early-stopping patience: training stops if validation metric does not improve for this many epochs.",
+  "simba2yolo_config": "Path to the SimBA project configuration file (.ini). Defines project paths, body-parts, and animals.",
+  "simba2yolo_train_size": "Percentage of sampled frames to use for the YOLO training set. The remainder is used for validation. E.g. 70 means 70% train, 30% val.",
+  "simba2yolo_padding": "Extra margin (as a fraction of image size) added around the keypoint bounding box. Use a small value (e.g. 0.05–0.2) if the tight box cuts off body parts or you want more context in each crop; None or 0 = no padding.",
+  "simba2yolo_sample_size": "Maximum number of frames to sample per video for creating YOLO images and labels. Higher values give more data but increase processing time.",
+  "simba2yolo_grey": "If TRUE, extracted video frames are saved in greyscale. If FALSE, frames are saved in color.",
+  "simba2yolo_clahe": "If TRUE, apply CLAHE (Contrast Limited Adaptive Histogram Equalization) to frames before saving. Can improve keypoint visibility in low-contrast videos.",
+  "yolo_plot_line_thickness": "Thickness of the lines drawn between keypoints (skeleton). AUTO lets the plotter choose based on video size; or set 1–20 pixels.",
+  "yolo_plot_circle_size": "Radius of the circles drawn at each keypoint. AUTO lets the plotter choose based on video size; or set 1–20 pixels.",
+  "yolo_plot_tracks": "If TRUE, draw trajectory paths (tracks) for each detected instance over time. If FALSE, draw only keypoints and skeleton per frame.",
+  "yolo_plot_data_path": "Path to a single YOLO pose result CSV (output from YOLO pose inference). Must match the video you select.",
+  "yolo_plot_video_path": "Path to the video file to overlay pose results onto. Filename should match the data CSV (without extension).",
+  "yolo_plot_data_dir": "Directory containing YOLO pose result CSV files. Used for batch plotting; each CSV is matched to a video of the same name in the video directory.",
+  "SLEAP_DATA_DIR": "Directory containing SLEAP CSV prediction files. Each CSV should match a video filename (without extension).",
+  "ANIMAL_COUNT": "Number of animals (tracks) in the videos. Used to name classes (e.g. animal_1, animal_2) in the YOLO dataset.",
+  "sleap_remove_animal_ids": "If TRUE, merge all tracks into a single identity (animal_1). Use when animal IDs are not meaningful or for single-animal data.",
+  "sleap_threshold": "Minimum SLEAP instance confidence (the instance.score column in the CSV). Only pose predictions with score ≥ this value are used when building the YOLO dataset. E.g. 90 means keep instances where instance.score ≥ 0.9; lower values include more frames but may add noisy predictions.",
+  "SLEAP_SLP_DATA_DIR": "Directory containing SLEAP .SLP project/annotation files. Each .SLP file is converted to YOLO pose format."
 }

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/model/yolo_fit.py

@@ -1,5 +1,6 @@
 import os
 import sys
+import urllib.request
 from contextlib import redirect_stderr, redirect_stdout
 
 os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
@@ -19,13 +20,19 @@ except ModuleNotFoundError:
 from simba.data_processors.cuda.utils import _is_cuda_available
 from simba.utils.checks import (check_file_exist_and_readable,
                                 check_if_dir_exists, check_int, check_str,
-                                check_valid_boolean, check_valid_device)
+                                check_valid_boolean, check_valid_device,
+                                check_valid_url)
 from simba.utils.enums import Options
 from simba.utils.errors import SimBAGPUError, SimBAPAckageVersionError
 from simba.utils.printing import stdout_information
 from simba.utils.read_write import find_core_cnt, get_current_time
 from simba.utils.yolo import load_yolo_model
 
+#YOLO_X_PATH = "https://huggingface.co/Ultralytics/YOLO11/resolve/main/yolo11x-pose.pt"
+
+YOLO_M_PATH = "https://huggingface.co/Ultralytics/YOLO11/resolve/main/yolo11m-pose.pt"
+
+
 
 class FitYolo():
 
@@ -74,9 +81,9 @@ class FitYolo():
     """
 
     def __init__(self,
-                 weights_path: Union[str, os.PathLike],
                  model_yaml: Union[str, os.PathLike],
                  save_path: Union[str, os.PathLike],
+                 weights_path: Optional[Union[str, os.PathLike]] = None,
                  epochs: int = 200,
                  batch: Union[int, float] = 16,
                  plots: bool = True,
@@ -92,7 +99,11 @@ class FitYolo():
             raise SimBAGPUError(msg='No GPU detected.', source=self.__class__.__name__)
         if YOLO is None:
             raise SimBAPAckageVersionError(msg='Ultralytics package not detected.', source=self.__class__.__name__)
-        check_file_exist_and_readable(file_path=weights_path)
+        if weights_path is not None:
+            check_file_exist_and_readable(file_path=weights_path)
+            self.weights_path = weights_path
+        else:
+            self._download_start_weights()
         check_file_exist_and_readable(file_path=model_yaml)
         check_valid_boolean(value=verbose, source=f'{__class__.__name__} verbose', raise_error=True)
         check_valid_boolean(value=plots, source=f'{__class__.__name__} plots', raise_error=True)
@@ -106,12 +117,19 @@ class FitYolo():
         check_valid_device(device=device)
         self.model_yaml, self.epochs, self.batch  = model_yaml, epochs, batch
         self.imgsz, self.device, self.workers, self.format = imgsz, device, workers, format
-        self.plots, self.save_path, self.verbose, self.weights_path, self.patience = plots, save_path, verbose, weights_path, patience
+        self.plots, self.save_path, self.verbose, self.patience = plots, save_path, verbose, patience
+
+    def _download_start_weights(self, url: str = YOLO_M_PATH, save_path: Union[str, os.PathLike] = "yolo11m-pose.pt"):
+        print(f'No start weights provided, downloading {save_path} from {url}...')
+        check_valid_url(url=url, raise_error=True, source=self.__class__.__name__)
+        if not os.path.isfile(save_path):
+            urllib.request.urlretrieve(url, save_path)
+            stdout_information(msg=f'Downloaded initial weights from {url}', source=self.__class__.__name__)
+        self.weights_path = save_path
+        print(self.weights_path)
 
 
     def run(self):
-        # Temporarily redirect stdout/stderr to terminal to ensure ultralytics output goes to terminal
-        # sys.__stdout__ and sys.__stderr__ are the original terminal streams
         stdout_information(msg=f'[{get_current_time()}] Please follow the YOLO pose model training in the terminal from where SimBA was launched ...', source=self.__class__.__name__)
         stdout_information(msg=f'[{get_current_time()}] Results will be stored in the {self.save_path} directory ..', source=self.__class__.__name__)
         with redirect_stdout(sys.__stdout__), redirect_stderr(sys.__stderr__):
@@ -133,7 +151,7 @@ class FitYolo():
 
 if __name__ == "__main__" and not hasattr(sys, 'ps1'):
     parser = argparse.ArgumentParser(description="Fit YOLO model using ultralytics package.")
-    parser.add_argument('--weights_path', type=str, required=True, help='Path to the trained YOLO model weights (e.g., yolo11n-pose.pt)')
+    parser.add_argument('--weights_path', type=str, default=None, help='Path to the trained YOLO model weights (e.g., yolo11n-pose.pt). Omit to download default starter weights.')
     parser.add_argument('--model_yaml', type=str, required=True, help='Path to map.yaml (model structure and label definitions)')
     parser.add_argument('--save_path', type=str, required=True, help='Directory where trained model and logs will be saved')
     parser.add_argument('--epochs', type=int, default=25, help='Number of epochs to train the model. Default is 25')
@@ -146,7 +164,6 @@ if __name__ == "__main__" and not hasattr(sys, 'ps1'):
     parser.add_argument('--workers', type=int, default=8, help='Number of data loader workers. Default is 8. Use -1 for max cores')
     parser.add_argument('--patience', type=int, default=100, help='Number of epochs to wait without improvement in validation metrics before early stopping the training. Default is 100')
 
-
     args = parser.parse_args()
 
     yolo_fitter = FitYolo(weights_path=args.weights_path,
@@ -159,11 +176,27 @@ if __name__ == "__main__" and not hasattr(sys, 'ps1'):
                           format=args.format,
                           device=int(args.device) if args.device != 'cpu' else 'cpu',
                           verbose=args.verbose,
-                          workers=args.workers)
+                          workers=args.workers,
+                          patience=args.patience)
     yolo_fitter.run()
 
 
 
+
+
+# fitter = FitYolo(weights_path=r"D:\maplight_tg2576_yolo\yolo_mdl\original_weight_oct\best.pt",
+#                  model_yaml=r"D:\maplight_tg2576_yolo\yolo_mdl\map.yaml",
+#                  save_path=r"D:\maplight_tg2576_yolo\yolo_mdl\mdl",
+#                  epochs=1500,
+#                  batch=22,
+#                  format=None,
+#                  device=0,
+#                  imgsz=640)
+# fitter.run()
+
+
+
+
 # fitter = FitYolo(weights_path=r"E:\yolo_resident_intruder\mdl\train3\weights\best.pt",
 #                  model_yaml=r"E:\maplight_videos\yolo_mdl\map.yaml",
 #                  save_path=r"E:\maplight_videos\yolo_mdl\mdl",

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/clean_sleap.py

@@ -0,0 +1,4 @@
+from simba.utils.read_write import clean_sleap_file_name
+
+
+clean_sleap_file_name(filename=f'2026-01-09 11-53-23 box1_1143_0_Gq_5cno.predictions.000_2026-01-09 11-53-23 box1_1143_0_Gq_5cno.analysis.csv')

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/third_party_label_appenders/transform/coco_keypoints_to_yolo.py

@@ -75,7 +75,7 @@ class COCOKeypoints2Yolo:
                  img_dir: Union[str, os.PathLike],
                  save_dir: Union[str, os.PathLike],
                  train_size: float = 0.7,
-                 flip_idx: Tuple[int, ...] = (0, 2, 1, 3, 5, 4, 6, 7, 8),
+                 flip_idx: Tuple[int, ...] = (0, 2, 1, 5, 4, 3, 6),
                  verbose: bool = True,
                  greyscale: bool = False,
                  clahe: bool = False,
@@ -175,7 +175,6 @@ class COCOKeypoints2Yolo:
         missing = [x for x in list(range(shapes[0])) if x not in self.flip_idx]
         if len(missing) > 0:
             raise InvalidInputError(msg=f'keypoints contains index values not in flip_idx ({missing}).', source=self.__class__.__name__)
-
         create_yolo_keypoint_yaml(path=self.save_dir, train_path=self.train_img_dir, val_path=self.val_img_dir, names=self.map_dict, save_path=self.map_path, kpt_shape=(int(shapes[0]), 3), flip_idx=self.flip_idx)
         timer.stop_timer()
         if self.verbose: stdout_success(msg=f'COCO keypoints to YOLO conversion complete. Data saved in directory {self.save_dir}.', elapsed_time=timer.elapsed_time_str)