simba-uw-tf-dev 5.4.1__tar.gz → 5.4.2__tar.gz

{simba_uw_tf_dev-5.4.1 → simba_uw_tf_dev-5.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba_uw_tf_dev
-Version: 5.4.1
+Version: 5.4.2
 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.1 → simba_uw_tf_dev-5.4.2}/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.1",
+    version="5.4.2",
     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.1 → simba_uw_tf_dev-5.4.2}/simba/assets/.recent_projects.txt

@@ -1,3 +1,4 @@
+H:/projects/nick_iso/nick_iso/project_folder/project_config.ini
 G:/projects/sleap_bp_order/by_order/project_folder/project_config.ini
 H:/projects/brainwide_trap/brainwide_trap/project_folder/project_config.ini
 D:/troubleshooting/open_field_below/project_folder/project_config.ini

{simba_uw_tf_dev-5.4.1 → simba_uw_tf_dev-5.4.2}/simba/feature_extractors/mitra_feature_extractor.py

@@ -231,8 +231,8 @@ class MitraFeatureExtractor(ConfigReader,
 #     feature_extractor = MitraFeatureExtractor(config_path=args.config_path)
 #     feature_extractor.run()
 #
-feature_extractor = MitraFeatureExtractor(config_path=r"H:\projects\brainwide_trap\brainwide_trap\project_folder\project_config.ini")
-feature_extractor.run()
+# feature_extractor = MitraFeatureExtractor(config_path=r"H:\projects\brainwide_trap\brainwide_trap\project_folder\project_config.ini")
+# feature_extractor.run()
 
 
 # feature_extractor = MitraFeatureExtractor(config_path=r"E:\troubleshooting\mitra_pbn\mitra_pbn\project_folder\project_config.ini")

{simba_uw_tf_dev-5.4.1 → simba_uw_tf_dev-5.4.2}/simba/mixins/geometry_mixin.py

@@ -3654,6 +3654,10 @@ class GeometryMixin(object):
         Hausdorff distance can be used to measure the similarity of the geometry in one frame relative to the geometry in the next frame.
         Larger values indicate that the animal has a different shape than in the preceding shape.
 
+        .. image:: _static/img/hausdorff_distance.webp
+           :width: 450
+           :align: center
+
         .. seealso::
            :func:`simba.mixins.geometry_mixin.GeometryMixin.multiframe_hausdorff_distance`
 
@@ -4172,6 +4176,10 @@ class GeometryMixin(object):
         smoothing is controlled by `smooth_factor`, and the number of interpolated points
         along the new smoothed boundary is determined by `points`.
 
+        .. image:: _static/img/smooth_geometry_bspline.webp
+           :width: 650
+           :align: center
+
         :param Union[np.ndarray, Polygon, List[Polygon]] data: The input geometry to be smoothed. This can be: A NumPy array of shape (N, 2) representing a single polygon. A NumPy array of shape (M, N, 2) representing multiple polygons. A `Polygon` object from Shapely. A list of `Polygon` objects.
         :param float smooth_factor: The smoothing factor for the B-spline. Higher values  result in smoother curves. Must be >= 0.1.
         :param int points: The number of interpolated points used to redefine the smoothed polygon boundary. Must be >= 3.

{simba_uw_tf_dev-5.4.1 → simba_uw_tf_dev-5.4.2}/simba/mixins/image_mixin.py

@@ -216,6 +216,10 @@ class ImageMixin(object):
         """
         Calculate contour similarity between two images.
 
+        .. image:: _static/img/get_contourmatch.webp
+           :width: 700
+           :align: center
+
         :param np.ndarray img_1: First input image (numpy array).
         :param np.ndarray img_2: Second input image (numpy array).
         :param Optional[Literal['all', 'exterior']] method: Method for contour extraction. Options: 'all' (all contours) or 'exterior' (only exterior contours). Defaults to 'all'.
@@ -249,7 +253,9 @@ class ImageMixin(object):
             img_2 = ImageMixin().canny_edge_detection(img=img_2)
         img_1_contours = ImageMixin().find_contours(img=img_1, mode=mode, method=method)
         img_2_contours = ImageMixin().find_contours(img=img_2, mode=mode, method=method)
-        return cv2.matchShapes(img_1_contours[0], img_2_contours[0], cv2.CONTOURS_MATCH_I1, 0.0)
+        cnt_1 = max(img_1_contours, key=cv2.contourArea)
+        cnt_2 = max(img_2_contours, key=cv2.contourArea)
+        return cv2.matchShapes(cnt_1, cnt_2, cv2.CONTOURS_MATCH_I1, 0.0)
 
     @staticmethod
     def slice_shapes_in_img(img: Union[np.ndarray, Tuple[cv2.VideoCapture, int]], geometries: List[Union[Polygon, np.ndarray]]) -> List[np.ndarray]:
@@ -265,6 +271,10 @@ class ImageMixin(object):
            For GPU acceleration, see :func:`simba.data_processors.cuda.image.slice_imgs`
            For single core method, see :func:`simba.mixins.image_mixin.ImageMixin.slice_shapes_in_imgs`
 
+        .. image:: _static/img/slice_shapes_in_img.webp
+           :width: 600
+           :align: center
+
         .. video:: _static/img/slice_imgs_gpu.webm
            :width: 800
            :autoplay:
@@ -1201,6 +1211,7 @@ class ImageMixin(object):
                  threshold: int,
                  method: str = 'absolute') -> np.ndarray:
 
+
         """
         Computes the difference between two images using the specified method and applies a threshold to produce a binary image.
 
@@ -1532,6 +1543,10 @@ class ImageMixin(object):
         of channels, they are converted to greyscale before computing the SSI. If the images are multi-channel (e.g., RGB),
         the SSI is computed for each channel.
 
+        .. image:: _static/img/structural_similarity_index.webp
+           :width: 700
+           :align: center
+
         .. seealso::
            For matrix SSI of image stack, see :func:`simba.mixins.image_mixin.ImageMixin.structural_similarity_matrix`
            for time-series based comparison, see :func:`simba.mixins.image_mixin.ImageMixin.sliding_structural_similarity_index`
@@ -1546,8 +1561,8 @@ class ImageMixin(object):
         check_if_valid_img(data=img_2, source=f'{ImageMixin.structural_similarity_index.__name__} img_2')
         multichannel = False
         if img_1.ndim != img_2.ndim:
-            img_1 = cv2.cvtColor(img_1, cv2.COLOR_BGR2GRAY)
-            img_2 = cv2.cvtColor(img_2, cv2.COLOR_BGR2GRAY)
+            if img_1.ndim == 3: img_1 = cv2.cvtColor(img_1, cv2.COLOR_BGR2GRAY)
+            if img_2.ndim == 3: img_2 = cv2.cvtColor(img_2, cv2.COLOR_BGR2GRAY)
         if img_1.ndim > 2: multichannel = True
         return abs(structural_similarity(im1=img_1.astype(np.uint8), im2=img_2.astype(np.uint8), multichannel=multichannel))
 
@@ -1650,6 +1665,10 @@ class ImageMixin(object):
 
         The NCC measures the similarity between two images by calculating the correlation coefficient of their pixel values. The output value ranges from -1 to 1, where 1 indicates perfect positive correlation, 0 indicates no correlation, and -1 indicates perfect negative correlation.
 
+        .. image:: _static/img/cross_correlation_similarity.webp
+           :width: 700
+           :align: center
+
         .. seealso::
            For time-series based NCC comparisons, see :func:`simba.mixins.image_mixin.ImageMixin.sliding_cross_correlation_similarity`
            For matrix based NCC comparisons, see :func:`simba.mixins.image_mixin.ImageMixin.cross_correlation_matrix`

{simba_uw_tf_dev-5.4.1 → simba_uw_tf_dev-5.4.2}/simba/mixins/timeseries_features_mixin.py

@@ -88,11 +88,18 @@ class TimeseriesFeatureMixin(object):
                 divided by the mobility.
         :rtype:
 
+        .. image:: _static/img/hjort_parameters.webp
+           :width: 600
+           :align: center
+
+        .. note::
+           A constant first derivative (e.g. a perfectly linear ramp) yields ``var(dx) == 0``; in that
+           degenerate case the function returns ``(0, 0, 0)`` to avoid division by zero.
 
         :example:
-        >>> data = np.array([1.0, 2.0, 3.0, 4.0, 5.0], dtype=np.float32)
+        >>> data = np.array([1.0, 3.0, 2.0, 6.0, 4.0, 5.0], dtype=np.float32)
         >>> TimeseriesFeatureMixin().hjort_parameters(data)
-        >>> (2.5, 0.5, 0.4082482904638631)
+        >>> (2.9166667, 1.2503713, 1.6617813)  # (activity, mobility, complexity)
 
         :math:`mobility = \sqrt{\\frac{dx_{var}}{x_{var}}}`
 
@@ -138,17 +145,17 @@ class TimeseriesFeatureMixin(object):
                 ddx = np.diff(np.ascontiguousarray(dx))
                 x_var, dx_var = np.var(sample), np.var(dx)
                 if (x_var <= 0) or (dx_var <= 0):
-                    results[0, r + 1, i] = 0
-                    results[1, r + 1, i] = 0
-                    results[2, r + 1, i] = 0
+                    results[0, r - 1, i] = 0
+                    results[1, r - 1, i] = 0
+                    results[2, r - 1, i] = 0
                 else:
                     ddx_var = np.var(ddx)
                     mobility = np.sqrt(dx_var / x_var)
                     complexity = np.sqrt(ddx_var / dx_var) / mobility
                     activity = np.var(sample)
-                    results[0, r + 1, i] = mobility
-                    results[1, r + 1, i] = complexity
-                    results[2, r + 1, i] = activity
+                    results[0, r - 1, i] = mobility
+                    results[1, r - 1, i] = complexity
+                    results[2, r - 1, i] = activity
 
         return results.astype(np.float32)
 
@@ -749,6 +756,10 @@ class TimeseriesFeatureMixin(object):
            :math:`PE` is the permutation entropy.
            :math:`p_i` is the probability of each unique order pattern.
 
+        .. image:: _static/img/permutation_entropy.webp
+           :width: 600
+           :align: center
+
         :param numpy.ndarray data: The time series data for which permutation entropy is calculated.
         :param int dimension: It specifies the length of the order patterns to be considered.
         :param int delay: Time delay between elements in an order pattern.
@@ -1443,6 +1454,10 @@ class TimeseriesFeatureMixin(object):
             - spike_vals (List[np.ndarray]): A list of 1D arrays, each containing the values of the data points within a detected spike.
             - spike_dict (Dict[int, Dict[str, float]]): A dictionary where the keys are spike indices, and the values are dictionaries containing spike characteristics including 'amplitude' (spike amplitude), 'fwhm' (FWHM), and 'half_width' (half-width).
 
+        .. image:: _static/img/spike_finder.webp
+           :width: 600
+           :align: center
+
         .. note::
            - The function uses the Numba JIT (Just-In-Time) compilation for optimized performance. Without fastmath=True there is no runtime improvement over standard numpy.
 
@@ -1465,7 +1480,7 @@ class TimeseriesFeatureMixin(object):
         for i in prange(len(spike_idx)):
             spike_data = data[spike_idx[i]]
             spike_amplitude = np.max(spike_data) - baseline
-            half_width_idx = np.argwhere(spike_data > spike_amplitude / 2).flatten()
+            half_width_idx = np.argwhere(spike_data > baseline + spike_amplitude / 2).flatten()
             spike_dict[i] = {
                 "amplitude": np.max(spike_data) - baseline,
                 "fwhm": (half_width_idx[-1] - half_width_idx[0]) / sample_rate,
@@ -1986,6 +2001,10 @@ class TimeseriesFeatureMixin(object):
         where :math:`N` is the number of points, :math:`x_i` represents the position at each point,
         and :math:`\frac{d^3 x_i}{dt^3}` is the third derivative of the position with respect to time.
 
+        .. image:: _static/img/mean_squared_jerk.webp
+           :width: 600
+           :align: center
+
         :param np.ndarray x: A 2D array where each row represents the [x, y] position at a time step.
         :param float time_step: The time difference between successive positions in seconds.
         :param float sample_rate: The rate at which the positions are sampled (samples per second).
@@ -2022,7 +2041,7 @@ class TimeseriesFeatureMixin(object):
         :param np.ndarray x: An (N, M) array representing the path of an object, where N is the number of samples (time steps) and M is the number of spatial dimensions (e.g., 2 for 2D motion). Each row represents the position at a time step.
         :param float window_size: The size of each sliding window in seconds. This defines the interval over which the mean squared jerk is calculated.
         :param float sample_rate: The sampling rate in Hz (samples per second), which is used to convert the window size from seconds to frames.
-        :return: A 1D array of length N, containing the mean squared jerk for each sliding window that ends at each time step. The first `frame_step` values will be NaN, as they do not have enough preceding data points to compute jerk over the full window.
+        :return: A 1D array of length N, containing the mean squared jerk for each sliding window that ends at each time step. The first `frame_step` values are set to ``-1.0``, as they do not have enough preceding data points to compute jerk over the full window.
         :rtype: np.ndarray
 
         :example:
@@ -2041,13 +2060,13 @@ class TimeseriesFeatureMixin(object):
         V = np.diff(x, axis=0)
         A = np.diff(V, axis=0)
         frame_step = int(max(1.0, window_size * sample_rate))
-        results = np.full(x.shape[0], fill_value=0, dtype=np.int64)
+        results = np.full(x.shape[0], fill_value=-1.0, dtype=np.float64)
         for r in range(frame_step, x.shape[0]):
             l = r - frame_step
             V_a = A[l:r, :]
             jerks = np.diff(V_a, axis=0)
             if jerks.shape[0] == 0:
-                results[r] = 0
+                results[r] = 0.0
             else:
                 results[r] = np.sum(jerks ** 2) / jerks.shape[0]
 
@@ -2541,12 +2560,16 @@ class TimeseriesFeatureMixin(object):
         :return: The average kinetic energy of the animal.
         :rtype: float
 
+        .. image:: _static/img/avg_kinetic_energy.webp
+           :width: 600
+           :align: center
+
         :example:
         >>> x = np.random.randint(0, 500, (200, 2))
         >>> TimeseriesFeatureMixin.avg_kinetic_energy(x=x, mass=35, sample_rate=30)
         """
 
-        delta_t = np.round(1 / sample_rate, 2)
+        delta_t = 1 / sample_rate
         vx, vy = np.gradient(x[:, 0], delta_t), np.gradient(x[:, 1], delta_t)
         speed = np.sqrt(vx ** 2 + vy ** 2)
         kinetic_energy = 0.5 * mass * speed ** 2
@@ -2580,7 +2603,7 @@ class TimeseriesFeatureMixin(object):
 
         time_window_frms = np.ceil(sample_rate * time_window)
         results = np.full(shape=(x.shape[0]), fill_value=-1.0, dtype=np.float32)
-        delta_t = np.round(1 / sample_rate, 2)
+        delta_t = 1 / sample_rate
         for r in range(time_window_frms, x.shape[0] + 1):
             l = r - time_window_frms
             keypoint_sample, mass_sample = x[l:r], mass[l:r]
@@ -2602,6 +2625,10 @@ class TimeseriesFeatureMixin(object):
         :param float sample_rate: Sampling rate in FPS.
         :returns: Magnitude of the momentum.
         :rtype: float
+
+        .. image:: _static/img/momentum_magnitude.webp
+           :width: 600
+           :align: center
         """
 
         check_valid_array(data=x, source=f'{TimeseriesFeatureMixin.momentum_magnitude.__name__} x', accepted_ndims=(2,), accepted_axis_1_shape=[2, ], accepted_dtypes=Formats.NUMERIC_DTYPES.value)

simba_uw_tf_dev-5.4.2/simba/pose_importers/sleap_slp_importer.py

@@ -0,0 +1,195 @@
+__author__ = "Simon Nilsson; sronilsson@gmail.com"
+
+import json
+import os
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import h5py
+import numpy as np
+import pandas as pd
+
+from simba.data_processors.interpolate import Interpolate
+from simba.data_processors.smoothing import Smoothing
+from simba.mixins.config_reader import ConfigReader
+from simba.mixins.pose_importer_mixin import PoseImporterMixin
+from simba.utils.checks import (check_file_exist_and_readable,
+                                check_if_dir_exists,
+                                check_if_keys_exist_in_dict, check_int,
+                                check_str, check_valid_lst)
+from simba.utils.enums import Methods, TagNames
+from simba.utils.errors import CountError
+from simba.utils.printing import (SimbaTimer, log_event, stdout_information,
+                                  stdout_success)
+from simba.utils.read_write import (clean_sleap_file_name,
+                                    find_all_videos_in_project, get_fn_ext,
+                                    get_video_meta_data, write_df)
+
+FRAME_IDX_COL, INST_START_COL, INST_END_COL = 2, 3, 4
+INSTANCE_TRACK_COL = 4
+POINT_X_COL, POINT_Y_COL, POINT_SCORE_COL = 0, 1, 4
+
+
+def _field(arr: np.ndarray, name: str, pos: int) -> np.ndarray:
+    """Return a column of a (possibly structured) numpy array by field name, falling back to positional index."""
+    names = arr.dtype.names
+    if names is not None and name in names:
+        return np.asarray(arr[name])
+    if names is not None:
+        return np.asarray(arr[names[pos]])
+    return np.asarray(arr[:, pos])
+
+
+class SLEAPImporterSLP(ConfigReader, PoseImporterMixin):
+    """
+    Class for importing SLEAP pose-estimation data (``.slp`` files) into a SimBA project.
+
+    :param str project_path: path to SimBA project config file in Configparser format.
+    :param str data_folder: Path to folder containing SLEAP data in ``.slp`` format.
+    :param List[str] id_lst: Animal names. This will be ignored in one animal projects and default to ``Animal_1``.
+    :param Optional[Dict[str, str]] interpolation_settings: Dict defining the type and method to use to perform interpolation e.g. {'type': 'animals', 'method': 'linear'}.
+    :param Optional[Dict[str, Union[str, int]]] smoothing_settings: Dictionary defining the pose estimation smoothing method e.g. {'time_window': 500, 'method': 'gaussian'}.
+
+    :example:
+    >>> slp_importer = SLEAPImporterSLP(project_path="MyConfigPath", data_folder=r'MySLPDataFolder', id_lst=['Mouse_1', 'Mouse_2'], interpolation_settings={'type': 'animals', 'method': 'linear'}, smoothing_settings={'time_window': 200, 'method': 'savitzky-golay'})
+    >>> slp_importer.run()
+
+    References
+    ----------
+    .. [1] Pereira et al., SLEAP: A deep learning system for multi-animal pose tracking, `Nature Methods`, 2022.
+    """
+
+    def __init__(self,
+                 project_path: Union[str, os.PathLike],
+                 data_folder:  Union[str, os.PathLike],
+                 id_lst: List[str],
+                 interpolation_settings: Optional[Dict[str, str]] = None,
+                 smoothing_settings: Optional[Dict[str, Any]] = None):
+
+        ConfigReader.__init__(self, config_path=project_path, read_video_info=False)
+        PoseImporterMixin.__init__(self)
+        log_event(logger_name=str(__class__.__name__), log_type=TagNames.CLASS_INIT.value, msg=self.create_log_msg_from_init_args(locals=locals()))
+        check_file_exist_and_readable(file_path=project_path)
+        check_if_dir_exists(in_dir=data_folder, source=self.__class__.__name__)
+        check_valid_lst(data=id_lst, source=f'{self.__class__.__name__} id_lst', valid_dtypes=(str,), min_len=1)
+        if interpolation_settings is not None:
+            check_if_keys_exist_in_dict(data=interpolation_settings, key=['method', 'type'], name=f'{self.__class__.__name__} interpolation_settings')
+            check_str(name=f'{self.__class__.__name__} interpolation_settings type', value=interpolation_settings['type'], options=('body-parts', 'animals'))
+            check_str(name=f'{self.__class__.__name__} interpolation_settings method', value=interpolation_settings['method'], options=('linear', 'quadratic', 'nearest'))
+        if smoothing_settings is not None:
+            check_if_keys_exist_in_dict(data=smoothing_settings, key=['method', 'time_window'], name=f'{self.__class__.__name__} smoothing_settings')
+            check_str(name=f'{self.__class__.__name__} smoothing_settings method', value=smoothing_settings['method'], options=('savitzky-golay', 'gaussian'))
+            check_int(name=f'{self.__class__.__name__} smoothing_settings time_window', value=smoothing_settings['time_window'], min_value=1)
+
+        self.interpolation_settings, self.smoothing_settings = interpolation_settings, smoothing_settings
+        self.data_folder, self.id_lst = data_folder, id_lst
+        self.import_log_path = os.path.join(self.logs_path, f"data_import_log_{self.datetime}.csv")
+        self.video_paths = find_all_videos_in_project(videos_dir=self.video_dir, raise_error=True if len(id_lst) > 1 else False)
+        self.input_data_paths = self.find_data_files(dir=self.data_folder, extensions=[".slp"])
+        if self.pose_setting is Methods.USER_DEFINED.value:
+            self.__update_config_animal_cnt()
+        if self.animal_cnt > 1:
+            self.data_and_videos_lk = self.link_video_paths_to_data_paths(data_paths=self.input_data_paths, video_paths=self.video_paths, filename_cleaning_func=clean_sleap_file_name)
+            self.check_multi_animal_status()
+            self.animal_bp_dict = self.create_body_part_dictionary(self.multi_animal_status, self.id_lst, self.animal_cnt, self.x_cols, self.y_cols, self.p_cols, self.clr_lst)
+            if self.pose_setting is Methods.USER_DEFINED.value:
+                self.update_bp_headers_file(update_bp_headers=True)
+        else:
+            self.data_and_videos_lk = dict([(get_fn_ext(file_path)[1], {"DATA": file_path, "VIDEO": None}) for file_path in self.input_data_paths])
+        stdout_information(msg=f"Importing {len(list(self.data_and_videos_lk.keys()))} file(s)...", source=self.__class__.__name__)
+
+    @staticmethod
+    def _read_metadata(file_path: Union[str, os.PathLike]) -> dict:
+        """Pull the JSON ``metadata`` blob (skeleton / node order) out of an .slp file."""
+        result = {}
+
+        def _visitor(name, obj):
+            if name == "metadata":
+                attrs = list(obj.attrs.items())
+                result["meta"] = dict(json.loads(attrs[1][1].decode("utf-8")))
+
+        with h5py.File(file_path, "r") as f:
+            f.visititems(_visitor)
+        return result["meta"]
+
+    def _slp_to_arrays(self, file_path: Union[str, os.PathLike]) -> Tuple[np.ndarray, np.ndarray, List[str]]:
+        """
+        Read an .slp file and return:
+            * ``data`` : (n_instances, n_nodes * 3) float64 array of interleaved [x, y, p].
+            * ``idx``  : (n_instances, 2) array of [track_id, frame_idx].
+            * ``ordered_bps`` : body-part names in skeleton node order.
+        """
+        meta = self._read_metadata(file_path)
+        bp_names = [bp["name"] for bp in meta["nodes"]]
+        ordered_ids = [n["id"] for n in meta["skeletons"][0]["nodes"]]
+        ordered_bps = [bp_names[i] for i in ordered_ids]
+        n_nodes = len(ordered_bps)
+
+        with h5py.File(file_path, "r") as f:
+            frames = f["frames"][:]
+            instances = f["instances"][:]
+            pred_points = f["pred_points"][:]
+
+        n_instances = instances.shape[0]
+        expected_points = n_instances * n_nodes
+        if pred_points.shape[0] != expected_points:
+            raise CountError(msg=f"SLP file {file_path}: expected {expected_points} predicted points "
+                                 f"({n_instances} instances x {n_nodes} nodes) but found {pred_points.shape[0]}.",
+                             source=self.__class__.__name__)
+
+        frame_idx_vals = _field(frames, "frame_idx", FRAME_IDX_COL).astype(np.int64)
+        inst_start = _field(frames, "instance_id_start", INST_START_COL).astype(np.int64)
+        inst_end = _field(frames, "instance_id_end", INST_END_COL).astype(np.int64)
+        instance_frame_idx = np.repeat(frame_idx_vals, inst_end - inst_start)
+
+        track_ids = _field(instances, "track", INSTANCE_TRACK_COL).astype(np.int64)
+
+        px = _field(pred_points, "x", POINT_X_COL).astype(np.float64).reshape(n_instances, n_nodes)
+        py = _field(pred_points, "y", POINT_Y_COL).astype(np.float64).reshape(n_instances, n_nodes)
+        pp = _field(pred_points, "score", POINT_SCORE_COL).astype(np.float64).reshape(n_instances, n_nodes)
+
+        data = np.empty((n_instances, n_nodes * 3), dtype=np.float64)
+        data[:, 0::3] = px
+        data[:, 1::3] = py
+        data[:, 2::3] = pp
+
+        idx = np.column_stack([track_ids, instance_frame_idx])
+        return data, idx, ordered_bps
+
+    def run(self):
+        for file_cnt, (video_name, video_data) in enumerate(self.data_and_videos_lk.items()):
+            output_filename = clean_sleap_file_name(filename=video_name)
+            stdout_information(msg=f"Importing {output_filename}...", source=self.__class__.__name__)
+            video_timer = SimbaTimer(start=True)
+            self.video_name = video_name
+            self.save_path = os.path.join(self.input_csv_dir, f"{output_filename}.{self.file_type}")
+
+            data, idx, _ = self._slp_to_arrays(file_path=video_data["DATA"])
+
+            if self.animal_cnt > 1:
+                self.data_df = pd.DataFrame(self.transpose_multi_animal_table(data=data, idx=idx, animal_cnt=self.animal_cnt))
+            else:
+                self.data_df = pd.DataFrame(data).set_index(idx[:, 1]).sort_index()
+                self.data_df = self.data_df.reindex(range(0, int(self.data_df.index[-1]) + 1), fill_value=0)
+
+            if len(self.bp_headers) != len(self.data_df.columns):
+                raise CountError(msg=f"The SimBA project expects {len(self.bp_headers)} data columns, but the reshaped "
+                                     f"SLEAP data at {video_data['DATA']} produced {len(self.data_df.columns)} columns. "
+                                     f"Make sure you have specified the correct number of animals and body-parts in your project.",
+                                 source=self.__class__.__name__)
+            self.data_df.columns = self.bp_headers
+
+            if self.animal_cnt > 1:
+                self.initialize_multi_animal_ui(animal_bp_dict=self.animal_bp_dict, video_info=get_video_meta_data(video_data["VIDEO"]), data_df=self.data_df, video_path=video_data["VIDEO"])
+                self.multianimal_identification()
+            else:
+                self.out_df = self.insert_multi_idx_columns(df=self.data_df.fillna(0))
+
+            write_df(df=self.out_df, file_type=self.file_type, save_path=self.save_path, multi_idx_header=True)
+            if self.interpolation_settings is not None:
+                Interpolate(config_path=self.config_path, data_path=self.save_path, type=self.interpolation_settings['type'], method=self.interpolation_settings['method'], multi_index_df_headers=True, copy_originals=False).run()
+            if self.smoothing_settings is not None:
+                Smoothing(config_path=self.config_path, data_path=self.save_path, time_window=self.smoothing_settings['time_window'], method=self.smoothing_settings['method'], multi_index_df_headers=True, copy_originals=False).run()
+            video_timer.stop_timer()
+            stdout_success(msg=f"Video {output_filename} data imported...", elapsed_time=video_timer.elapsed_time_str, source=self.__class__.__name__)
+        self.timer.stop_timer()
+        stdout_success(msg=f"All SLEAP SLP data files imported to {self.input_csv_dir} directory", elapsed_time=self.timer.elapsed_time_str, source=self.__class__.__name__)

{simba_uw_tf_dev-5.4.1 → simba_uw_tf_dev-5.4.2}/simba_uw_tf_dev.egg-info/PKG-INFO

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