simba-uw-tf-dev 5.3.7__tar.gz → 5.3.8__tar.gz

{simba_uw_tf_dev-5.3.7 → simba_uw_tf_dev-5.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba_uw_tf_dev
-Version: 5.3.7
+Version: 5.3.8
 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
@@ -57,7 +57,7 @@ If you use the code, please cite:
 ```
 
 ### Licence
-SimBA is licensed under GNU Lesser General Public License v3.0.
+SimBA is licensed under a modified BSD 3-Clause License, permitting use for academic and research purposes only. For commercial licensing inquiries, contact sronilsson@gmail.com.
 
 ### Contributors
 Contributers on Github https://github.com/sgoldenlab/simba#contributors

{simba_uw_tf_dev-5.3.7 → simba_uw_tf_dev-5.3.8}/README.md

@@ -4,7 +4,7 @@
 [![py3.10 tests](https://github.com/sgoldenlab/simba/actions/workflows/tests_py310.yml/badge.svg)](https://github.com/sgoldenlab/simba/actions/workflows/tests_py310.yml)
 [![py3.6 tests](https://github.com/sgoldenlab/simba/actions/workflows/tests_py36.yml/badge.svg)](https://github.com/sgoldenlab/simba/actions/workflows/tests_py36.yml)
 ![Docs](https://readthedocs.org/projects/simba-uw-tf-dev/badge/?version=latest&style=flat)
-[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+[![License: Modified BSD 3-Clause](https://img.shields.io/badge/License-Modified%20BSD%203--Clause%20(Academic%2FResearch)-blue.svg)](LICENSE)
 [![Gitter chat](https://badges.gitter.im/USER/REPO.png)](https://gitter.im/SimBA-Resource/community)
 [![Download: Weights](https://img.shields.io/badge/Download-Weights-orange.svg)](https://osf.io/5t4y9/)
 [![SimBA: listserv](https://img.shields.io/static/v1?label=SimBA&message=listserv&color=blue)](https://docs.google.com/forms/d/e/1FAIpQLSfjbjae0XqNcl7GYOxmqvRsCveG-cmf4p4hBNNJ8gu5vPLHng/viewform)

{simba_uw_tf_dev-5.3.7 → simba_uw_tf_dev-5.3.8}/setup.py

@@ -3,7 +3,8 @@ SimBA (Simple Behavioral Analysis)
 https://github.com/sgoldenlab/simba
 Contributors.
 https://github.com/sgoldenlab/simba#contributors-
-Licensed under GNU Lesser General Public License v3.0
+Licensed under a modified BSD 3-Clause License (academic and research use only).
+For commercial licensing inquiries, contact sronilsson@gmail.com.
 """
 
 import setuptools
@@ -29,7 +30,7 @@ with open(GPU_REQUIREMENTS_PATH, "r") as f:
 # Setup configuration
 setuptools.setup(
     name="simba_uw_tf_dev",
-    version="5.3.7",
+    version="5.3.8",
     author="Simon Nilsson, Jia Jie Choong, Sophia Hwang",
     author_email="sronilsson@gmail.com",
     description="Toolkit for computer classification and analysis of behaviors in experimental animals",

simba_uw_tf_dev-5.3.8/simba/plotting/compare_bbox_mdls.py

@@ -0,0 +1,289 @@
+__author__ = "Simon Nilsson; sronilsson@gmail.com"
+
+import os
+
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+
+from typing import Dict, List, Optional, Tuple, Union
+
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal
+
+try:
+    from ultralytics import YOLO
+except ModuleNotFoundError:
+    YOLO = None
+
+from simba.data_processors.cuda.utils import _is_cuda_available
+from simba.model.yolo_inference import YoloInference
+from simba.plotting.yolo_visualize import YOLOVisualizer
+from simba.utils.checks import (check_file_exist_and_readable, check_float,
+                                check_if_dir_exists,
+                                check_if_string_value_is_valid_video_timestamp,
+                                check_int,
+                                check_that_hhmmss_start_is_before_end,
+                                check_valid_boolean, check_valid_lst)
+from simba.utils.data import get_cpu_pool, terminate_cpu_pool
+from simba.utils.enums import Options
+from simba.utils.errors import (InvalidInputError, InvalidVideoFileError,
+                                SimBAGPUError, SimBAPAckageVersionError)
+from simba.utils.printing import SimbaTimer, stdout_information, stdout_success
+from simba.utils.read_write import (find_core_cnt,
+                                    find_files_of_filetypes_in_directory,
+                                    get_fn_ext, get_video_meta_data)
+from simba.utils.yolo import get_yolo_imgsz_and_batch_size
+from simba.video_processors.video_processing import (
+    clip_video_in_range, horizontal_video_concatenator, superimpose_freetext)
+
+ENGINE = '.engine'
+
+
+class YoloModelComparator():
+    """
+    Compare two or more YOLO models side-by-side on a set of test videos.
+
+    Per-model CSV detections and visualization videos are written to``out_dir/<label>/`` and the final comparison videos to ``out_dir/compare/``.
+
+    .. seealso::
+       :class:`~simba.model.yolo_inference.YoloInference` (per-model inference)
+       :class:`~simba.plotting.yolo_visualize.YOLOVisualizer` (per-model rendering)
+       :func:`~simba.video_processors.video_processing.horizontal_video_concatenator` (side-by-side concat)
+
+    :param List[Union[str, os.PathLike]] weights: List of YOLO model weight paths (length >= 2).
+    :param Union[str, os.PathLike, List[Union[str, os.PathLike]]] video_path: One of: a single video file path; a directory of videos (searched non-recursively); or a list/tuple of video file paths.
+    :param Union[str, os.PathLike] out_dir: Output directory. Per-model CSV/viz subdirectories and a ``compare/`` subdirectory are created underneath.
+    :param Optional[List[str]] labels: Display labels (one per model). If None, the weight file name (without extension) of each model is used. Must be unique and match ``len(weights)``.
+    :param float threshold: YOLO detection confidence threshold in ``[0.0, 1.0]``.
+    :param Union[Literal['cpu'], int] device: Inference device ('cpu' or CUDA index).
+    :param Optional[int] batch_size: Frames per YOLO inference batch. If None, it is read per-model from the model metadata (required for ``.engine`` files); falls back to 400 when unavailable (e.g. ``.pt`` weights).
+    :param Optional[int] imgsz: Model inference image size. If None, it is read per-model from the model metadata; falls back to 320 when unavailable. For ``.engine`` files the engine's baked-in image size always wins (a mismatching explicit value is overridden with a warning).
+    :param int max_detections: Maximum detections per frame.
+    :param Optional[str] palette: Matplotlib palette passed to ``YOLOVisualizer``.
+    :param float opacity: Polygon fill opacity in ``[0.0, 1.0]`` for the visualization.
+    :param Optional[int] thickness: Polygon line thickness.
+    :param int padding: Polygon offset in pixels for the visualization. Defaults to 0 (draw the exact detection box). Positive values expand polygons outward, ``-1`` shrinks them inward.
+    :param Optional[Tuple[int, int, int]] outline_color: BGR outline color for polygons.
+    :param Optional[int] core_cnt: CPU core count for the visualizer. If None, defaults to a quarter of the available cores to leave headroom; ``-1`` = all cores.
+    :param bool gpu: Use the NVENC codec when concatenating side-by-side.
+    :param bool overwrite: If True (default), always re-render comparison videos. If False, skip videos whose comparison output already exists.
+    :param bool overlay_labels: If True, burns each model's ``label`` into the top-left corner of its panel before side-by-side concatenation, so the panels are self-describing.
+    :param Optional[Dict[str, str]] time_window: Analysis window as a dict with ``'start'`` and ``'end'`` keys, both in ``HH:MM:SS`` format (e.g. ``{'start': '00:00:05', 'end': '00:00:30'}``). If provided, each video is clipped to the window (saved under ``out_dir/clips/``) and the comparison runs on the clip. If None, the full video is analysed.
+    :param bool verbose: Print progress information.
+
+    :example:
+    >>> c = YoloModelComparator(
+    ...     weights=[r"/mdl/train8/weights/best.pt", r"/mdl/train13/weights/best.pt"],
+    ...     video_path=r"/test_videos",
+    ...     out_dir=r"/yolo_comparison",
+    ...     labels=["train8", "train13"],
+    ...     threshold=0.05,
+    ...     max_detections=1,
+    ...     device=0,
+    ... )
+    >>> c.run()
+    """
+
+    def __init__(self,
+                 weights: List[Union[str, os.PathLike]],
+                 video_path: Union[str, os.PathLike, List[Union[str, os.PathLike]]],
+                 out_dir: Union[str, os.PathLike],
+                 labels: Optional[List[str]] = None,
+                 threshold: float = 0.05,
+                 device: Union[Literal['cpu'], int] = 0,
+                 batch_size: Optional[int] = None,
+                 imgsz: Optional[int] = None,
+                 max_detections: int = 300,
+                 palette: Optional[str] = 'Set1',
+                 opacity: float = 0.6,
+                 thickness: Optional[int] = 2,
+                 padding: int = 0,
+                 outline_color: Optional[Tuple[int, int, int]] = None,
+                 core_cnt: Optional[int] = None,
+                 gpu: bool = False,
+                 overwrite: bool = True,
+                 overlay_labels: bool = True,
+                 time_window: Optional[Dict[str, str]] = None,
+                 verbose: bool = True):
+
+        if not _is_cuda_available()[0]:
+            raise SimBAGPUError(msg='No GPU detected.', source=self.__class__.__name__)
+        if YOLO is None:
+            raise SimBAPAckageVersionError(msg='ultralytics.YOLO package not detected.', source=self.__class__.__name__)
+        check_valid_lst(data=weights, source=f'{self.__class__.__name__} weights', valid_dtypes=(str, os.PathLike), min_len=2)
+        for w in weights:
+            check_file_exist_and_readable(file_path=w)
+        if labels is None:
+            labels = [get_fn_ext(filepath=w)[1] for w in weights]
+        check_valid_lst(data=labels, source=f'{self.__class__.__name__} labels', valid_dtypes=(str,), exact_len=len(weights))
+        if len(set(labels)) != len(labels):
+            raise InvalidInputError(msg=f'labels must be unique, got: {labels}', source=self.__class__.__name__)
+        if isinstance(video_path, (list, tuple)):
+            check_valid_lst(data=video_path, source=f'{self.__class__.__name__} video_path', valid_dtypes=(str, os.PathLike), min_len=1)
+            for v in video_path:
+                check_file_exist_and_readable(file_path=v)
+                get_video_meta_data(video_path=v)
+            self.video_paths = list(video_path)
+        elif os.path.isfile(video_path):
+            check_file_exist_and_readable(file_path=video_path)
+            get_video_meta_data(video_path=video_path)
+            self.video_paths = [video_path]
+        elif os.path.isdir(video_path):
+            self.video_paths = find_files_of_filetypes_in_directory(directory=video_path, extensions=Options.ALL_VIDEO_FORMAT_OPTIONS.value, raise_error=True, as_dict=False)
+        else:
+            raise InvalidVideoFileError(msg=f'{video_path} is not a valid video file, directory, or list of video files.', source=self.__class__.__name__)
+        check_if_dir_exists(in_dir=out_dir, source=f'{self.__class__.__name__} out_dir', create_if_not_exist=True)
+        check_float(name=f'{self.__class__.__name__} threshold', value=threshold, min_value=0.0, max_value=1.0)
+        if batch_size is not None:
+            check_int(name=f'{self.__class__.__name__} batch_size', value=batch_size, min_value=1)
+        if imgsz is not None:
+            check_int(name=f'{self.__class__.__name__} imgsz', value=imgsz, min_value=32)
+        check_int(name=f'{self.__class__.__name__} max_detections', value=max_detections, min_value=1)
+        if core_cnt is None:
+            core_cnt = find_core_cnt()[1]
+        check_int(name=f'{self.__class__.__name__} core_cnt', value=core_cnt, min_value=-1, unaccepted_vals=[0])
+        check_float(name=f'{self.__class__.__name__} opacity', value=opacity, min_value=0.0, max_value=1.0)
+        check_valid_boolean(value=[gpu, overwrite, overlay_labels, verbose], source=self.__class__.__name__)
+        self.start_time, self.end_time = None, None
+        if time_window is not None:
+            if not isinstance(time_window, dict) or set(time_window.keys()) != {'start', 'end'}:
+                raise InvalidInputError(msg=f"time_window must be a dict with exactly 'start' and 'end' keys in HH:MM:SS format, got: {time_window}", source=self.__class__.__name__)
+            check_if_string_value_is_valid_video_timestamp(value=time_window['start'], name=f'{self.__class__.__name__} time_window start')
+            check_if_string_value_is_valid_video_timestamp(value=time_window['end'], name=f'{self.__class__.__name__} time_window end')
+            check_that_hhmmss_start_is_before_end(start_time=time_window['start'], end_time=time_window['end'], name=f'{self.__class__.__name__} time_window')
+            self.start_time, self.end_time = time_window['start'], time_window['end']
+
+        self.weights, self.labels = list(weights), list(labels)
+        self.video_path, self.out_dir = video_path, out_dir
+        self.threshold, self.device, self.batch_size, self.imgsz = threshold, device, batch_size, imgsz
+        self.max_detections, self.palette, self.opacity = max_detections, palette, opacity
+        self.thickness, self.padding, self.outline_color = thickness, padding, outline_color
+        self.core_cnt, self.gpu, self.overwrite, self.verbose = core_cnt, gpu, overwrite, verbose
+        self.overlay_labels = overlay_labels
+        self.clip_videos = self.start_time is not None
+        self.compare_dir = os.path.join(out_dir, 'compare')
+        os.makedirs(self.compare_dir, exist_ok=True)
+        if self.clip_videos:
+            self.clips_dir = os.path.join(out_dir, 'clips')
+            os.makedirs(self.clips_dir, exist_ok=True)
+        self.csv_dirs, self.viz_dirs = {}, {}
+        for label in self.labels:
+            csv_dir = os.path.join(out_dir, label, 'csv')
+            viz_dir = os.path.join(out_dir, label, 'viz')
+            os.makedirs(csv_dir, exist_ok=True)
+            os.makedirs(viz_dir, exist_ok=True)
+            self.csv_dirs[label] = csv_dir
+            self.viz_dirs[label] = viz_dir
+
+    def _resolve_imgsz_batch(self, weight: Union[str, os.PathLike], label: str) -> Tuple[int, int]:
+        """Resolve the effective imgsz/batch_size for a single model. Engine bindings are authoritative; otherwise the user value, then the model metadata, then a default is used."""
+        is_engine = get_fn_ext(filepath=weight)[2].lower() == ENGINE
+        mdl_imgsz, mdl_batch = get_yolo_imgsz_and_batch_size(model=weight, raise_error=False)
+        if is_engine and mdl_imgsz is not None:
+            if self.imgsz is not None and self.imgsz != mdl_imgsz and self.verbose:
+                stdout_information(msg=f'{label}: passed imgsz={self.imgsz} overridden by engine imgsz={mdl_imgsz}.', source=self.__class__.__name__)
+            imgsz = mdl_imgsz
+        else:
+            imgsz = self.imgsz if self.imgsz is not None else (mdl_imgsz if mdl_imgsz is not None else 320)
+        if is_engine and mdl_batch is not None:
+            if self.batch_size is not None and self.batch_size != mdl_batch and self.verbose:
+                stdout_information(msg=f'{label}: passed batch_size={self.batch_size} overridden by engine batch_size={mdl_batch}.', source=self.__class__.__name__)
+            batch_size = mdl_batch
+        else:
+            batch_size = self.batch_size if self.batch_size is not None else (mdl_batch if mdl_batch is not None else 400)
+        return imgsz, batch_size
+
+    def _clip_videos(self) -> List[Union[str, os.PathLike]]:
+        """Clip every source video to ``[start_time, end_time]`` into ``out_dir/clips/`` and return the clipped paths. Existing clips are reused when ``overwrite`` is False."""
+        clipped_paths = []
+        for video_path in self.video_paths:
+            _, video_name, _ = get_fn_ext(filepath=video_path)
+            save_path = os.path.join(self.clips_dir, f'{video_name}_clipped.mp4')
+            if os.path.isfile(save_path) and not self.overwrite:
+                if self.verbose:
+                    stdout_information(msg=f'{video_name}: clip exists, reusing {save_path}.', source=self.__class__.__name__)
+            else:
+                clip_video_in_range(file_path=video_path, start_time=self.start_time, end_time=self.end_time, save_path=save_path, overwrite=True, gpu=self.gpu, verbose=self.verbose)
+            clipped_paths.append(save_path)
+        return clipped_paths
+
+    def run(self):
+        timer = SimbaTimer(start=True)
+        video_paths = self._clip_videos() if self.clip_videos else self.video_paths
+        for label, weight in zip(self.labels, self.weights):
+            imgsz, batch_size = self._resolve_imgsz_batch(weight=weight, label=label)
+            if self.verbose:
+                stdout_information(msg=f'Running YOLO inference for {label} on {len(video_paths)} video(s) (imgsz={imgsz}, batch_size={batch_size})...', source=self.__class__.__name__)
+            YoloInference(weights=weight,
+                          video_path=video_paths,
+                          save_dir=self.csv_dirs[label],
+                          device=self.device,
+                          batch_size=batch_size,
+                          imgsz=imgsz,
+                          threshold=self.threshold,
+                          max_detections=self.max_detections,
+                          verbose=self.verbose).run()
+
+        pool = get_cpu_pool(core_cnt=self.core_cnt, verbose=True, source=self.__class__.__name__)
+        for video_idx, video_path in enumerate(video_paths):
+            _, video_name, _ = get_fn_ext(filepath=video_path)
+            out_path = os.path.join(self.compare_dir, f'{video_name}_compare.mp4')
+            if os.path.isfile(out_path) and not self.overwrite:
+                if self.verbose:
+                    stdout_information(msg=f'[{video_idx + 1}/{len(video_paths)}] {video_name}: comparison exists, skipping.', source=self.__class__.__name__)
+                continue
+            if self.verbose:
+                stdout_information(msg=f'[{video_idx + 1}/{len(video_paths)}] Rendering {video_name}...', source=self.__class__.__name__)
+            label_font_size = max(int(get_video_meta_data(video_path=video_path)['height'] / 15), 12) if self.overlay_labels else None
+            viz_paths = []
+            for label in self.labels:
+                csv_path = os.path.join(self.csv_dirs[label], f'{video_name}.csv')
+                check_file_exist_and_readable(file_path=csv_path)
+                visualizer = YOLOVisualizer(data_path=csv_path,
+                                            video_path=video_path,
+                                            pool=pool,
+                                            save_dir=self.viz_dirs[label],
+                                            palette=self.palette,
+                                            core_cnt=self.core_cnt,
+                                            threshold=self.threshold,
+                                            padding=self.padding,
+                                            thickness=self.thickness,
+                                            opacity=self.opacity,
+                                            outline_color=self.outline_color,
+                                            verbose=self.verbose)
+                visualizer.run()
+                viz_path = os.path.join(self.viz_dirs[label], f'{video_name}.mp4')
+                if self.overlay_labels:
+                    superimpose_freetext(video_path=viz_path, text=label, font_size=label_font_size, position='top_left', save_dir=self.viz_dirs[label], gpu=self.gpu)
+                    viz_path = os.path.join(self.viz_dirs[label], f'{video_name}_text_superimposed.mp4')
+                viz_paths.append(viz_path)
+            horizontal_video_concatenator(video_paths=viz_paths,
+                                          save_path=out_path,
+                                          height_idx=0,
+                                          gpu=self.gpu,
+                                          verbose=self.verbose)
+
+        terminate_cpu_pool(pool=pool, force=False, source=self.__class__.__name__)
+        timer.stop_timer()
+        if self.verbose:
+            stdout_success(msg=f'Saved {len(video_paths)} comparison video(s) for {len(self.weights)} model(s) in {self.compare_dir}.', source=self.__class__.__name__, elapsed_time=timer.elapsed_time_str)
+
+
+
+
+
+
+#if __name__ == '__main__':
+# comparator = YoloModelComparator(weights=[r"G:\netholabs\yolo_comparator_test\mdls\yolo_0518_best.pt",
+#                                           r"G:\netholabs\yolo_comparator_test\mdls\yolo_0519_best.pt"],
+#                                  video_path=r"D:\troubleshooting\sleap_two_animals\project_folder\videos\simba_test_v11.avi",
+#                                  out_dir=r"D:\troubleshooting\sleap_two_animals\project_folder\videos\output",
+#                                  labels=["yolo_0518_best", "train13"],
+#                                  threshold=0.01,
+#                                  max_detections=2,
+#                                  overwrite=True,
+#                                  time_window={'start': '00:00:00', 'end': '00:00:10'},
+#                                  overlay_labels=True,
+#                                  device=0)
+# comparator.run()

{simba_uw_tf_dev-5.3.7 → simba_uw_tf_dev-5.3.8}/simba/plotting/yolo_visualize.py

@@ -1,3 +1,4 @@
+import multiprocessing
 import os
 from typing import Optional, Tuple, Union
 
@@ -8,7 +9,8 @@ from simba.mixins.geometry_mixin import GeometryMixin
 from simba.plotting.geometry_plotter import GeometryPlotter
 from simba.utils.checks import (check_file_exist_and_readable, check_float,
                                 check_if_dir_exists, check_int,
-                                check_valid_boolean, check_valid_dataframe)
+                                check_valid_boolean, check_valid_cpu_pool,
+                                check_valid_dataframe)
 from simba.utils.data import get_cpu_pool, terminate_cpu_pool
 from simba.utils.errors import FrameRangeError
 from simba.utils.read_write import (find_core_cnt, get_fn_ext,
@@ -63,7 +65,7 @@ class YOLOVisualizer():
     :param Optional[str] palette: Matplotlib color palette name for per-class geometry colors (e.g., ``'Set1'``, ``'tab10'``). Default: ``'Set1'``.
     :param Optional[int] core_cnt: CPU core count for parallel processing. Use ``-1`` for all available cores.
     :param float threshold: Confidence threshold in ``[0.0, 1.0]``. Detections below threshold are masked before polygon conversion.
-    :param Optional[int] padding: Polygon padding offset in pixels used during multiframe bbox-to-polygon conversion for rendering. Positive values expand polygons outward, negative values shrink polygons inward. If ``None``, no padding offset is applied. This affects visualization geometry only, not the underlying YOLO detections in the input CSV.
+    :param int padding: Polygon offset in pixels used during multiframe bbox-to-polygon conversion for rendering. Defaults to 0 (draw the exact detection box). Positive values expand polygons outward, ``-1`` shrinks them inward. This affects visualization geometry only, not the underlying YOLO detections in the input CSV.
     :param Optional[int] thickness: Polygon line thickness. If ``None``, default geometry plotter thickness is used.
     :param float opacity: Polygon fill opacity in ``[0.0, 1.0]``. Default: 0.6.
     :param Optional[Tuple[int, int, int]] outline_color: BGR color for polygon outlines. If ``None``, no outlines are drawn. Default: None.
@@ -88,7 +90,8 @@ class YOLOVisualizer():
                  palette: Optional[str] = 'Set1',
                  core_cnt: Optional[int] = -1,
                  threshold: float = 0.0,
-                 padding: Optional[int] = 20,
+                 padding: int = 0,
+                 pool: Optional[multiprocessing.Pool] = None,
                  thickness: Optional[int] = None,
                  opacity: float = 0.6,
                  outline_color: Optional[Tuple[int, int, int]] = None,
@@ -99,8 +102,9 @@ class YOLOVisualizer():
         self.data_path, self.video_path = data_path, video_path
         self.video_name = get_fn_ext(filepath=data_path)[1]
         check_int(name=f'{self.__class__.__name__} core_cnt', value=core_cnt, min_value=-1, unaccepted_vals=[0])
-        if padding is not None: check_int(name=f'{self.__class__.__name__} padding', value=padding, min_value=-1, unaccepted_vals=[0])
+        check_int(name=f'{self.__class__.__name__} padding', value=padding, min_value=-1)
         check_float(name=f'{self.__class__.__name__} threshold', value=threshold, min_value=0.0, max_value=1.0)
+        if pool is not None: check_valid_cpu_pool(value=pool, source=self.__class__.__name__,  max_cores=find_core_cnt()[0], raise_error=True)
         self.core_cnt = core_cnt
         if core_cnt == -1 or core_cnt > find_core_cnt()[0]: self.core_cnt = find_core_cnt()[0]
         if thickness is not None:
@@ -109,13 +113,14 @@ class YOLOVisualizer():
         check_valid_boolean(value=[verbose], source=self.__class__.__name__, raise_error=True)
         check_float(name=f'{self.__class__.__name__} opacity', value=opacity, min_value=0.0, max_value=1.0)
         self.save_dir, self.verbose, self.palette, self.thickness = save_dir, verbose, palette, thickness
-        self.threshold, self.padding, self.opacity, self.outline_color = threshold, padding, opacity, outline_color
+        self.threshold, self.padding, self.opacity, self.outline_color, self.pool = threshold, padding, opacity, outline_color, pool
+        self.pool_terminate_flag = False if pool is not None else True
 
     def run(self):
         data_df = pd.read_csv(self.data_path, index_col=0)
         check_valid_dataframe(df=data_df, source=self.__class__.__name__, required_fields=EXPECTED_COLS)
         df_frm_cnt = np.unique(data_df[FRAME].values).shape[0]
-        pool = get_cpu_pool(core_cnt=self.core_cnt, source=self.__class__.__name__)
+        pool = self.pool if self.pool is not None else get_cpu_pool(core_cnt=self.core_cnt, verbose=True, source=self.__class__.__name__)
         if self.video_meta_data['frame_count'] != df_frm_cnt:
             raise FrameRangeError(
                 msg=f'The bounding boxes contain data for {df_frm_cnt} frames, while the video is {self.video_meta_data["frame_count"]} frames',
@@ -145,7 +150,7 @@ class YOLOVisualizer():
                                   outline_clr=self.outline_color,
                                   pool=pool)
         plotter.run()
-        terminate_cpu_pool(pool=pool, source=self.__class__.__name__)
+        if self.pool_terminate_flag: terminate_cpu_pool(pool=pool, force=False, source=self.__class__.__name__)
 #
 #
 # if __name__ == '__main__':

{simba_uw_tf_dev-5.3.7 → simba_uw_tf_dev-5.3.8}/simba/third_party_label_appenders/transform/litpose_crop_annotations_bbox_square.py

@@ -69,7 +69,6 @@ class CropLPAnnotationsBboxSquare:
             y2 = int(np.ceil(np.max(y_valid)))
             return (x1, y1, x2, y2)
 
-        # No detection, no keypoints: center crop
         cx, cy = img_w // 2, img_h // 2
         half = min(img_w, img_h) // 2
         return (cx - half, cy - half, cx + half, cy + half)
@@ -84,7 +83,6 @@ class CropLPAnnotationsBboxSquare:
         x2p = x2 + px
         y2p = y2 + py
 
-        # Make square by extending the shorter side
         pw, ph = x2p - x1p, y2p - y1p
         side = max(pw, ph)
         cx = (x1p + x2p) / 2.0
@@ -96,7 +94,6 @@ class CropLPAnnotationsBboxSquare:
         crop_x2 = crop_x1 + side
         crop_y2 = crop_y1 + side
 
-        # Clamp to image bounds
         if crop_x1 < 0:
             crop_x1, crop_x2 = 0, side
         if crop_y1 < 0:
@@ -106,7 +103,6 @@ class CropLPAnnotationsBboxSquare:
         if crop_y2 > img_h:
             crop_y2, crop_y1 = img_h, img_h - side
 
-        # If image is smaller than the square, clamp
         crop_x1 = max(0, int(crop_x1))
         crop_y1 = max(0, int(crop_y1))
         crop_x2 = min(img_w, int(crop_x2))
@@ -179,27 +175,22 @@ class CropLPAnnotationsBboxSquare:
                 continue
             h, w = img.shape[:2]
 
-            # Get bbox and make square crop
             bbox = self._get_bbox_for_image(img_rel=img_rel, img_h=h, img_w=w, xs=xs, ys=ys, valid=valid)
             crop_x1, crop_y1, crop_x2, crop_y2 = self._bbox_to_square_crop(
                 bbox[0], bbox[1], bbox[2], bbox[3], h, w
             )
 
-            # Crop the square region
             cropped = img[crop_y1:crop_y2, crop_x1:crop_x2]
             crop_h, crop_w = cropped.shape[:2]
 
-            # Resize to target crop_size
             scale_x = crop_size[0] / crop_w
             scale_y = crop_size[1] / crop_h
             resized = cv2.resize(cropped, crop_size, interpolation=cv2.INTER_LINEAR)
 
-            # Save cropped image
             out_img_path = os.path.join(save_dir, img_rel.replace("/", os.sep))
             os.makedirs(os.path.dirname(out_img_path), exist_ok=True)
             cv2.imwrite(out_img_path, resized)
 
-            # Transform coordinates: shift by crop offset, then scale
             new_coords = coords.copy()
             new_xs = np.where(np.isnan(xs), np.nan, (xs - crop_x1) * scale_x)
             new_ys = np.where(np.isnan(ys), np.nan, (ys - crop_y1) * scale_y)
@@ -223,8 +214,6 @@ class CropLPAnnotationsBboxSquare:
         out_df.to_csv(out_csv_path)
         stdout_success(msg=f"Saved {out_csv_path} ({len(out_df)} rows).")
 
-    # --- Copied from original (unchanged) ---
-
     @staticmethod
     def _copy_project_files(lp_project_dir: str, save_dir: str):
         COPY_DIRS = ("configs", "calibrations", "models")
@@ -305,9 +294,9 @@ class CropLPAnnotationsBboxSquare:
         return common
 
 
-#if __name__ == "__main__":
-# cropper = CropLPAnnotationsBboxSquare(lp_project_dir=r"Z:\home\simon\LPProjects\mini_project_0513",
-#                                           save_dir=r"Z:\home\simon\LPProjects\mini_project_0513_cropped",
-#                                           bbox_pad_frac=0.25,
-#                                           visualize=True)
-# cropper.run()
+# if __name__ == "__main__":
+#     cropper = CropLPAnnotationsBboxSquare(lp_project_dir=r"Z:\home\simon\LPProjects\project_0601",
+#                                               save_dir=r"Z:\home\simon\LPProjects\project_0601_cropped",
+#                                               bbox_pad_frac=0.25,
+#                                               visualize=50)
+#     cropper.run()

{simba_uw_tf_dev-5.3.7 → simba_uw_tf_dev-5.3.8}/simba/utils/read_write.py

@@ -81,6 +81,7 @@ SIMBA_DIR = os.path.dirname(simba.__file__)
 
 PARSE_OPTIONS = csv.ParseOptions(delimiter=",")
 READ_OPTIONS = csv.ReadOptions(encoding="utf8")
+PA_DEFAULT_BLOCK_SIZE = csv.ReadOptions().block_size
 ImageFile.LOAD_TRUNCATED_IMAGES = False
 
 def read_df(file_path: Union[str, os.PathLike],
@@ -122,8 +123,11 @@ def read_df(file_path: Union[str, os.PathLike],
     timer = SimbaTimer(start=True)
     if file_type == Formats.CSV.value:
         try:
+            with open(file_path, "rb") as f:
+                first_line_len = len(f.readline())
+            read_options = csv.ReadOptions(encoding="utf8", block_size=max(PA_DEFAULT_BLOCK_SIZE, first_line_len * 2))
             df = csv.read_csv(
-                file_path, parse_options=PARSE_OPTIONS, read_options=READ_OPTIONS
+                file_path, parse_options=PARSE_OPTIONS, read_options=read_options
             )
             duplicate_headers = list(
                 set([x for x in df.column_names if df.column_names.count(x) > 1])

{simba_uw_tf_dev-5.3.7 → simba_uw_tf_dev-5.3.8}/simba/utils/yolo.py

@@ -591,7 +591,7 @@ def read_yolo_metadata(model: Union[str, os.PathLike, YOLO]) -> dict:
 
     META_KEYS = ('batch', 'imgsz', 'stride', 'task', 'names', 'fp16', 'dynamic')
 
-    if isinstance(model, YOLO):
+    if YOLO is not None and isinstance(model, YOLO):
         meta = {}
         if hasattr(model, 'predictor') and model.predictor is not None and hasattr(model.predictor, 'model'):
             backend = model.predictor.model
@@ -625,6 +625,8 @@ def read_yolo_metadata(model: Union[str, os.PathLike, YOLO]) -> dict:
                 return json.loads(f.read(meta_len).decode('utf-8'))
         return {}
 
+    if YOLO is None:
+        raise SimBAPAckageVersionError(msg=f'Reading metadata from a {ext} model requires the ultralytics package, which is not installed.', source=read_yolo_metadata.__name__)
     loaded = YOLO(path)
     meta = {}
     if hasattr(loaded, 'overrides'):
@@ -642,6 +644,49 @@ def read_yolo_metadata(model: Union[str, os.PathLike, YOLO]) -> dict:
                 meta[key] = getattr(loaded.model, key)
     return meta
 
+
+def get_yolo_imgsz_and_batch_size(model: Union[str, os.PathLike, YOLO],
+                                  raise_error: bool = True) -> Tuple[Optional[int], Optional[int]]:
+    """
+    Attempt to read the image size and batch size baked into a YOLO model.
+
+    .. note::
+       For ``.engine`` (TensorRT) files both values are read straight from the embedded header
+       and represent the fixed input bindings. For ``.pt`` and other formats the values are
+       scraped from the training arguments, so ``imgsz`` reflects the *training* size (a sensible
+       default, not a hard constraint) and ``batch`` is frequently unavailable.
+
+    .. seealso::
+       :func:`~simba.utils.yolo.read_yolo_metadata` (full metadata dictionary)
+
+    :param Union[str, os.PathLike, YOLO] model: Path to a YOLO model file, or an already-loaded :class:`ultralytics.YOLO` instance.
+    :param bool raise_error: If True (default), raise :class:`~simba.utils.errors.InvalidInputError` when ``imgsz`` or ``batch`` cannot be found in the model metadata. If False, missing values are returned as ``None``.
+    :return: Tuple of ``(imgsz, batch_size)``, each an ``int`` (or ``None`` if not found and ``raise_error`` is False).
+    :rtype: Tuple[Optional[int], Optional[int]]
+    :raises InvalidInputError: If ``raise_error`` is True and ``imgsz`` and/or ``batch`` is not present in the model metadata.
+
+    :example:
+    >>> get_yolo_imgsz_and_batch_size(r'/models/best.engine')
+    (256, 192)
+    >>> get_yolo_imgsz_and_batch_size(r'/models/best.pt', raise_error=False)
+    (640, None)
+    """
+
+    check_valid_boolean(value=raise_error, source=f'{get_yolo_imgsz_and_batch_size.__name__} raise_error', raise_error=True)
+    meta = read_yolo_metadata(model=model)
+    imgsz, batch_size = meta.get('imgsz', None), meta.get('batch', None)
+    if isinstance(imgsz, (list, tuple)) and len(imgsz) > 0:
+        imgsz = imgsz[0]
+    if imgsz is not None:
+        imgsz = int(imgsz)
+    if batch_size is not None:
+        batch_size = int(batch_size)
+    if raise_error:
+        missing = [k for k, v in (('imgsz', imgsz), ('batch', batch_size)) if v is None]
+        if missing:
+            raise InvalidInputError(msg=f'Could not read {" and ".join(missing)} from the metadata of model {model}. Pass the value(s) explicitly, or set raise_error=False.', source=get_yolo_imgsz_and_batch_size.__name__)
+    return imgsz, batch_size
+
 # export_yolo_model(model_path=r"E:\open_video\open_field_2\yolo_seg_project\mdl\train\weights\best.pt",
 #                   export_format='engine',
 #                   imgsz=1240,

{simba_uw_tf_dev-5.3.7 → simba_uw_tf_dev-5.3.8}/simba/video_processors/video_processing.py

@@ -4680,7 +4680,7 @@ def superimpose_freetext(video_path: Union[str, os.PathLike],
        :align: center
 
     :param Union[str, os.PathLike] video_path: Path to the input video file or directory containing video files.
-    :param str text: The text to overlay on the video
+    :param str text: The text to overlay on the video. Characters that break the ffmpeg ``drawtext`` filter (``: ' " \\ % , ; =``) are stripped or replaced before rendering. Raises if no legal characters remain.
     :param Optional[int] font_size: Font size for the text. Default 30.
     :param Optional[str] font_color:  Font color for text. Default white
     :param Optional[str] font_border_color: Font border color for the text. Default black.
@@ -4701,6 +4701,11 @@ def superimpose_freetext(video_path: Union[str, os.PathLike],
     check_int(name=f'{superimpose_freetext.__name__} font_size', value=font_size, min_value=1)
     check_int(name=f'{superimpose_freetext.__name__} font_border_width', value=font_border_width, min_value=1)
     check_str(name=f'{superimpose_freetext.__name__} text', value=text)
+    illegal_chars = {':': '-', "'": '', '"': '', '\\': '', '%': '', ',': ' ', ';': ' ', '=': '-'}
+    cleaned_text = ''.join(illegal_chars.get(c, c) for c in text).strip()
+    if len(cleaned_text) == 0:
+        raise InvalidInputError(msg=f'The text "{text}" only contains characters that are illegal in ffmpeg drawtext and cannot be superimposed.', source=superimpose_freetext.__name__)
+    text = cleaned_text
     font_dict = get_fonts()
     check_str(name='font', value=font, options=tuple(font_dict.keys()))
     font_path = font_dict[font]

{simba_uw_tf_dev-5.3.7 → simba_uw_tf_dev-5.3.8}/simba_uw_tf_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba-uw-tf-dev
-Version: 5.3.7
+Version: 5.3.8
 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
@@ -57,7 +57,7 @@ If you use the code, please cite:
 ```
 
 ### Licence
-SimBA is licensed under GNU Lesser General Public License v3.0.
+SimBA is licensed under a modified BSD 3-Clause License, permitting use for academic and research purposes only. For commercial licensing inquiries, contact sronilsson@gmail.com.
 
 ### Contributors
 Contributers on Github https://github.com/sgoldenlab/simba#contributors

{simba_uw_tf_dev-5.3.7 → simba_uw_tf_dev-5.3.8}/simba_uw_tf_dev.egg-info/SOURCES.txt

@@ -688,6 +688,7 @@ simba/plotting/circular_feature_overlay_plotter.py
 simba/plotting/circular_plotting.py
 simba/plotting/clf_validator.py
 simba/plotting/clf_validator_mp.py
+simba/plotting/compare_bbox_mdls.py
 simba/plotting/cue_light_visualizer.py
 simba/plotting/data_plotter.py
 simba/plotting/directing_animals_to_bodypart_visualizer.py