simba-uw-tf-dev 5.4.3__tar.gz → 5.4.4__tar.gz

{simba_uw_tf_dev-5.4.3 → simba_uw_tf_dev-5.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba_uw_tf_dev
-Version: 5.4.3
+Version: 5.4.4
 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-5.4.3 → simba_uw_tf_dev-5.4.4}/setup.py

@@ -30,7 +30,7 @@ with open(GPU_REQUIREMENTS_PATH, "r") as f:
 # Setup configuration
 setuptools.setup(
     name="simba_uw_tf_dev",
-    version="5.4.3",
+    version="5.4.4",
     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.4.3 → simba_uw_tf_dev-5.4.4}/simba/data_processors/cuda/geometry.py

@@ -78,6 +78,11 @@ def is_inside_circle(x: np.ndarray, y: np.ndarray, r: float) -> np.ndarray:
     """
     Determines whether points in array `x` are inside the circle with center ``y`` and radius ``r``
 
+    .. image:: _static/img/simba.data_processors.cuda.geometry.is_inside_circle.webp
+       :alt: Is inside circle
+       :width: 700
+       :align: center
+
     .. csv-table::
        :header: EXPECTED RUNTIMES
        :file: ../../../docs/tables/is_inside_circle.csv

{simba_uw_tf_dev-5.4.3 → simba_uw_tf_dev-5.4.4}/simba/data_processors/cuda/timeseries.py

@@ -44,6 +44,11 @@ def sliding_threshold(data: np.ndarray, time_window: float, sample_rate: float,
     """
     Compute the count of observations above or below threshold crossings over a sliding window using GPU acceleration.
 
+    .. image:: _static/img/sliding_threshold.webp
+       :alt: Sliding threshold
+       :width: 700
+       :align: center
+
     :param np.ndarray data: Input data array.
     :param float time_window: Size of the sliding window in seconds.
     :param float sample_rate: Number of samples per second in the data.
@@ -85,9 +90,7 @@ def _sliding_percent_beyond_n_std_kernel(data, time, std_n, results):
         std_val = _cuda_std(sample, m) * std_n[0]
         cnt = 0
         for i in range(sample.shape[0]):
-
             if (sample[i] > (m + std_val)) or (sample[i] < (m - std_val)):
-                print(sample[i], m + std_val)
                 cnt += 1
         results[r-1] = cnt
 
@@ -98,6 +101,11 @@ def sliding_percent_beyond_n_std(data: np.ndarray, time_window: float, sample_ra
 
     This function uses GPU acceleration via CUDA to efficiently compute the result over large datasets.
 
+    .. image:: _static/img/simba.data_processors.cuda.timeseries.sliding_percent_beyond_n_std.webp
+       :alt: Sliding percent beyond n std
+       :width: 700
+       :align: center
+
     :param np.ndarray data: The input 1D data array for which the sliding window computation is to be performed.
     :param float time_window: The length of the time window in seconds.
     :param float sample_rate: The sample rate of the data in Hz (samples per second).

{simba_uw_tf_dev-5.4.3 → simba_uw_tf_dev-5.4.4}/simba/data_processors/cuda/utils.py

@@ -53,7 +53,7 @@ def _cuda_standard_deviation(x):
 def _cuda_std(x: np.ndarray, x_hat: float):
     std = 0
     for i in range(x.shape[0]):
-        std += (x[0] - x_hat) ** 2
+        std += (x[i] - x_hat) ** 2
     return math.sqrt(std / x.shape[0])
 
 @cuda.jit(device=True)

{simba_uw_tf_dev-5.4.3 → simba_uw_tf_dev-5.4.4}/simba/mixins/feature_extraction_mixin.py

@@ -86,6 +86,11 @@ class FeatureExtractionMixin(object):
             For GPU acceleration through CuPy, use :func:`simba.data_processors.cuda.statistics.get_euclidean_distance_cupy`.
             For GPU acceleration through numba CUDA, use :func:`simba.data_processors.cuda.statistics.get_euclidean_distance_cuda`.
 
+        .. image:: _static/img/euclidean_distance.webp
+           :alt: Euclidean distance between two body-parts
+           :width: 400
+           :align: center
+
         :param np.ndarray bp_1_x: 2D array of size len(frames) x 1 with bodypart 1 x-coordinates.
         :param np.ndarray bp_2_x: 2D array of size len(frames) x 1 with bodypart 2 x-coordinates.
         :param np.ndarray bp_1_y: 2D array of size len(frames) x 1 with bodypart 1 y-coordinates.
@@ -582,6 +587,10 @@ class FeatureExtractionMixin(object):
         Jitted analogue of meth:`scipy.cdist` for 3D array. Use to calculate Euclidean distances between
         all coordinates in of one array and itself.
 
+        .. image:: _static/img/cdist_3d.webp
+           :width: 700
+           :align: center
+
         :param np.ndarray data: 3D array of body-part coordinates of size len(frames) x -1 x 2.
         :return np.ndarray: 3D array of size data.shape[0], data.shape[1], data.shape[1].
         """
@@ -598,8 +607,14 @@ class FeatureExtractionMixin(object):
     # @njit('(float32[:],)')
     def cosine_similarity(data: np.ndarray) -> np.ndarray:
         """
-        Jitted analogue of sklearn.metrics.pairwise import cosine_similarity. Similar to scipy.cdist.
-        calculates the cosine similarity between all pairs in 2D array.
+        Analogue of ``sklearn.metrics.pairwise.cosine_similarity``. Similar to scipy.cdist.
+        Calculates the cosine similarity (the cosine of the angle between two vectors, so magnitude is
+        ignored) between all pairs of rows in a 2D array. Values range from 1 (same direction) through
+        0 (orthogonal) to -1 (opposite). Zero-vectors yield a similarity of 0.
+
+        .. image:: _static/img/cosine_similarity.webp
+           :width: 700
+           :align: center
 
         :param np.ndarray data: 2D array of observations.
         :return: Matrix representing the cosine similarity between all observations in ``data``.
@@ -608,11 +623,12 @@ class FeatureExtractionMixin(object):
         :example:
         >>> data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]).astype(np.float32)
         >>> FeatureExtractionMixin().cosine_similarity(data=data)
