simba-uw-tf-dev 4.6.7__py3-none-any.whl → 4.6.8__py3-none-any.whl

simba/assets/.recent_projects.txt

@@ -1,2 +1,3 @@
+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/data_processors/circling_detector.py

@@ -11,12 +11,13 @@ from simba.mixins.feature_extraction_mixin import FeatureExtractionMixin
 from simba.mixins.timeseries_features_mixin import TimeseriesFeatureMixin
 from simba.utils.checks import (
     check_all_file_names_are_represented_in_video_log, check_if_dir_exists,
-    check_int, check_str, check_valid_dataframe)
+    check_str, check_valid_dataframe)
 from simba.utils.data import detect_bouts, plug_holes_shortest_bout
 from simba.utils.enums import Formats
 from simba.utils.printing import stdout_success
 from simba.utils.read_write import (find_files_of_filetypes_in_directory,
-                                    get_fn_ext, read_df, read_video_info)
+                                    get_current_time, get_fn_ext, read_df,
+                                    read_video_info)
 
 CIRCLING = 'CIRCLING'
 
@@ -58,30 +59,34 @@ class CirclingDetector(ConfigReader):
     """
 
     def __init__(self,
-                 data_dir: Union[str, os.PathLike],
                  config_path: Union[str, os.PathLike],
                  nose_name: Optional[str] = 'nose',
+                 data_dir: Optional[Union[str, os.PathLike]] = None,
                  left_ear_name: Optional[str] = 'left_ear',
                  right_ear_name: Optional[str] = 'right_ear',
                  tail_base_name: Optional[str] = 'tail_base',
                  center_name: Optional[str] = 'center',
-                 time_threshold: Optional[int] = 10,
-                 circular_range_threshold: Optional[int] = 320,
+                 time_threshold: Optional[int] = 7,
+                 circular_range_threshold: Optional[int] = 350,
+                 shortest_bout: int = 100,
                  movement_threshold: Optional[int] = 60,
                  save_dir: Optional[Union[str, os.PathLike]] = None):
 
-        check_if_dir_exists(in_dir=data_dir)
         for bp_name in [nose_name, left_ear_name, right_ear_name, tail_base_name]: check_str(name='body part name', value=bp_name, allow_blank=False)
-        self.data_paths = find_files_of_filetypes_in_directory(directory=data_dir, extensions=['.csv'])
         ConfigReader.__init__(self, config_path=config_path, read_video_info=True, create_logger=False)
+        if data_dir is not None:
+            check_if_dir_exists(in_dir=data_dir)
+        else:
+            data_dir = self.outlier_corrected_dir
+        self.data_paths = find_files_of_filetypes_in_directory(directory=data_dir, extensions=['.csv'])
         self.nose_heads = [f'{nose_name}_x'.lower(), f'{nose_name}_y'.lower()]
         self.left_ear_heads = [f'{left_ear_name}_x'.lower(), f'{left_ear_name}_y'.lower()]
         self.right_ear_heads = [f'{right_ear_name}_x'.lower(), f'{right_ear_name}_y'.lower()]
         self.center_heads = [f'{center_name}_x'.lower(), f'{center_name}_y'.lower()]
         self.required_field = self.nose_heads + self.left_ear_heads + self.right_ear_heads
-        self.save_dir = save_dir
+        self.save_dir, self.shortest_bout = save_dir, shortest_bout
         if self.save_dir is None:
-            self.save_dir = os.path.join(self.logs_path, f'circling_data_{self.datetime}')
+            self.save_dir = os.path.join(self.logs_path, f'circling_data_{time_threshold}s_{circular_range_threshold}d_{movement_threshold}mm_{self.datetime}')
             os.makedirs(self.save_dir)
         else:
             check_if_dir_exists(in_dir=self.save_dir)
@@ -93,7 +98,7 @@ class CirclingDetector(ConfigReader):
         check_all_file_names_are_represented_in_video_log(video_info_df=self.video_info_df, data_paths=self.data_paths)
         for file_cnt, file_path in enumerate(self.data_paths):
             video_name = get_fn_ext(filepath=file_path)[1]
-            print(f'Analyzing {video_name} ({file_cnt+1}/{len(self.data_paths)})...')
+            print(f'[{get_current_time()}] Analyzing circling {video_name}... (video {file_cnt+1}/{len(self.data_paths)})')
             save_file_path = os.path.join(self.save_dir, f'{video_name}.csv')
             df = read_df(file_path=file_path, file_type='csv').reset_index(drop=True)
             _, px_per_mm, fps = read_video_info(video_info_df=self.video_info_df, video_name=video_name)
@@ -115,11 +120,24 @@ class CirclingDetector(ConfigReader):
             circling_idx = np.argwhere(sliding_circular_range >= self.circular_range_threshold).astype(np.int32).flatten()
             movement_idx = np.argwhere(movement_sum >= self.movement_threshold).astype(np.int32).flatten()
             circling_idx = [x for x in movement_idx if x in circling_idx]
+            df[f'Probability_{CIRCLING}'] = 0
             df[CIRCLING] = 0
             df.loc[circling_idx, CIRCLING] = 1
+            df.loc[circling_idx, f'Probability_{CIRCLING}'] = 1
+            df = plug_holes_shortest_bout(data_df=df, clf_name=CIRCLING, fps=fps, shortest_bout=self.shortest_bout)
             bouts = detect_bouts(data_df=df, target_lst=[CIRCLING], fps=fps)
-            df = plug_holes_shortest_bout(data_df=df, clf_name=CIRCLING, fps=fps, shortest_bout=100)
+            if len(bouts) > 0:
+                df[CIRCLING] = 0
+                circling_idx = list(bouts.apply(lambda x: list(range(int(x["Start_frame"]), int(x["End_frame"]) + 1)), 1))
+                circling_idx = [x for xs in circling_idx for x in xs]
+                df.loc[circling_idx, CIRCLING] = 1
+                df.loc[circling_idx, f'Probability_{CIRCLING}'] = 1
+            else:
+                df[CIRCLING] = 0
+                circling_idx = []
+
             df.to_csv(save_file_path)
+            #print(video_name, len(circling_idx), round(len(circling_idx) / fps, 4), df[CIRCLING].sum())
             agg_results.loc[len(agg_results)] = [video_name, len(circling_idx), round(len(circling_idx) / fps, 4), len(bouts), round((len(circling_idx) / len(df)) * 100, 4), len(df), round(len(df)/fps, 2) ]
 
         agg_results.to_csv(agg_results_path)
@@ -127,7 +145,6 @@ class CirclingDetector(ConfigReader):
 
 #
 #
-# detector = CirclingDetector(data_dir=r'C:\troubleshooting\mitra\project_folder\csv\outlier_corrected_movement_location',
-#                             config_path=r"C:\troubleshooting\mitra\project_folder\project_config.ini")
+# detector = CirclingDetector(config_path=r"E:\troubleshooting\mitra_emergence\project_folder\project_config.ini")
 # detector.run()
 

simba/data_processors/cuda/image.py

@@ -332,12 +332,22 @@ def _digital(data, results):
 def img_stack_brightness(x: np.ndarray,
                          method: Optional[Literal['photometric', 'digital']] = 'digital',
                          ignore_black: bool = True,
-                         verbose: bool = False) -> np.ndarray:
+                         verbose: bool = False,
+                         batch_size: int = 2500) -> np.ndarray:
     """
     Calculate the average brightness of a stack of images using a specified method.
 
     Useful for analyzing light cues or brightness changes over time. For example, compute brightness in images containing a light cue ROI, then perform clustering (e.g., k-means) on brightness values to identify frames when the light cue is on vs off.
 
+    .. csv-table::
+       :header: EXPECTED RUNTIMES
+       :file: ../../../docs/tables/img_stack_brightness_gpu.csv
+       :widths: 10, 45, 45
+       :align: center
+       :class: simba-table
+       :header-rows: 1
+
+
     - **Photometric Method**: The brightness is calculated using the formula:
 
     .. math::
@@ -365,27 +375,41 @@ def img_stack_brightness(x: np.ndarray,
 
     check_instance(source=img_stack_brightness.__name__, instance=x, accepted_types=(np.ndarray,))
     check_if_valid_img(data=x[0], source=img_stack_brightness.__name__)
+    check_int(name=f'{img_stack_brightness.__name__} batch_size', value=batch_size, allow_zero=False, allow_negative=False, raise_error=True)
     x, timer = np.ascontiguousarray(x).astype(np.uint8), SimbaTimer(start=True)
+    results = []
     if x.ndim == 4:
-        grid_x = (x.shape[1] + 16 - 1) // 16
-        grid_y = (x.shape[2] + 16 - 1) // 16
-        grid_z = x.shape[0]
-        threads_per_block = (16, 16, 1)
-        blocks_per_grid = (grid_y, grid_x, grid_z)
-        x_dev = cuda.to_device(x)
-        results = cuda.device_array((x.shape[0], x.shape[1], x.shape[2]), dtype=np.uint8)
-        if method == PHOTOMETRIC:
-            _photometric[blocks_per_grid, threads_per_block](x_dev, results)
+        batch_results_dev = cuda.device_array((batch_size, x.shape[1], x.shape[2]), dtype=np.uint8)
+    for batch_cnt, l in enumerate(range(0, x.shape[0], batch_size)):
+        r = l + batch_size
+        batch_x = x[l:r]
+        if batch_x.ndim == 4:
+            grid_x = (batch_x.shape[1] + 16 - 1) // 16
+            grid_y = (batch_x.shape[2] + 16 - 1) // 16
+            grid_z = batch_x.shape[0]
+            threads_per_block = (16, 16, 1)
+            blocks_per_grid = (grid_y, grid_x, grid_z)
+            x_dev = cuda.to_device(batch_x)
+            if method == PHOTOMETRIC:
+                _photometric[blocks_per_grid, threads_per_block](x_dev, batch_results_dev)
+            else:
+                _digital[blocks_per_grid, threads_per_block](x_dev, batch_results_dev)
+            batch_results_host = batch_results_dev.copy_to_host()[:batch_x.shape[0]]
+            batch_results_cp = cp.asarray(batch_results_host)
+            if ignore_black:
+                mask = batch_results_cp != 0
+                batch_results_cp = cp.where(mask, batch_results_cp, cp.nan)
+                batch_results = cp.nanmean(batch_results_cp, axis=(1, 2))
+                batch_results = cp.where(cp.isnan(batch_results), 0, batch_results)
+                batch_results = batch_results.get()
+            else:
+                batch_results = cp.mean(batch_results_cp, axis=(1, 2)).get()
         else:
-            _digital[blocks_per_grid, threads_per_block](x_dev, results)
-        results = results.copy_to_host()
-        if ignore_black:
-            masked_array = np.ma.masked_equal(results, 0)
-            results = np.mean(masked_array, axis=(1, 2)).filled(0)
-    else:
-        results = deepcopy(x)
-        results = np.mean(results, axis=(1, 2))
+            batch_results = deepcopy(x)
+            batch_results = np.mean(batch_results, axis=(1, 2))
+        results.append(batch_results)
     timer.stop_timer()
+    results = np.concatenate(results) if len(results) > 0 else np.array([])
     if verbose: print(f'Brightness computed in {results.shape[0]} images (elapsed time {timer.elapsed_time_str}s)')
     return results
 

simba/data_processors/cuda/statistics.py

@@ -19,7 +19,6 @@ from scipy.spatial import ConvexHull
 from simba.utils.read_write import get_unique_values_in_iterable, read_df
 from simba.utils.warnings import GPUToolsWarning
 
-
 try:
     import cupy as cp
     from cupyx.scipy.spatial.distance import cdist
@@ -44,8 +43,8 @@ except:
 
 from simba.data_processors.cuda.utils import _cuda_are_rows_equal
 from simba.mixins.statistics_mixin import Statistics
-from simba.utils.checks import (check_int, check_str, check_valid_array,
-                                check_valid_tuple, check_float)
+from simba.utils.checks import (check_float, check_int, check_str,
+                                check_valid_array, check_valid_tuple)
 from simba.utils.data import bucket_data
 from simba.utils.enums import Formats
 

simba/data_processors/freezing_detector.py

@@ -1,10 +1,8 @@
 import os
 from typing import Optional, Union
-
 import numpy as np
 import pandas as pd
 from numba import typed
-
 from simba.mixins.config_reader import ConfigReader
 from simba.mixins.feature_extraction_mixin import FeatureExtractionMixin
 from simba.mixins.timeseries_features_mixin import TimeseriesFeatureMixin
@@ -14,65 +12,73 @@ from simba.utils.checks import (
 from simba.utils.data import detect_bouts, plug_holes_shortest_bout
 from simba.utils.enums import Formats
 from simba.utils.printing import stdout_success
-from simba.utils.read_write import (find_files_of_filetypes_in_directory,
-                                    get_fn_ext, read_df, read_video_info)
+from simba.utils.read_write import (find_files_of_filetypes_in_directory, get_fn_ext, read_df, read_video_info, get_current_time)
 
 NAPE_X, NAPE_Y = 'nape_x', 'nape_y'
 FREEZING = 'FREEZING'
 
 class FreezingDetector(ConfigReader):
-
     """
-    Detect freezing behavior using heuristic rules.
-
+    Detect freezing behavior using heuristic rules based on movement velocity thresholds.
+    Analyzes pose-estimation data to detect freezing episodes by computing the mean velocity
+    of key body parts (nape, nose, and tail-base) and identifying periods where movement falls below
+    a specified threshold for a minimum duration.
     .. important::
-
         Freezing is detected as `present` when **the velocity (computed from the mean movement of the nape, nose, and tail-base body-parts) falls below
-        the movement threshold for the duration (and longer) of the specied time-window**.
-
+        the movement threshold for the duration (and longer) of the specified time-window**.
         Freezing is detected as `absent` when not present.
-
     .. note::
-
-       We pass the names of the left and right ears, as the method will use body-parts to compute the `nape` location of the animal.
-
-    :param Union[str, os.PathLike] data_dir: Path to directory containing pose-estimated body-part data in CSV format.
-    :param Union[str, os.PathLike] config_path: Path to SimBA project config file.
-    :param Optional[str] nose_name: The name of the pose-estimated nose body-part. Defaults to 'nose'.
-    :param Optional[str] left_ear_name: The name of the pose-estimated left ear body-part. Defaults to 'left_ear'.
-    :param Optional[str] right_ear_name: The name of the pose-estimated right ear body-part. Defaults to 'right_ear'.
-    :param Optional[str] tail_base_name: The name of the pose-estimated tail base body-part. Defaults to 'tail_base'.
-    :param Optional[int] time_window: The time window in preceding seconds in which to evaluate freezing. Default: 3.
-    :param Optional[int] movement_threshold: A movement threshold in millimeters per second. Defaults to 5.
-    :param Optional[Union[str, os.PathLike]] save_dir: Directory where to store the results. If None, then results are stored in the ``logs`` directory of the SimBA project.
-
+       The method uses the left and right ear body-parts to compute the `nape` location of the animal
+       as the midpoint between the ears. The nape, nose, and tail-base movements are averaged to compute
+       overall animal movement velocity.
+    :param Union[str, os.PathLike] data_dir: Path to directory containing pose-estimated body-part data in CSV format. Each CSV file should contain pose estimation data for one video.
+    :param Union[str, os.PathLike] config_path: Path to SimBA project config file (`.ini` format) containing project settings and video information.
+    :param Optional[str] nose_name: The name of the pose-estimated nose body-part column (without _x/_y suffix). Defaults to 'nose'.
+    :param Optional[str] left_ear_name: The name of the pose-estimated left ear body-part column (without _x/_y suffix). Defaults to 'Left_ear'.
+    :param Optional[str] right_ear_name: The name of the pose-estimated right ear body-part column (without _x/_y suffix). Defaults to 'right_ear'.
+    :param Optional[str] tail_base_name: The name of the pose-estimated tail base body-part column (without _x/_y suffix). Defaults to 'tail_base'.
+    :param Optional[int] time_window: The minimum time window in seconds that movement must be below the threshold to be considered freezing. Only freezing bouts lasting at least this duration are retained. Defaults to 3.
+    :param Optional[int] movement_threshold: Movement threshold in millimeters per second. Frames with mean velocity below this threshold are considered potential freezing. Defaults to 5.
+    :param Optional[int] shortest_bout: Minimum duration in milliseconds for a freezing bout to be considered valid. Shorter bouts are filtered out. Defaults to 100.
+    :param Optional[Union[str, os.PathLike]] save_dir: Directory where to store the results. If None, then results are stored in a timestamped subdirectory within the ``logs`` directory of the SimBA project.
+    :returns: None. Results are saved to CSV files in the specified save directory:
+        - Individual video results: One CSV file per video with freezing annotations added as a 'FREEZING' column (1 = freezing, 0 = not freezing)
+        - Aggregate results: `aggregate_freezing_results.csv` containing summary statistics for all videos
     :example:
-    >>> FreezingDetector(data_dir=r'D:\troubleshooting\mitra\project_folder\csv\outlier_corrected_movement_location', config_path=r"D:\troubleshooting\mitra\project_folder\project_config.ini")
-
+    >>> FreezingDetector(
+    ...     data_dir=r'D:\\troubleshooting\\mitra\\project_folder\\csv\\outlier_corrected_movement_location',
+    ...     config_path=r"D:\\troubleshooting\\mitra\\project_folder\\project_config.ini",
+    ...     time_window=3,
+    ...     movement_threshold=5,
+    ...     shortest_bout=100
+    ... ).run()
     References
     ----------
+    ..
     .. [1] Sabnis et al., Visual detection of seizures in mice using supervised machine learning, `biorxiv`, doi: https://doi.org/10.1101/2024.05.29.596520.
     .. [2] Lopez et al., Region-specific Nucleus Accumbens Dopamine Signals Encode Distinct Aspects of Avoidance Learning, `biorxiv`, doi: https://doi.org/10.1101/2024.08.28.610149
-    .. [3] Lopez, Gabriela C., Louis D. Van Camp, Ryan F. Kovaleski, et al. “Region-Specific Nucleus Accumbens Dopamine Signals Encode Distinct Aspects of Avoidance Learning.” `Cell Biology`, Volume 35, Issue 10p2433-2443.e5May 19, 2025. DOI: 10.1016/j.cub.2025.04.006
+    .. [3] Lopez, Gabriela C., Louis D. Van Camp, Ryan F. Kovaleski, et al. "Region-Specific Nucleus Accumbens Dopamine Signals Encode Distinct Aspects of Avoidance Learning." `Cell Biology`, Volume 35, Issue 10p2433-2443.e5May 19, 2025. DOI: 10.1016/j.cub.2025.04.006
     .. [4] Lazaro et al., Brainwide Genetic Capture for Conscious State Transitions, `biorxiv`, doi: https://doi.org/10.1101/2025.03.28.646066
+    .. [5] Sabnis et al., Visual detection of seizures in mice using supervised machine learning, 2025, Cell Reports Methods 5, 101242 December 15, 2025.
     """
-
     def __init__(self,
-                 data_dir: Union[str, os.PathLike],
                  config_path: Union[str, os.PathLike],
-                 nose_name: Optional[str] = 'nose',
-                 left_ear_name: Optional[str] = 'Left_ear',
-                 right_ear_name: Optional[str] = 'right_ear',
-                 tail_base_name: Optional[str] = 'tail_base',
-                 time_window: Optional[int] = 3,
-                 movement_threshold: Optional[int] = 5,
-                 shortest_bout: Optional[int] = 100,
+                 nose_name: str = 'nose',
+                 left_ear_name: str = 'Left_ear',
+                 right_ear_name: str = 'right_ear',
+                 tail_base_name: str = 'tail_base',
+                 data_dir: Optional[Union[str, os.PathLike]] = None,
+                 time_window: int = 4,
+                 movement_threshold: int = 5,
+                 shortest_bout: int = 100,
                  save_dir: Optional[Union[str, os.PathLike]] = None):
-
-        check_if_dir_exists(in_dir=data_dir)
         for bp_name in [nose_name, left_ear_name, right_ear_name, tail_base_name]: check_str(name='body part name', value=bp_name, allow_blank=False)
-        self.data_paths = find_files_of_filetypes_in_directory(directory=data_dir, extensions=['.csv'])
         ConfigReader.__init__(self, config_path=config_path, read_video_info=True, create_logger=False)
+        if data_dir is not None:
+            check_if_dir_exists(in_dir=data_dir)
+        else:
+            data_dir = self.outlier_corrected_dir
+        self.data_paths = find_files_of_filetypes_in_directory(directory=data_dir, extensions=['.csv'])
         self.nose_heads = [f'{nose_name}_x'.lower(), f'{nose_name}_y'.lower()]
         self.left_ear_heads = [f'{left_ear_name}_x'.lower(), f'{left_ear_name}_y'.lower()]
         self.right_ear_heads = [f'{right_ear_name}_x'.lower(), f'{right_ear_name}_y'.lower()]
@@ -82,21 +88,19 @@ class FreezingDetector(ConfigReader):
         check_int(name='movement_threshold', value=movement_threshold, min_value=1)
         self.save_dir = save_dir
         if self.save_dir is None:
-            self.save_dir = os.path.join(self.logs_path, f'freezing_data_time_{time_window}s_{self.datetime}')
+            self.save_dir = os.path.join(self.logs_path, f'freezing_data_time_{time_window}s_{movement_threshold}mm_{self.datetime}')
             os.makedirs(self.save_dir)
         else:
             check_if_dir_exists(in_dir=self.save_dir)
         self.time_window, self.movement_threshold = time_window, movement_threshold
         self.movement_threshold, self.shortest_bout = movement_threshold, shortest_bout
-        self.run()
-
     def run(self):
         agg_results = pd.DataFrame(columns=['VIDEO', 'FREEZING FRAMES', 'FREEZING TIME (S)', 'FREEZING BOUT COUNTS', 'FREEZING PCT OF SESSION', 'VIDEO TOTAL FRAMES', 'VIDEO TOTAL TIME (S)'])
-        agg_results_path = os.path.join(self.save_dir, 'aggregate_freezing_results.csv')
+        agg_results_path = os.path.join(self.save_dir, f'aggregate_freezing_results_{self.datetime}.csv')
         check_all_file_names_are_represented_in_video_log(video_info_df=self.video_info_df, data_paths=self.data_paths)
         for file_cnt, file_path in enumerate(self.data_paths):
             video_name = get_fn_ext(filepath=file_path)[1]
-            print(f'Analyzing {video_name}...({file_cnt+1}/{len(self.data_paths)})')
+            print(f'[{get_current_time()}] Analyzing freezing {video_name}...(video {file_cnt+1}/{len(self.data_paths)})')
             save_file_path = os.path.join(self.save_dir, f'{video_name}.csv')
             df = read_df(file_path=file_path, file_type='csv').reset_index(drop=True)
             _, px_per_mm, fps = read_video_info(vid_info_df=self.video_info_df, video_name=video_name)
@@ -118,23 +122,23 @@ class FreezingDetector(ConfigReader):
             mean_movement = np.mean(movement, axis=1)
             mm_s = TimeseriesFeatureMixin.sliding_descriptive_statistics(data=mean_movement.astype(np.float32), window_sizes=np.array([1], dtype=np.float64), sample_rate=int(fps), statistics=typed.List(["sum"]))[0].flatten()
             freezing_idx = np.argwhere(mm_s <= self.movement_threshold).astype(np.int32).flatten()
+            df[f'Probability_{FREEZING}'] = 0
             df[FREEZING] = 0
             df.loc[freezing_idx, FREEZING] = 1
             df = plug_holes_shortest_bout(data_df=df, clf_name=FREEZING, fps=fps, shortest_bout=self.shortest_bout)
             bouts = detect_bouts(data_df=df, target_lst=[FREEZING], fps=fps)
             bouts = bouts[bouts['Bout_time'] >= self.time_window]
             if len(bouts) > 0:
+                df[FREEZING] = 0
                 freezing_idx = list(bouts.apply(lambda x: list(range(int(x["Start_frame"]), int(x["End_frame"]) + 1)), 1))
                 freezing_idx = [x for xs in freezing_idx for x in xs]
                 df.loc[freezing_idx, FREEZING] = 1
+                df.loc[freezing_idx, f'Probability_{FREEZING}'] = 1
             else:
+                df[FREEZING] = 0
                 freezing_idx = []
             df.to_csv(save_file_path)
+            print(video_name, len(freezing_idx), round(len(freezing_idx) / fps, 4), df[FREEZING].sum())
             agg_results.loc[len(agg_results)] = [video_name, len(freezing_idx), round(len(freezing_idx) / fps, 4), len(bouts), round((len(freezing_idx) / len(df)) * 100, 4), len(df), round(len(df)/fps, 2) ]
-
         agg_results.to_csv(agg_results_path)
-        stdout_success(msg=f'Results saved in {self.save_dir} directory.')
-
-#
-# FreezingDetector(data_dir=r'C:\troubleshooting\mitra\project_folder\csv\outlier_corrected_movement_location',
-#                  config_path=r"C:\troubleshooting\mitra\project_folder\project_config.ini")
+        self.timer.stop_timer(); stdout_success(msg=f'Results saved in {self.save_dir} directory.', elapsed_time=self.timer.elapsed_time_str)

simba/feature_extractors/mitra_feature_extractor.py

@@ -28,7 +28,7 @@ RIGHT_EAR = 'right_ear'
 CENTER = 'center'
 TAIL_BASE = 'tail_base'
 TAIL_CENTER = 'tail_center'
-TAIL_TIP = 'tail_tip'
+TAIL_TIP = 'tail_end'
 
 TIME_WINDOWS = np.array([0.25, 0.5, 1.0, 2.0])
 
@@ -207,7 +207,7 @@ class MitraFeatureExtractor(ConfigReader,
 
 
 
-# feature_extractor = MitraFeatureExtractor(config_path=r"D:\troubleshooting\mitra\project_folder\project_config.ini")
+# feature_extractor = MitraFeatureExtractor(config_path=r"E:\troubleshooting\mitra_emergence\project_folder\project_config.ini")
 # feature_extractor.run()
 
 

simba/mixins/config_reader.py

@@ -41,8 +41,8 @@ from simba.utils.read_write import (find_core_cnt, get_all_clf_names,
                                     get_fn_ext, read_config_file, read_df,
                                     read_project_path_and_file_type, write_df)
 from simba.utils.warnings import (BodypartColumnNotFoundWarning,
-                                  InvalidValueWarning, NoDataFoundWarning,
-                                  NoFileFoundWarning)
+                                  DuplicateNamesWarning, InvalidValueWarning,
+                                  NoDataFoundWarning, NoFileFoundWarning)
 
 
 class ConfigReader(object):
@@ -610,11 +610,14 @@ class ConfigReader(object):
         >>> config_reader.get_bp_headers()
         """
 
+        duplicates = list({x for x in self.body_parts_lst if self.body_parts_lst.count(x) > 1})
+        if len(duplicates) > 0: DuplicateNamesWarning(msg=f'The pose configuration file at {self.body_parts_path} contains duplicate entries: {duplicates}', source=self.__class__.__name__)
         self.bp_headers = []
         for bp in self.body_parts_lst:
             c1, c2, c3 = (f"{bp}_x", f"{bp}_y", f"{bp}_p")
             self.bp_headers.extend((c1, c2, c3))
 
+
     def read_config_entry(
         self,
         config: ConfigParser,

simba/mixins/plotting_mixin.py

@@ -39,7 +39,7 @@ from simba.utils.data import create_color_palette, detect_bouts
 from simba.utils.enums import Formats, Keys, Options, Paths
 from simba.utils.errors import InvalidInputError
 from simba.utils.lookups import (get_categorical_palettes, get_color_dict,
-                                 get_named_colors)
+                                 get_fonts, get_named_colors)
 from simba.utils.printing import SimbaTimer, stdout_success
 from simba.utils.read_write import (find_files_of_filetypes_in_directory,
                                     get_fn_ext, get_video_meta_data, read_df,
@@ -342,16 +342,28 @@ class PlottingMixin(object):
                         height: int = 480,
                         font_size: int = 8,
                         font_rotation: int = 45,
+                        font: Optional[str] = None,
                         save_path: Optional[str] = None,
+                        edge_clr: Optional[str] = 'black',
                         hhmmss: bool = False) -> Union[None, np.ndarray]:
 
         video_timer = SimbaTimer(start=True)
         colour_tuple_x = list(np.arange(3.5, 203.5, 5))
+        original_font_family = copy(plt.rcParams['font.family']) if isinstance(plt.rcParams['font.family'], list) else plt.rcParams['font.family']
+        
+        if font is not None:
+            available_fonts = get_fonts()
+            if font in available_fonts:
+                matplotlib.font_manager._get_font.cache_clear()
+                plt.rcParams['font.family'] = font
+            else:
+                matplotlib.font_manager._get_font.cache_clear()
+                plt.rcParams['font.family'] = [font, 'sans-serif']
+        
         fig, ax = plt.subplots()
-        fig.patch.set_facecolor('#fafafa')
-        ax.set_facecolor('#ffffff')
         fig.patch.set_facecolor('white')
-        plt.title(video_name, fontsize=font_size + 6, pad=15, fontweight='bold')
+        
+        plt.title(video_name, fontsize=font_size + 6, pad=25, fontweight='bold')
         ax.spines['top'].set_visible(False)
         ax.spines['right'].set_visible(False)
         ax.spines['left'].set_color('#666666')
@@ -367,7 +379,7 @@ class PlottingMixin(object):
                 if event[0] == x:
                     ix = clf_names.index(x)
                     data_event = event[1][["Start_time", "Bout_time"]]
-                    ax.broken_barh(data_event.values, (colour_tuple_x[ix], 3), facecolors=palette[ix])
+                    ax.broken_barh(data_event.values, (colour_tuple_x[ix], 3), facecolors=palette[ix], edgecolor=edge_clr, linewidth=0.5, alpha=0.9)
 
         x_ticks_seconds = np.round(np.linspace(0, x_length / fps, 6))
         x_ticks_locs = x_ticks_seconds
@@ -375,18 +387,19 @@ class PlottingMixin(object):
         if hhmmss:
             x_lbls = [seconds_to_timestamp(sec) for sec in x_ticks_seconds]
         else:
-            x_lbls = x_ticks_seconds
+            x_lbls = [int(x) for x in x_ticks_seconds]
 
-        #x_ticks_locs = x_lbls = np.round(np.linspace(0, x_length / fps, 6))
         ax.set_xticks(x_ticks_locs)
         ax.set_xticklabels(x_lbls)
         ax.set_ylim(0, colour_tuple_x[len(clf_names)])
         ax.set_yticks(np.arange(5, 5 * len(clf_names) + 1, 5))
-        ax.set_yticklabels(clf_names, rotation=font_rotation)
+        ax.set_yticklabels(clf_names, rotation=font_rotation, ha='right', va='center')
         ax.tick_params(axis="both", labelsize=font_size)
         plt.xlabel(x_label, fontsize=font_size + 3)
-        ax.yaxis.grid(True, linewidth=1.5, color='gray', alpha=0.4, linestyle='--')
-        #ax.yaxis.grid(True)
+        ax.grid(True, axis='both', linewidth=1.0, color='gray', alpha=0.2, linestyle='--', which='major')
+
+        plt.subplots_adjust(left=0.1, right=0.95, top=0.9, bottom=0.15)
+        plt.tight_layout()
         buffer_ = io.BytesIO()
         plt.savefig(buffer_, format="png")
         buffer_.seek(0)
@@ -397,6 +410,11 @@ class PlottingMixin(object):
         frame = np.uint8(open_cv_image)
         buffer_.close()
         plt.close('all')
+
+        if font is not None:
+            plt.rcParams['font.family'] = original_font_family
+            matplotlib.font_manager._get_font.cache_clear()
+        
         if save_path is not None:
             cv2.imwrite(save_path, frame)
             video_timer.stop_timer()

simba/outlier_tools/skip_outlier_correction.py

@@ -47,5 +47,5 @@ class OutlierCorrectionSkipper(ConfigReader):
         self.timer.stop_timer()
         stdout_success(msg=f"Skipped outlier correction for {len(self.input_csv_paths)} files", elapsed_time=self.timer.elapsed_time_str)
 
-# test = OutlierCorrectionSkipper(config_path='/Users/simon/Desktop/envs/troubleshooting/naresh/project_folder/project_config.ini')
+# test = OutlierCorrectionSkipper(config_path=r"E:\troubleshooting\mitra_emergence\project_folder\project_config.ini")
 # test.run()

simba/plotting/gantt_creator.py

@@ -2,6 +2,7 @@ __author__ = "Simon Nilsson; sronilsson@gmail.com"
 
 import os
 import shutil
+from copy import deepcopy
 from typing import List, Optional, Union
 
 import cv2
@@ -16,7 +17,7 @@ from simba.utils.checks import (
 from simba.utils.data import create_color_palette, detect_bouts
 from simba.utils.enums import Formats, Options
 from simba.utils.errors import NoSpecifiedOutputError
-from simba.utils.lookups import get_named_colors
+from simba.utils.lookups import get_fonts, get_named_colors
 from simba.utils.printing import stdout_success
 from simba.utils.read_write import get_fn_ext, read_df
 
@@ -60,16 +61,18 @@ class GanttCreatorSingleProcess(ConfigReader, PlottingMixin):
 
     def __init__(self,
                  config_path: Union[str, os.PathLike],
-                 data_paths: List[Union[str, os.PathLike]],
+                 data_paths: Optional[Union[Union[str, os.PathLike], List[Union[str, os.PathLike]]]] = None,
                  width: int = 640,
                  height: int = 480,
                  font_size: int = 8,
                  font_rotation: int = 45,
+                 font: Optional[str] = None,
                  palette: str = 'Set1',
-                 frame_setting: Optional[bool] = False,
-                 video_setting: Optional[bool] = False,
-                 last_frm_setting: Optional[bool] = True,
-                 hhmmss: Optional[bool] = True):
+                 frame_setting: bool = False,
+                 video_setting: bool = False,
+                 last_frm_setting: bool = True,
+                 hhmmss: bool = True,
+                 clf_names: Optional[List[str]] = None):
 
         if ((frame_setting != True) and (video_setting != True) and (last_frm_setting != True)):
             raise NoSpecifiedOutputError(msg="SIMBA ERROR: Please select gantt videos, frames, and/or last frame.")
@@ -78,7 +81,13 @@ class GanttCreatorSingleProcess(ConfigReader, PlottingMixin):
         check_int(value=height, min_value=1, name=f'{self.__class__.__name__} height')
         check_int(value=font_size, min_value=1, name=f'{self.__class__.__name__} font_size')
         check_int(value=font_rotation, min_value=0, max_value=180, name=f'{self.__class__.__name__} font_rotation')
-        check_valid_lst(data=data_paths, source=f'{self.__class__.__name__} data_paths', valid_dtypes=(str,), min_len=1)
+        if isinstance(data_paths, list):
+            check_valid_lst(data=data_paths, source=f'{self.__class__.__name__} data_paths', valid_dtypes=(str,), min_len=1)
+        elif isinstance(data_paths, str):
+            check_file_exist_and_readable(file_path=data_paths)
+            data_paths = [data_paths]
+        else:
+            data_paths = deepcopy(self.machine_results_paths)
         check_valid_boolean(value=hhmmss, source=f'{self.__class__.__name__} hhmmss', raise_error=False)
         palettes = Options.PALETTE_OPTIONS_CATEGORICAL.value + Options.PALETTE_OPTIONS.value
         check_str(name=f'{self.__class__.__name__} palette', value=palette, options=palettes)
@@ -90,7 +99,12 @@ class GanttCreatorSingleProcess(ConfigReader, PlottingMixin):
         if not os.path.exists(self.gantt_plot_dir): os.makedirs(self.gantt_plot_dir)
         self.frame_setting, self.video_setting, self.last_frm_setting = frame_setting, video_setting, last_frm_setting
         self.width, self.height, self.font_size, self.font_rotation = width, height, font_size, font_rotation
-        self.data_paths, self.hhmmss = data_paths, hhmmss
+        if font is not None:
+            check_str(name=f'{self.__class__.__name__} font', value=font, options=list(get_fonts().keys()), raise_error=True)
+        if clf_names is not None:
+            check_valid_lst(data=clf_names, source=f'{self.__class__.__name__} clf_names', valid_dtypes=(str,), valid_values=self.clf_names, min_len=1, raise_error=True)
+            self.clf_names = clf_names
+        self.data_paths, self.hhmmss, self.font = data_paths, hhmmss, font
         self.colours = get_named_colors()
         self.colour_tuple_x = list(np.arange(3.5, 203.5, 5))
 
@@ -121,6 +135,7 @@ class GanttCreatorSingleProcess(ConfigReader, PlottingMixin):
                                      font_size=self.font_size,
                                      font_rotation=self.font_rotation,
                                      video_name=self.video_name,
+                                     font=self.font,
                                      save_path=os.path.join(self.gantt_plot_dir, f"{self.video_name }_final_image.png"),
                                      palette=self.clr_lst,
                                      hhmmss=self.hhmmss)
@@ -135,6 +150,7 @@ class GanttCreatorSingleProcess(ConfigReader, PlottingMixin):
                                                 width=self.width,
                                                 height=self.height,
                                                 font_size=self.font_size,
+                                                font=self.font,
                                                 font_rotation=self.font_rotation,
                                                 video_name=self.video_name,
                                                 palette=self.clr_lst,
@@ -156,13 +172,16 @@ class GanttCreatorSingleProcess(ConfigReader, PlottingMixin):
 # test = GanttCreatorSingleProcess(config_path=r"C:\troubleshooting\mitra\project_folder\project_config.ini",
 #                                 frame_setting=False,
 #                                 video_setting=False,
-#                                 data_paths=[r"C:\troubleshooting\mitra\project_folder\csv\machine_results\592_MA147_Gq_CNO_0515.csv"],
+#                                 data_paths=[r"C:\troubleshooting\mitra\project_folder\csv\machine_results\501_MA142_Gi_CNO_0516.csv"],
 #                                 last_frm_setting=True,
 #                                 width=640,
 #                                 height= 480,
 #                                 font_size=10,
+#                                  font=None,
 #                                 font_rotation=45,
-#                                 palette='Set1')
+#                                 hhmmss=False,
+#                                 palette='Set1',
+#                                 clf_names=['straub_tail'])
 # test.run()