-        >>> [[1.0, 0.974, 0.959][0.974,  1.0, 0.998] [0.959, 0.998, 1.0]
+        >>> [[1.0, 0.974, 0.959], [0.974, 1.0, 0.998], [0.959, 0.998, 1.0]]
         """
 
         dot_product = np.dot(data, data.T)
         norms = np.linalg.norm(data, axis=1).reshape(-1, 1)
+        norms[norms == 0] = 1  # avoid division by zero; zero-vectors yield a similarity of 0
         similarity = dot_product / (norms * norms.T)
         return similarity
 

{simba_uw_tf_dev-5.4.3 → simba_uw_tf_dev-5.4.4}/simba/mixins/feature_extraction_supplement_mixin.py

@@ -172,7 +172,7 @@ class FeatureExtractionSupplemental(FeatureExtractionMixin):
                 if window_data[-1] > window_data[-2]:
                     peak_cnt += 1
                 for k in prange(1, len(window_data) - 1):
-                    if window_data[j] > window_data[j - 1]:
+                    if window_data[k] > window_data[k - 1] and window_data[k] > window_data[k + 1]:
                         peak_cnt += 1
                 peak_ratio = peak_cnt / window_data.shape[0]
                 results[j, i] = peak_ratio

{simba_uw_tf_dev-5.4.3 → simba_uw_tf_dev-5.4.4}/simba/mixins/image_mixin.py

@@ -111,6 +111,11 @@ class ImageMixin(object):
         Gaussian blurring is used to reduce image noise and detail by smoothing the image. It applies a weighted average
         where more importance is given to the central pixels, creating a soft blur effect.
 
+        .. image:: _static/img/gaussian_blur.webp
+           :alt: Gaussian blur
+           :width: 700
+           :align: center
+
         :param np.ndarray img: Input image as a NumPy array. The image should be a valid 2D (grayscale) or 3D (color) array.
         :param Optional[Tuple] kernel_size: A tuple (height, width) representing the size of the Gaussian kernel. The values must be positive odd integers. Default is (9, 9).
         :return: A NumPy array representing the blurred image with the same dimensions as the input image.
@@ -129,6 +134,11 @@ class ImageMixin(object):
         """
         Applies morphological erosion to the input image using the specified kernel size and number of iterations.
 
+        .. image:: _static/img/erode.webp
+           :alt: Erode
+           :width: 700
+           :align: center
+
         :param np.ndarray img: A 2D or 3D NumPy array representing the input image on which erosion will be applied. It should be in the form of a binary or greyscale image.
         :param Optional[Tuple[int, int]] kernel_size: A tuple (width, height) specifying the size of the kernel to be used for erosion. The default kernel size is (3, 3).
         :param Optional[int] iterations: The number of times the erosion operation is applied. The default value is 3.
@@ -141,7 +151,7 @@ class ImageMixin(object):
         check_instance(source=ImageMixin.gaussian_blur.__name__, instance=kernel_size, accepted_types=(tuple,))
         check_valid_lst(data=list(kernel_size), source=ImageMixin.gaussian_blur.__name__, valid_dtypes=(int,), exact_len=2)
         check_int(name=ImageMixin.erode.__name__, value=iterations, min_value=1)
-        return cv2.erode(img, np.ones((3, 3), np.uint8), iterations=3)
+        return cv2.erode(img, np.ones(kernel_size, np.uint8), iterations=iterations)
 
     @staticmethod
     def get_histocomparison(
@@ -163,10 +173,19 @@ class ImageMixin(object):
         """
         Compare histograms of two images using OpenCV's histogram comparison methods.
 
-        Computes a similarity metric between the histograms of two images. The method determines how the comparison
-        is performed (e.g., correlation, chi-square, Bhattacharyya distance). Lower values typically indicate
-        greater similarity for correlation and intersection methods, while higher values indicate similarity for
-        chi-square methods.
+        Each image is reduced to a normalized intensity histogram (256 bins per channel) and the two histograms are
+        compared with the chosen method. Because only the distribution of intensities is compared, the score is blind
+        to where pixels sit (a spatially shuffled image scores identically) and to image content (two different images
+        with similar tone distributions score as alike).
+
+        The "more similar" direction depends on the method: for ``correlation`` and ``intersection`` higher values
+        indicate greater similarity, while for ``chi_square`` and ``bhattacharyya``/``hellinger`` lower values
+        (0 = identical) indicate greater similarity.
+
+        .. image:: _static/img/get_histocomparison.webp
+           :alt: Get histocomparison
+           :width: 700
+           :align: center
 
         .. seealso::
            For histogram comparison within specific geometries, see :func:`simba.mixins.geometry_mixin.GeometryMixin.geometry_histocomparison`.
@@ -195,16 +214,26 @@ class ImageMixin(object):
             options=tuple(GeometryEnum.HISTOGRAM_COMPARISON_MAP.value.keys()),
         )
         method = GeometryEnum.HISTOGRAM_COMPARISON_MAP.value[method]
-        if absolute:
-            return abs(
-                cv2.compareHist(
-                    img_1.astype(np.float32), img_2.astype(np.float32), method
-                )
+        if img_1.ndim != img_2.ndim:
+            raise InvalidInputError(
+                msg=f"img_1 and img_2 must have the same number of channels (got {img_1.ndim}D and {img_2.ndim}D)",
+                source=ImageMixin.get_histocomparison.__name__,
             )
+
+        def _histogram(img: np.ndarray) -> np.ndarray:
+            img = img.astype(np.uint8)
+            if img.ndim == 2:
+                channels = [cv2.calcHist([img], [0], None, [256], [0, 256])]
+            else:
+                channels = [cv2.calcHist([img], [c], None, [256], [0, 256]) for c in range(img.shape[2])]
+            hist = np.concatenate(channels, axis=0)
+            return cv2.normalize(hist, hist).flatten()
+
+        hist_1, hist_2 = _histogram(img_1), _histogram(img_2)
+        if absolute:
+            return abs(cv2.compareHist(hist_1, hist_2, method))
         else:
-            return cv2.compareHist(
-                img_1.astype(np.float32), img_2.astype(np.float32), method
-            )
+            return cv2.compareHist(hist_1, hist_2, method)
 
     @staticmethod
     def get_contourmatch(img_1: np.ndarray,
@@ -413,6 +442,11 @@ class ImageMixin(object):
         .. note::
            See wiki ` https://en.wikipedia.org/wiki/Image_moment#Hu_invariant_moments <See https://en.wikipedia.org/wiki/Image_moment#Hu_invariant_moments>`__.
 
+        .. image:: _static/img/img_moments.webp
+           :alt: Image moments
+           :width: 700
+           :align: center
+
         :param np.ndarray img: The input image as a 2D or 3D NumPy array. If the image has multiple channels (e.g., RGB or BGR), it will be converted to grayscale.
         :param  Optional[bool] hu_moments: If set to True, the function computes and returns the 7 Hu moments.  If False, it returns the standard moments of the image. Default is False.
         :return: A 24x1 2D-array if `hu_moments` is False (representing standard moments), or a 7x1 2D-array if `hu_moments` is True (representing Hu moments).
@@ -439,6 +473,11 @@ class ImageMixin(object):
         """
         Find contours in an image.
 
+        .. image:: _static/img/find_contours.webp
+           :alt: Find contours
+           :width: 700
+           :align: center
+
         .. seealso::
            For contour comparisons, see :func:`simba.mixins.image_mixin.ImageMixin.get_contourmatch`
 
@@ -525,6 +564,11 @@ class ImageMixin(object):
 
         E.g., having a cropped image, find the image and frame number in a video it most likely has been cropped from.
 
+        .. image:: _static/img/template_matching_cpu.webp
+           :alt: Template matching CPU
+           :width: 700
+           :align: center
+
         :param Union[str, os.PathLike] video_path: Path to the video file on disk.
         :param np.ndarray img: Template image for matching. E.g., a cropped image from ``video_path``.
         :param Optional[int] core_cnt: Number of CPU cores to use for parallel processing. Default is -1 (max available cores).
@@ -737,6 +781,11 @@ class ImageMixin(object):
         """
         Segment a horizontal part of all images in stack.
 
+        .. image:: _static/img/segment_img_stack_horizontal.webp
+           :alt: Segment img stack horizontal
+           :width: 800
+           :align: center
+
         .. seealso::
            :func:`simba.mixins.image_mixin.ImageMixin.segment_img_horizontal`
            :func:`simba.data_processors.cuda.image.segment_img_stack_horizontal`,
@@ -910,6 +959,11 @@ class ImageMixin(object):
         """
         Jitted pairwise comparison of images in two stacks of equal length using mean squared errors.
 
+        .. image:: _static/img/img_stack_mse.webp
+           :alt: Image stack MSE
+           :width: 700
+           :align: center
+
         .. note::
            Useful for noting subtle changes, each imgs_2 equals imgs_1 with images shifted by 1. Images has to be in uint8 format.
            Also see ``img_sliding_mse``.

{simba_uw_tf_dev-5.4.3 → simba_uw_tf_dev-5.4.4}/simba/model/inference_batch.py

@@ -113,49 +113,49 @@ class InferenceBatch(TrainModelMixin, ConfigReader):
 
     def run(self):
         check_all_file_names_are_represented_in_video_log(video_info_df=self.video_info_df, data_paths=self.feature_file_paths)
-        # for file_cnt, file_path in enumerate(self.feature_file_paths):
-        #     video_timer = SimbaTimer(start=True)
-        #     _, file_name, _ = get_fn_ext(file_path)
-        #     if self.verbose: stdout_information(msg=f"Analyzing video {file_name}... (Video {file_cnt+1}/{len(self.feature_file_paths)})")
-        #     file_save_path = os.path.join(self.save_dir, f"{file_name}.{self.file_type}")
-        #     in_df = read_df(file_path, self.file_type)
-        #     x_df = self.drop_bp_cords(df=in_df).astype(np.float32)
-        #     self.check_df_dataset_integrity(df=x_df, logs_path=self.logs_path, file_name=file_name)
-        #     _, px_per_mm, fps = self.read_video_info(video_name=file_name, raise_error=False)
-        #     out_df = deepcopy(in_df)
-        #     for m, m_hyp in self.model_dict.items():
-        #         check_if_keys_exist_in_dict(data=m_hyp, key=[MODEL_PATH, MODEL_NAME, THRESHOLD, MINIMUM_BOUT_LENGTH], name=f'classifier {m}', raise_error=False)
-        #         if not os.path.isfile(m_hyp[MODEL_PATH]):
-        #             NoFileFoundWarning(msg=f'SKIPPING CLASSIFIER {m} for video {file_name}. The classifier model file {m_hyp[MODEL_PATH]} could not be found.', source=self.__class__.__name__)
-        #             continue
-        #         clf = self.read_pickle(file_path=m_hyp[MODEL_PATH])
-        #         if self.feature_subsets_by_clf is None or m_hyp[MODEL_NAME] not in self.feature_subsets_by_clf:
-        #             probability_column = f"Probability_{m_hyp[MODEL_NAME]}"
-        #             out_df[probability_column] = self.clf_predict_proba(clf=clf, x_df=x_df, data_path=file_path, model_name=m_hyp[MODEL_NAME])
-        #             out_df[m_hyp[MODEL_NAME]] = np.where(out_df[probability_column] > m_hyp[THRESHOLD], 1, 0)
-        #             clf_min_bout = self.minimum_bout_length if self.minimum_bout_length is not None else m_hyp[MINIMUM_BOUT_LENGTH]
-        #             if int(clf_min_bout) > 0:
-        #                 if self.verbose: stdout_information(msg=f'Correcting minimum bouts in video {file_name} and classifier {m_hyp[MODEL_NAME]} ({clf_min_bout}ms)...')
-        #                 out_df = plug_holes_shortest_bout(data_df=out_df, clf_name=m_hyp[MODEL_NAME], fps=fps, shortest_bout=clf_min_bout)
-        #         else:
-        #             subset_cnts = len(self.feature_subsets_by_clf[m_hyp[MODEL_NAME]].keys())
-        #             self.config.set(section=ConfigKey.SML_SETTINGS.value, option=ConfigKey.TARGET_CNT.value, value=str(subset_cnts))
-        #             for mdl_cnt, (model_subset_name, model_x) in enumerate(self.feature_subsets_by_clf[m_hyp[MODEL_NAME]].items()):
-        #                 probability_column = f"Probability_{m_hyp[MODEL_NAME]}_{model_subset_name}"
-        #                 self.config.set(section=ConfigKey.SML_SETTINGS.value, option=f'target_name_{mdl_cnt+1}', value=f'{m_hyp[MODEL_NAME]}_{model_subset_name}')
-        #                 self.config.set(section=ConfigKey.THRESHOLD_SETTINGS.value, option=f'threshold_{mdl_cnt+1}', value=f'{m_hyp[THRESHOLD]}')
-        #                 self.config.set(section=ConfigKey.MIN_BOUT_LENGTH.value, option=f'min_bout_{mdl_cnt+1}', value=f'{m_hyp[MINIMUM_BOUT_LENGTH]}')
-        #                 check_that_column_exist(df=x_df, column_name=model_x, file_name=file_path, raise_error=True)
-        #                 out_df[probability_column] = self.clf_predict_proba(clf=clf, x_df=x_df[model_x], data_path=file_path, model_name=model_subset_name)
-        #                 out_df[f'{m_hyp[MODEL_NAME]}_{model_subset_name}'] = np.where(out_df[probability_column] > m_hyp[THRESHOLD], 1, 0)
-        #                 clf_min_bout = self.minimum_bout_length if self.minimum_bout_length is not None else m_hyp[MINIMUM_BOUT_LENGTH]
-        #                 if int(clf_min_bout) > 0:
-        #                     if self.verbose: stdout_information(msg=f'Correcting minimum bouts in video {file_name} and classifier {m_hyp[MODEL_NAME]} ({clf_min_bout}ms)...')
-        #                     out_df = plug_holes_shortest_bout(data_df=out_df, clf_name=f'{m_hyp[MODEL_NAME]}_{model_subset_name}', fps=fps, shortest_bout=clf_min_bout)
-        #             with open(self.config_path, "w") as f: self.config.write(f)
-        #     write_df(df=out_df, file_type=self.file_type, save_path=file_save_path)
-        #     video_timer.stop_timer()
-        #     if self.verbose: stdout_information(msg=f"Predictions created for {file_name} (frame count: {len(in_df)}, elapsed time: {video_timer.elapsed_time_str}) ...")
+        for file_cnt, file_path in enumerate(self.feature_file_paths):
+            video_timer = SimbaTimer(start=True)
+            _, file_name, _ = get_fn_ext(file_path)
+            if self.verbose: stdout_information(msg=f"Analyzing video {file_name}... (Video {file_cnt+1}/{len(self.feature_file_paths)})")
+            file_save_path = os.path.join(self.save_dir, f"{file_name}.{self.file_type}")
+            in_df = read_df(file_path, self.file_type)
+            x_df = self.drop_bp_cords(df=in_df).astype(np.float32)
+            self.check_df_dataset_integrity(df=x_df, logs_path=self.logs_path, file_name=file_name)
+            _, px_per_mm, fps = self.read_video_info(video_name=file_name, raise_error=False)
+            out_df = deepcopy(in_df)
+            for m, m_hyp in self.model_dict.items():
+                check_if_keys_exist_in_dict(data=m_hyp, key=[MODEL_PATH, MODEL_NAME, THRESHOLD, MINIMUM_BOUT_LENGTH], name=f'classifier {m}', raise_error=False)
+                if not os.path.isfile(m_hyp[MODEL_PATH]):
+                    NoFileFoundWarning(msg=f'SKIPPING CLASSIFIER {m} for video {file_name}. The classifier model file {m_hyp[MODEL_PATH]} could not be found.', source=self.__class__.__name__)
+                    continue
+                clf = self.read_pickle(file_path=m_hyp[MODEL_PATH])
+                if self.feature_subsets_by_clf is None or m_hyp[MODEL_NAME] not in self.feature_subsets_by_clf:
+                    probability_column = f"Probability_{m_hyp[MODEL_NAME]}"
+                    out_df[probability_column] = self.clf_predict_proba(clf=clf, x_df=x_df, data_path=file_path, model_name=m_hyp[MODEL_NAME])
+                    out_df[m_hyp[MODEL_NAME]] = np.where(out_df[probability_column] > m_hyp[THRESHOLD], 1, 0)
+                    clf_min_bout = self.minimum_bout_length if self.minimum_bout_length is not None else m_hyp[MINIMUM_BOUT_LENGTH]
+                    if int(clf_min_bout) > 0:
+                        if self.verbose: stdout_information(msg=f'Correcting minimum bouts in video {file_name} and classifier {m_hyp[MODEL_NAME]} ({clf_min_bout}ms)...')
+                        out_df = plug_holes_shortest_bout(data_df=out_df, clf_name=m_hyp[MODEL_NAME], fps=fps, shortest_bout=clf_min_bout)
+                else:
+                    subset_cnts = len(self.feature_subsets_by_clf[m_hyp[MODEL_NAME]].keys())
+                    self.config.set(section=ConfigKey.SML_SETTINGS.value, option=ConfigKey.TARGET_CNT.value, value=str(subset_cnts))
+                    for mdl_cnt, (model_subset_name, model_x) in enumerate(self.feature_subsets_by_clf[m_hyp[MODEL_NAME]].items()):
+                        probability_column = f"Probability_{m_hyp[MODEL_NAME]}_{model_subset_name}"
+                        self.config.set(section=ConfigKey.SML_SETTINGS.value, option=f'target_name_{mdl_cnt+1}', value=f'{m_hyp[MODEL_NAME]}_{model_subset_name}')
+                        self.config.set(section=ConfigKey.THRESHOLD_SETTINGS.value, option=f'threshold_{mdl_cnt+1}', value=f'{m_hyp[THRESHOLD]}')
+                        self.config.set(section=ConfigKey.MIN_BOUT_LENGTH.value, option=f'min_bout_{mdl_cnt+1}', value=f'{m_hyp[MINIMUM_BOUT_LENGTH]}')
+                        check_that_column_exist(df=x_df, column_name=model_x, file_name=file_path, raise_error=True)
+                        out_df[probability_column] = self.clf_predict_proba(clf=clf, x_df=x_df[model_x], data_path=file_path, model_name=model_subset_name)
+                        out_df[f'{m_hyp[MODEL_NAME]}_{model_subset_name}'] = np.where(out_df[probability_column] > m_hyp[THRESHOLD], 1, 0)
+                        clf_min_bout = self.minimum_bout_length if self.minimum_bout_length is not None else m_hyp[MINIMUM_BOUT_LENGTH]
+                        if int(clf_min_bout) > 0:
+                            if self.verbose: stdout_information(msg=f'Correcting minimum bouts in video {file_name} and classifier {m_hyp[MODEL_NAME]} ({clf_min_bout}ms)...')
+                            out_df = plug_holes_shortest_bout(data_df=out_df, clf_name=f'{m_hyp[MODEL_NAME]}_{model_subset_name}', fps=fps, shortest_bout=clf_min_bout)
+                    with open(self.config_path, "w") as f: self.config.write(f)
+            write_df(df=out_df, file_type=self.file_type, save_path=file_save_path)
+            video_timer.stop_timer()
+            if self.verbose: stdout_information(msg=f"Predictions created for {file_name} (frame count: {len(in_df)}, elapsed time: {video_timer.elapsed_time_str}) ...")
         if self.save_agg_stats is not None:
             if self.verbose: stdout_information(msg=f"Computing aggregate classifier statistics into {self.save_agg_stats}...")
             agg = AggregateClfCalculator(config_path=self.config_path, classifiers=list(self.clf_names), data_dir=self.save_dir, save_dir=self.save_agg_stats)
@@ -174,9 +174,9 @@ class InferenceBatch(TrainModelMixin, ConfigReader):
 
 #
 # test = InferenceBatch(config_path=r"H:\projects\jason_zhang\jason_project\project_folder\project_config.ini",
-#                       save_dir=r'H:\projects\jason_zhang\jason_project\project_folder\csv\GROOMING',
-#                       model_dict={'GROOMING': {'model_path': r"H:\projects\jason_zhang\jason_project\models\GROOMING.sav", 'minimum_bout_length': 500, 'threshold': 0.24}},
-#                       save_agg_stats=r'H:\projects\jason_zhang\jason_project\project_folder\csv\GROOMING')
+#                       save_dir=r'H:\projects\jason_zhang\jason_project\project_folder\csv\GROOMING\500_0.275_smoothing_500ms\csv',
+#                       model_dict={'GROOMING': {'model_path': r"H:\projects\jason_zhang\jason_project\models\GROOMING.sav", 'minimum_bout_length': 500, 'threshold': 0.275}},
+#                       save_agg_stats=r'H:\projects\jason_zhang\jason_project\project_folder\csv\GROOMING\500_0.25\csv')
 # test.run()
 
 #

{simba_uw_tf_dev-5.4.3 → simba_uw_tf_dev-5.4.4}/simba/plotting/ROI_feature_visualizer_mp.py

@@ -31,8 +31,8 @@ from simba.utils.checks import (check_file_exist_and_readable,
 from simba.utils.data import (find_frame_numbers_from_time_stamp, get_cpu_pool,
                               slice_roi_dict_for_video, terminate_cpu_pool)
 from simba.utils.enums import Formats, Options, TextOptions
-from simba.utils.lookups import get_simba_font_name_and_path
 from simba.utils.errors import BodypartColumnNotFoundError, NoFilesFoundError
+from simba.utils.lookups import get_simba_font_name_and_path
 from simba.utils.printing import stdout_information, stdout_success
 from simba.utils.read_write import (concatenate_videos_in_folder,
                                     find_core_cnt, get_fn_ext,

{simba_uw_tf_dev-5.4.3 → simba_uw_tf_dev-5.4.4}/simba/plotting/plot_clf_results_mp.py

@@ -519,17 +519,17 @@ class PlotSklearnResultsMultiProcess(ConfigReader, TrainModelMixin, PlottingMixi
 # if __name__ == "__main__":
 #     clf_plotter = PlotSklearnResultsMultiProcess(config_path=r"H:\projects\jason_zhang\jason_project\project_folder\project_config.ini",
 #                                                  video_paths=r"H:\projects\jason_zhang\jason_project\project_folder\videos",
-#                                                  data_dir=r"H:\projects\jason_zhang\jason_project\project_folder\csv\GROOMING",
-#                                                  save_dir=r'H:\projects\jason_zhang\jason_project\project_folder\csv\GROOMING\videos',
+#                                                  data_dir=r"H:\projects\jason_zhang\jason_project\project_folder\csv\GROOMING\500_0.275_smoothing_500ms\csvs",
+#                                                  save_dir=r'H:\projects\jason_zhang\jason_project\project_folder\csv\GROOMING\500_0.275_smoothing_500ms\videos',
 #                                                  clf_names=('GROOMING',),
 #                                                  video_setting=True,
 #                                                  frame_setting=False,
 #                                                  rotate=False,
 #                                                  show_confidence=True,
-#                                                  core_cnt=14,
+#                                                  core_cnt=8,
 #                                                  show_pose=True,
 #                                                  animal_names=False,
-#                                                  font='DynaPuff',
+#                                                  font='poppins regular',
 #                                                  print_timer=HHMMSSSSSS,
 #                                                  overwrite=False,
 #                                                  time_slice=None, # {START_TIME: '00:00:00', END_TIME: '00:00:10'}, #{START_TIME: '00:00:00', END_TIME: '00:01:00'}, #,{START_TIME: '00:00:00', END_TIME: '00:01:00'}

{simba_uw_tf_dev-5.4.3 → simba_uw_tf_dev-5.4.4}/simba/roi_tools/roi_utils.py

@@ -319,6 +319,11 @@ def get_ear_tags_for_rectangle(center: Tuple[int, int], width: int, height: int)
     """
     Knowing the center, width, and height of rectangle, return its vertices.
 
+    .. image:: _static/img/get_ear_tags_for_rectangle.webp
+       :alt: Get ear tags for rectangle
+       :width: 600
+       :align: center
+
     :param Tuple[int, int] center: The center x and y coordinates of the rectangle
     :param int width: The width of the rectangle in pixels.
     :param Tuple[int, int] height: The width of the rectangle in pixels.

{simba_uw_tf_dev-5.4.3 → simba_uw_tf_dev-5.4.4}/simba/third_party_label_appenders/converters.py

@@ -82,6 +82,11 @@ def geometries_to_coco(geometries: Dict[str, np.ndarray],
     them into COCO format annotations. The geometries are associated with frames of a video, and the corresponding
     images are extracted from the video, saved as PNG files, and linked to the annotations.
 
+    .. image:: _static/img/geometries_to_coco.webp
+       :alt: Geometries to COCO
+       :width: 700
+       :align: center
+
     :example:
     >>> data_path = r"C:\troubleshooting\mitra\project_folder\csv\outlier_corrected_movement_location\FRR_gq_Saline_0624.csv"
     >>> animal_data = read_df(file_path=data_path, file_type='csv', usecols=['Nose_x', 'Nose_y', 'Tail_base_x', 'Tail_base_y', 'Left_side_x', 'Left_side_y', 'Right_side_x', 'Right_side_y']).values.reshape(-1, 4, 2)[0:20].astype(np.int32)
@@ -114,7 +119,7 @@ def geometries_to_coco(geometries: Dict[str, np.ndarray],
                 img_save_path = os.path.join(save_img_dir, img_name)
                 cv2.imwrite(img_save_path, img)
                 img_names.append(img_name)
-            annotation_id = category_cnt * img_cnt + 1
+            annotation_id = len(annotations) + 1
             d = GeometryMixin().get_shape_lengths_widths(shapes=Polygon(img_geometry))
             a_h, a_w, a_a = d['max_length'], d['max_width'], d['max_area']
             bbox = [int(category_data[img_cnt][0][0]), int(category_data[img_cnt][0][1]), int(a_w), int(a_h)]
@@ -137,6 +142,11 @@ def geometries_to_yolo(geometries: Dict[Union[str, int], np.ndarray],
     """
     Converts geometrical shapes (like polygons) into YOLO format annotations and saves them along with corresponding video frames as images.
 
+    .. image:: _static/img/geometries_to_yolo.webp
+       :alt: Geometries to YOLO
+       :width: 700
+       :align: center
+
     :param Dict[Union[str, int], np.ndarray geometries: A dictionary where the keys represent category IDs (either string or int), and the values are NumPy arrays of shape `(n_frames, n_points, 2)`. Each entry in the array represents the geometry of an object in a particular frame (e.g., keypoints or polygons).
     :param Union[str, os.PathLike] video_path: Path to the video file from which frames are extracted. The video is used to extract images corresponding to the geometrical annotations.
     :param Union[str, os.PathLike] save_dir: The directory where the output images and YOLO annotation files will be saved. Images will be stored in a subfolder `images/` and annotations in `labels/`.
@@ -204,7 +214,7 @@ def geometries_to_yolo(geometries: Dict[Union[str, int], np.ndarray],
                     results[img_name] = [img_results]
                 else:
                     results[img_name].append(img_results)
-                lbl_cnt =+ 1
+                lbl_cnt += 1
 
     for k, v in results.items():
         name = k.split(sep='.', maxsplit=2)[0]
@@ -367,6 +377,11 @@ def dlc_to_labelme(dlc_dir: Union[str, os.PathLike],
     """
     Convert a folder of DLC annotations into labelme json format.
 
+    .. image:: _static/img/dlc_to_labelme.webp
+       :alt: DLC to Labelme
+       :width: 700
+       :align: center
+
     :param Union[str, os.PathLike] dlc_dir: Folder with DLC annotations. I.e., directory inside
     :param Union[str, os.PathLike] save_dir: Directory to where to save the labelme json files.
     :param Optional[str] labelme_version: Version number encoded in the json files.
@@ -741,6 +756,11 @@ def simba_rois_to_yolo(config_path: Optional[Union[str, os.PathLike]] = None,
     """
     Converts SimBA roi definitions into annotations and images for training yolo network.
 
+    .. image:: _static/img/simba_rois_to_yolo.webp
+       :alt: SimBA ROIs to YOLO
+       :width: 700
+       :align: center
+
     :param Optional[Union[str, os.PathLike]] config_path: Optional path to the project config file in SimBA project.
     :param Optional[Union[str, os.PathLike]] roi_path: Path to the SimBA roi definitions .h5 file. If None, then the ``roi_coordinates_path`` of the project.
     :param Optional[Union[str, os.PathLike]] video_dir: Directory where to find the videos. If None, then the videos folder of the project.
@@ -883,12 +903,16 @@ def yolo_obb_data_to_bounding_box(center_x: float, center_y: float, width: float
     this function computes the coordinates of the four corner points of the bounding box,
     with rotation applied about the center.
 
+    .. image:: _static/img/yolo_obb_data_to_bounding_box.webp
+       :alt: YOLO OBB data to bounding box
+       :width: 600
+       :align: center
+
     :param float center_x: The x-coordinate of the bounding box center.
     :param float center_y: The y-coordinate of the bounding box center.
     :param float width: The width of the bounding box.
     :param float height: The height of the bounding box.
     :param float angle: The rotation angle of the bounding box in degrees, measured counterclockwise.
-
     :return: An array of shape (4, 2) containing the (x, y) coordinates of the four corners of the bounding box in the following order: top-left, top-right, bottom-right, and bottom-left.
     :rtype: np.ndarray
     """

{simba_uw_tf_dev-5.4.3 → simba_uw_tf_dev-5.4.4}/simba/third_party_label_appenders/transform/litpose_merge_projects.py

@@ -344,9 +344,9 @@ class LitPoseMergeProjects:
 
 
 
-# merger = LitPoseMergeProjects(master_dir=r'Z:\home\simon\LPProjects\project_0609_5cam_simon',
-#                               other_dirs=[r"Z:\home\simon\LPProjects\project_0609_5cam"],
-#                               duplicate_method='skip',
-#                               verbose=True,
-#                               skip_videos=True)
-# merger.run()
+merger = LitPoseMergeProjects(master_dir=r'H:\sina\project_0609_5cam\project_0609_5cam',
+                              other_dirs=[r"H:\sina\project_0609_5cam_simon", r"H:\sina\project_0615\project_0615"],
+                              duplicate_method='skip',
+                              verbose=True,
+                              skip_videos=False)
+merger.run()