simba-uw-tf-dev 2.7.2__tar.gz → 2.7.4__tar.gz

{simba_uw_tf_dev-2.7.2 → simba_uw_tf_dev-2.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba_uw_tf_dev
-Version: 2.7.2
+Version: 2.7.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-2.7.2 → simba_uw_tf_dev-2.7.4}/Simba_UW_tf_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba-uw-tf-dev
-Version: 2.7.2
+Version: 2.7.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-2.7.2 → simba_uw_tf_dev-2.7.4}/Simba_UW_tf_dev.egg-info/SOURCES.txt

@@ -328,6 +328,7 @@ simba/data_processors/circling_detector.py
 simba/data_processors/directing_animal_to_bodypart.py
 simba/data_processors/directing_other_animals_calculator.py
 simba/data_processors/egocentric_aligner.py
+simba/data_processors/find_animal_blob_location.py
 simba/data_processors/freezing_detector.py
 simba/data_processors/fsttc_calculator.py
 simba/data_processors/gibbs_sampler.py

{simba_uw_tf_dev-2.7.2 → simba_uw_tf_dev-2.7.4}/setup.py

@@ -29,7 +29,7 @@ with open(GPU_REQUIREMENTS_PATH, "r") as f:
 # Setup configuration
 setuptools.setup(
     name="simba_uw_tf_dev",
-    version="2.7.2",
+    version="2.7.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-2.7.2 → simba_uw_tf_dev-2.7.4}/simba/SimBA.py

@@ -1,7 +1,8 @@
 __author__ = "Simon Nilsson"
 
-import os.path
 import time
+
+import os.path
 import warnings
 
 warnings.filterwarnings("ignore", category=FutureWarning)

{simba_uw_tf_dev-2.7.2 → simba_uw_tf_dev-2.7.4}/simba/data_processors/blob_location_computer.py

@@ -2,31 +2,28 @@ __author__ = "Simon Nilsson"
 __email__ = "sronilsson@gmail.com"
 
 import os
-from copy import deepcopy
-from typing import Optional, Union
-
+import cv2
+from copy import deepcopy, copy
+from typing import Optional, Union, Dict
+from shapely.geometry import Polygon, MultiPolygon
+from shapely.affinity import scale
 import numpy as np
 
 try:
     from typing import Literal
 except:
     from typing_extensions import Literal
-
 import pandas as pd
 
 from simba.mixins.image_mixin import ImageMixin
-from simba.utils.checks import (check_if_dir_exists, check_int,
-                                check_nvidea_gpu_available, check_str,
-                                check_valid_boolean)
+from simba.mixins.geometry_mixin import GeometryMixin
+from simba.utils.checks import (check_if_dir_exists, check_int, check_nvidea_gpu_available, check_str, check_valid_boolean, check_instance, is_img_bw, check_float)
 from simba.utils.data import df_smoother, savgol_smoother
 from simba.utils.enums import Formats, Methods, Options
 from simba.utils.errors import FFMPEGCodecGPUError, InvalidInputError
 from simba.utils.printing import SimbaTimer, stdout_success
-from simba.utils.read_write import (find_all_videos_in_directory, get_fn_ext,
-                                    get_video_meta_data, remove_files,
-                                    write_df)
-from simba.video_processors.video_processing import (video_bg_subtraction,
-                                                     video_bg_subtraction_mp)
+from simba.utils.read_write import (find_all_videos_in_directory, get_fn_ext, get_video_meta_data, remove_files, write_df)
+from simba.video_processors.video_processing import (video_bg_subtraction, video_bg_subtraction_mp)
 
 
 class BlobLocationComputer(object):
@@ -54,10 +51,10 @@ class BlobLocationComputer(object):
                  data_path: Union[str, os.PathLike],
                  verbose: Optional[bool] = True,
                  gpu: Optional[bool] = True,
-                 batch_size: Optional[int] = 2500,
+                 batch_size: int = 2500,
                  save_dir: Optional[Union[str, os.PathLike]] = None,
                  smoothing: Optional[str] = None,
-                 multiprocessing: Optional[bool] = False):
+                 multiprocessing: bool = False):
 
 
         if os.path.isdir(data_path):
@@ -122,5 +119,13 @@ class BlobLocationComputer(object):
             if self.verbose:
                 stdout_success(f'Video blob detection complete for {len(self.data_paths)} video', elapsed_time=timer.elapsed_time_str)
 
+
+
+
+
+
+
+
+
 # x = BlobLocationComputer(data_path=r"C:\troubleshooting\RAT_NOR\project_folder\videos\2022-06-20_NOB_DOT_4_downsampled.mp4", multiprocessing=True, gpu=True, batch_size=2000, save_dir=r"C:\troubleshooting\RAT_NOR\project_folder\csv\blob_positions", smoothing='Savitzky Golay')
 # x.run()

simba_uw_tf_dev-2.7.4/simba/data_processors/find_animal_blob_location.py

@@ -0,0 +1,173 @@
+from shapely.geometry import Polygon, MultiPolygon
+from shapely.affinity import scale
+from typing import Dict, Optional, Union
+from copy import copy
+import numpy as np
+import cv2
+import os
+import pandas as pd
+from simba.utils.read_write import read_img_batch_from_video_gpu, get_video_meta_data, find_core_cnt, get_fn_ext, read_img_batch_from_video
+from simba.utils.checks import (check_float, check_instance, check_valid_boolean, is_img_bw, check_int, check_nvidea_gpu_available)
+from simba.utils.printing import SimbaTimer
+from simba.utils.errors import NotDirectoryError, FFMPEGCodecGPUError
+import functools
+import multiprocessing
+from simba.utils.enums import Defaults
+
+def find_animal_blob_location(imgs: Dict[int, np.ndarray],
+                              verbose: bool = False,
+                              video_name: Optional[str] = None,
+                              inclusion_zone: Optional[Union[Polygon, MultiPolygon,]] = None,
+                              window_size: Optional[int] = None) -> Dict[int, Dict[str, Union[int, np.ndarray]]]:
+    """
+    Helper to find the largest connected component in binary image. E.g., Use to find a "blob" (i.e., animal) within a background subtracted image.
+
+    .. seealso::
+       To create background subtracted videos, use e.g., :func:`simba.video_processors.video_processing.video_bg_subtraction_mp`, or :func:`~simba.video_processors.video_processing.video_bg_subtraction`.
+       To get ``img`` dict, use :func:`~simba.utils.read_write.read_img_batch_from_video_gpu` or :func:`~simba.mixins.image_mixin.ImageMixin.read_img_batch_from_video`.
+       For relevant notebook, see `BACKGROUND REMOVAL <https://simba-uw-tf-dev.readthedocs.io/en/latest/nb/bg_remove.html>`__.
+
+    .. important::
+       Pass black and white [0, 255] pixel values only, where the foreground is 255 and background is 0.
+
+    :param Dict[int, np.ndarray] imgs: Dictionary of images where the key is the frame id and the value is an image in np.ndarray format.
+    :param bool verbose: If True, prints progress. Default: False.
+    :param video_name video_name: The name of the video being processed for interpretable progress msg if ``verbose``.
+    :param Optional[Union[Polygon, MultiPolygon]] inclusion_zone: Optional shapely polygon, or multipolygon, restricting where to search for the largest blob. Default: None.
+    :param Optional[int] window_size: If not None, then integer representing the size multiplier of the animal geometry in previous frame. If not None, the animal geometry will only be searched for within this geometry.
+    :return: Dictionary where the key is the frame id and the value is a 2D array with x and y coordinates.
+    :rtype: Dict[int, np.ndarray]
+
+    :example:
+    >>> imgs = read_img_batch_from_video_gpu(video_path=r"C:\troubleshooting\mitra\test\temp\501_MA142_Gi_Saline_0515.mp4", start_frm=0, end_frm=0, black_and_white=True)
+    >>> data = find_animal_blob_location(imgs=imgs, window_size=3)
+    >>> data = pd.DataFrame.from_dict(data, orient='index')
+    """
+
+    from simba.mixins.geometry_mixin import GeometryMixin
+    check_valid_boolean(value=[verbose], source=f'{find_animal_blob_location.__name__} verbose', raise_error=True)
+    if inclusion_zone is not None:
+        check_instance(source=f'{find_animal_blob_location.__name__} inclusion_zone', instance=inclusion_zone, accepted_types=(MultiPolygon, Polygon,), raise_error=True)
+    if window_size is not None:
+        check_float(name='window_size', value=window_size, min_value=1.0, raise_error=True)
+    results, prior_window = {}, None
+    for frm_idx, img in imgs.items():
+        if verbose:
+            if video_name is None: print(f'Finding blob in image {frm_idx}...')
+            else: print(f'Finding blob in image {frm_idx} (Video {video_name})...')
+        is_img_bw(img=img, raise_error=True, source=f'{find_animal_blob_location.__name__} {frm_idx}')
+        contours = cv2.findContours(img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[1]
+        contours = [cnt.reshape(1, -1, 2) for cnt in contours if len(cnt) >= 3]
+        geometries = GeometryMixin().contours_to_geometries(contours=contours, force_rectangles=False)
+        if inclusion_zone is not None:
+            geo_idx = [inclusion_zone.contains(x.centroid) for x in geometries]
+            selected_polygons = [geometries[i] for i in geo_idx]
+            geometries = copy(selected_polygons)
+        if prior_window is not None:
+            geo_idx = [prior_window.contains(x.centroid) for x in geometries]
+            selected_polygons = [geometries[i] for i in geo_idx]
+            geometries = copy(selected_polygons)
+        geometry_stats = GeometryMixin().get_shape_statistics(shapes=geometries)
+        geometry = geometries[np.argmax(np.array(geometry_stats['areas']))].convex_hull.simplify(tolerance=5)
+        if window_size is not None:
+            window_geometry = GeometryMixin.minimum_rotated_rectangle(shape=geometry)
+            prior_window = scale(window_geometry, xfact=window_size, yfact=window_size, origin=window_geometry.centroid)
+        center = np.array(geometry.centroid.coords)[0].astype(np.int32)
+        vertices = np.array(geometry.exterior.coords).astype(np.int32)
+        results[frm_idx] = {'x': center[0], 'y': center[1], 'vertices': vertices}
+    return results
+
+
+def get_blob_locations(video_path: Union[str, os.PathLike],
+                       batch_size: int = 3000,
+                       gpu: bool = False,
+                       verbose: bool = True,
+                       save_path: Optional[Union[str, os.PathLike]] = None,
+                       inclusion_zone: Optional[Union[Polygon, MultiPolygon]] = None,
+                       window_size: Optional[float] = None) -> Union[None, pd.DataFrame]:
+    """
+    Detects the location of the largest blob in each frame of a video. Processes frames in batches and optionally uses GPU for acceleration. Results can be saved to a specified path or returned as a NumPy array.
+    .. seealso::
+       For visualization of results, see :func:`simba.plotting.blob_plotter.BlobPlotter` and :func:`simba.mixins.plotting_mixin.PlottingMixin._plot_blobs`
+       Background subtraction can be performed using :func:`~simba.video_processors.video_processing.video_bg_subtraction_mp` or :func:`~simba.video_processors.video_processing.video_bg_subtraction`.
+    .. note::
+       In ``inclusion_zones`` is not None, then the largest blob will be searches for **inside** the passed vertices.
+    :param Union[str, os.PathLike] video_path: Path to the video file from which to extract frames. Often, a background subtracted video, which can be created with e.g., :func:`simba.video_processors.video_processing.video_bg_subtraction_mp`.
+    :param Optional[int] batch_size: Number of frames to process in each batch. Default is 3k.
+    :param Optional[bool] gpu: Whether to use GPU acceleration for processing. Default is False.
+    :param Optional[bool] verbose: Whether to print progress and status messages. Default is True.
+    :param Optional[Union[str, os.PathLike]] save_path: Path to save the results as a CSV file. If None, results are not saved.
+    :param Optional[Union[Polygon, MultiPolygon]] inclusion_zones: Optional shapely polygon, or multipolygon, restricting where to search for the largest blob. Default: None.
+    :param Optional[int] window_size: If not None, then integer representing the size multiplier of the animal geometry in previous frame. If not None, the animal geometry will only be searched for within this geometry.
+    :return: A dataframe shape (N, 4) where N is the number of frames, containing the X and Y coordinates of the centroid of the largest blob in each frame and the vertices representing the hull. If `save_path` is provided, returns None.
+    :rtype: Union[None, pd.DataFrame]
+    :example:
+    >>> x = ImageMixin.get_blob_locations(video_path=r"/mnt/c/troubleshooting/RAT_NOR/project_folder/videos/2022-06-20_NOB_DOT_4_downsampled_bg_subtracted.mp4", gpu=True)
+    >>> y = ImageMixin.get_blob_locations(video_path=r"C:\troubleshooting\RAT_NOR\project_folder\videos\2022-06-20_NOB_IOT_1_bg_subtracted.mp4", gpu=True)
+    """
+
+
+    timer = SimbaTimer(start=True)
+    video_meta = get_video_meta_data(video_path=video_path)
+    _, video_name, _ = get_fn_ext(filepath=video_path)
+    check_int(name=f'{get_blob_locations.__name__} batch_size', value=batch_size, min_value=1)
+    if batch_size > video_meta['frame_count']: batch_size = video_meta['frame_count']
+    if save_path is not None:
+        if not os.path.isdir(os.path.dirname(save_path)):
+            raise NotDirectoryError(msg=f'Directory path {os.path.dirname(save_path)} is not a valid directory', source=get_blob_locations.__name__)
+    check_valid_boolean(value=gpu, source=f'{get_blob_locations.__name__} gpu')
+    check_valid_boolean(value=verbose, source=f'{get_blob_locations.__name__} verbose')
+    if gpu and not check_nvidea_gpu_available():
+        raise FFMPEGCodecGPUError(msg='No GPU detected, try to set GPU to False', source=get_blob_locations.__name__)
+    if inclusion_zone is not None:
+        check_instance(source=f'{get_blob_locations} inclusion_zone', instance=inclusion_zone, accepted_types=(MultiPolygon, Polygon,), raise_error=True)
+    if window_size is not None:
+        check_float(name='window_size', value=window_size, min_value=1.0, raise_error=True)
+    frame_ids = list(range(0, video_meta['frame_count']))
+    frame_ids = [frame_ids[i:i + batch_size] for i in range(0, len(frame_ids), batch_size)]
+    core_cnt = find_core_cnt()[0]
+    results = {}
+    if verbose:
+        print('Starting blob location detection...')
+    for frame_batch in range(len(frame_ids)):
+        start_frm, end_frm = frame_ids[frame_batch][0], frame_ids[frame_batch][-1]
+        if gpu:
+            imgs = read_img_batch_from_video_gpu(video_path=video_path, start_frm=start_frm, end_frm=end_frm,  verbose=False, out_format='array', black_and_white=True)
+        else:
+            imgs = read_img_batch_from_video(video_path=video_path, start_frm=start_frm, end_frm=end_frm, verbose=False, black_and_white=True)
+        keys = np.arange(start_frm, end_frm+1)
+        img_dict = {}
+        for cnt, img_id in enumerate(range(start_frm, end_frm+1)):
+            img_dict[img_id] = imgs[cnt]
+        batch_results = {}
+        img_dict = [{k: img_dict[k] for k in subset} for subset in np.array_split(keys, core_cnt)]
+        del imgs
+        with multiprocessing.Pool(core_cnt, maxtasksperchild=Defaults.LARGE_MAX_TASK_PER_CHILD.value) as pool:
+            constants = functools.partial(find_animal_blob_location,
+                                          verbose=verbose,
+                                          video_name=video_name,
+                                          inclusion_zone=inclusion_zone)
+            for cnt, result in enumerate(pool.imap(constants, img_dict, chunksize=1)):
+                batch_results.update(result)
+        results.update(batch_results)
+        pool.join()
+        pool.terminate()
+    results = dict(sorted(results.items()))
+    results = pd.DataFrame.from_dict(data=results, orient='index', columns=['x', 'y', 'vertices'])
+    if save_path is not None:
+        results.to_csv(save_path)
+    else:
+        return results
+
+
+
+
+if __name__ == "__main__":
+    get_blob_locations(video_path=r"C:\troubleshooting\mitra\test\temp\501_MA142_Gi_Saline_0515.mp4", gpu=False, save_path=r'C:\troubleshooting\mitra\test\blob_data\501_MA142_Gi_Saline_0515.csv')
+
+
+
+#
+# imgs = read_img_batch_from_video_gpu(video_path=r"C:\troubleshooting\mitra\test\temp\501_MA142_Gi_Saline_0515.mp4", start_frm=0, end_frm=0, black_and_white=True)
+# data = find_animal_blob_location(imgs=imgs, window_size=3)
+# data = pd.DataFrame.from_dict(data, orient='index')

{simba_uw_tf_dev-2.7.2 → simba_uw_tf_dev-2.7.4}/simba/mixins/geometry_mixin.py

@@ -3833,9 +3833,6 @@ class GeometryMixin(object):
             lengths.append(length)
             widths.append(width)
             areas.append(area)
-
-
-
             centers.append(list(np.array(shape.centroid.coords)[0].astype(np.int32)))
 
         return {'lengths': lengths, 'widths': widths, 'areas': areas, 'centers': centers, 'max_length': max_length, 'min_length': min_length, 'min_width': min_width, 'max_width': max_width, 'min_area': min_area, 'max_area': max_area}

{simba_uw_tf_dev-2.7.2 → simba_uw_tf_dev-2.7.4}/simba/mixins/image_mixin.py

@@ -1,8 +1,6 @@
 import platform
 from typing import Dict, List, Optional, Tuple, Union
-
 import numpy as np
-
 try:
     from typing import Literal
 except:
@@ -16,7 +14,7 @@ from collections import ChainMap
 import cv2
 import pandas as pd
 from numba import float64, int64, jit, njit, prange, uint8
-from shapely.geometry import Polygon
+from shapely.geometry import Polygon, MultiPolygon
 from skimage.metrics import structural_similarity
 
 from simba.utils.checks import (check_file_exist_and_readable, check_float,
@@ -31,12 +29,8 @@ from simba.utils.errors import (ArrayError, FFMPEGCodecGPUError,
                                 FrameRangeError, InvalidInputError,
                                 NotDirectoryError)
 from simba.utils.printing import SimbaTimer, stdout_success
-from simba.utils.read_write import (find_core_cnt,
-                                    find_files_of_filetypes_in_directory,
-                                    find_largest_blob_location, get_fn_ext,
-                                    get_video_meta_data, read_frm_of_video,
-                                    read_img_batch_from_video_gpu, write_df)
-
+from simba.utils.read_write import (find_core_cnt, find_files_of_filetypes_in_directory, get_fn_ext, get_video_meta_data, read_frm_of_video, read_img_batch_from_video_gpu, write_df)
+from simba.data_processors.find_animal_blob_location import find_animal_blob_location
 
 class ImageMixin(object):
     """
@@ -948,7 +942,7 @@ class ImageMixin(object):
         return results.astype(int64)
 
     @staticmethod
-    def _read_img_batch_from_video_helper(frm_idx: np.ndarray, video_path: Union[str, os.PathLike], greyscale: bool, verbose: bool):
+    def _read_img_batch_from_video_helper(frm_idx: np.ndarray, video_path: Union[str, os.PathLike], greyscale: bool, verbose: bool, black_and_white: bool):
 
         """Multiprocess helper used by read_img_batch_from_video to read in images from video file."""
         start_idx, end_frm, current_frm = frm_idx[0], frm_idx[-1] + 1, frm_idx[0]
@@ -959,8 +953,10 @@ class ImageMixin(object):
             if verbose:
                 print(f'Reading frame idx {current_frm}...')
             img = cap.read()[1]
-            if greyscale:
+            if greyscale or black_and_white:
                 img = ImageMixin.img_to_greyscale(img=img)
+            if black_and_white:
+                img = np.where(img > 127, 255, 0).astype(np.uint8)
             results[current_frm] = img
             current_frm += 1
         return results
@@ -969,20 +965,26 @@ class ImageMixin(object):
     def read_img_batch_from_video(video_path: Union[str, os.PathLike],
                                   start_frm: int,
                                   end_frm: int,
-                                  greyscale: Optional[bool] = False,
-                                  core_cnt: Optional[int] = -1,
-                                  verbose: Optional[bool] = False) -> Dict[int, np.ndarray]:
+                                  greyscale: bool = False,
+                                  black_and_white: bool = False,
+                                  core_cnt: int = -1,
+                                  verbose: bool = False) -> Dict[int, np.ndarray]:
         """
         Read a batch of frames from a video file. This method reads frames from a specified range of frames within a video file using multiprocessing.
 
         .. seealso::
            For GPU acceleration, see :func:`simba.utils.read_write.read_img_batch_from_video_gpu`
 
+        .. note::
+          When black-and-white videos are saved as MP4, there can be some small errors in pixel values during compression. A video with only (0, 255) pixel values therefore gets other pixel values, around 0 and 255, when read in again.
+          If you expect that the video you are reading in is black and white, set ``black_and_white`` to True to round any of these wonly value sto 0 and 255.
+
         :param Union[str, os.PathLike] video_path: Path to the video file.
         :param int start_frm: Starting frame index.
         :param int end_frm: Ending frame index.
         :param Optionalint] core_cnt: Number of CPU cores to use for parallel processing. Default is -1, indicating using all available cores.
         :param Optional[bool] greyscale: If True, reads the images as greyscale. If False, then as original color scale. Default: False.
+        :param bool black_and_white: If True, returns the images in black and white. Default False.
         :returns: A dictionary containing frame indices as keys and corresponding frame arrays as values.
         :rtype: Dict[int, np.ndarray]
 
@@ -998,7 +1000,7 @@ class ImageMixin(object):
         check_int(name=ImageMixin().__class__.__name__,value=start_frm, min_value=0,max_value=video_meta_data["frame_count"])
         check_int(name=ImageMixin().__class__.__name__, value=end_frm, min_value=start_frm+1, max_value=video_meta_data["frame_count"])
         check_int(name=ImageMixin().__class__.__name__, value=core_cnt, min_value=-1)
-        check_valid_boolean(value=[greyscale], source=f'{ImageMixin().__class__.__name__} greyscale')
+        check_valid_boolean(value=[greyscale, black_and_white], source=f'{ImageMixin().__class__.__name__} greyscale black_and_white')
         if core_cnt < 0:
             core_cnt = multiprocessing.cpu_count()
         if end_frm <= start_frm:
@@ -1006,7 +1008,7 @@ class ImageMixin(object):
         frm_lst = np.array_split(np.arange(start_frm, end_frm + 1), core_cnt)
         results = {}
         with multiprocessing.Pool(core_cnt, maxtasksperchild=Defaults.LARGE_MAX_TASK_PER_CHILD.value) as pool:
-            constants = functools.partial(ImageMixin()._read_img_batch_from_video_helper, video_path=video_path, greyscale=greyscale, verbose=verbose)
+            constants = functools.partial(ImageMixin()._read_img_batch_from_video_helper, video_path=video_path, greyscale=greyscale, black_and_white=black_and_white, verbose=verbose)
             for cnt, result in enumerate(pool.imap(constants, frm_lst, chunksize=1)):
                 results.update(result)
 
@@ -1717,25 +1719,30 @@ class ImageMixin(object):
 
     @staticmethod
     def get_blob_locations(video_path: Union[str, os.PathLike],
-                           batch_size: Optional[int] = 3000,
-                           gpu: Optional[bool] = False,
-                           verbose: Optional[bool] = True,
-                           save_path: Optional[Union[str, os.PathLike]] = None) -> Union[None, np.ndarray]:
+                           batch_size: int = 3000,
+                           gpu: bool = False,
+                           verbose: bool = True,
+                           save_path: Optional[Union[str, os.PathLike]] = None,
+                           inclusion_zone: Optional[Union[Polygon, MultiPolygon]] = None,
+                           window_size: Optional[float] = None) -> Union[None, np.ndarray]:
         """
-        Detects the location of the largest blob in each frame of a video. Processes frames in batches and
-        optionally uses GPU for acceleration. Results can be saved to a specified path or returned as a NumPy array.
+        Detects the location of the largest blob in each frame of a video. Processes frames in batches and optionally uses GPU for acceleration. Results can be saved to a specified path or returned as a NumPy array.
 
         .. seealso::
            For visualization of results, see :func:`simba.plotting.blob_plotter.BlobPlotter` and :func:`simba.mixins.plotting_mixin.PlottingMixin._plot_blobs`
+           Background subtraction can be performed using :func:`~simba.video_processors.video_processing.video_bg_subtraction_mp` or :func:`~simba.video_processors.video_processing.video_bg_subtraction`.
+
+        .. note::
+           In ``inclusion_zones`` is not None, then the largest blob will be searches for **inside** the passed vertices.
 
-        :param Union[str, os.PathLike] video_path: Path to the video file from which to extract frames.
-        :param Optional[int] batch_size: Number of frames to process in each batch. Default is 2000.
+        :param Union[str, os.PathLike] video_path: Path to the video file from which to extract frames. Often, a background subtracted video, which can be created with e.g., :func:`simba.video_processors.video_processing.video_bg_subtraction_mp`.
+        :param Optional[int] batch_size: Number of frames to process in each batch. Default is 3k.
         :param Optional[bool] gpu: Whether to use GPU acceleration for processing. Default is False.
         :param Optional[bool] verbose: Whether to print progress and status messages. Default is True.
         :param Optional[Union[str, os.PathLike]] save_path: Path to save the results as a CSV file. If None, results are not saved.
-
-        :return: A NumPy array of shape (N, 2) where N is the number of frames, containing the X and Y coordinates
-                 of the centroid of the largest blob in each frame. If `save_path` is provided, returns None.
+        :param Optional[Union[Polygon, MultiPolygon]] inclusion_zones: Optional shapely polygon, or multipolygon, restricting where to search for the largest blob. Default: None.
+        :param Optional[int] window_size: If not None, then integer representing the size multiplier of the animal geometry in previous frame. If not None, the animal geometry will only be searched for within this geometry.
+        :return: A NumPy array of shape (N, 2) where N is the number of frames, containing the X and Y coordinates of the centroid of the largest blob in each frame. If `save_path` is provided, returns None.
         :rtype: Union[None, np.ndarray]
 
         :example:
@@ -1754,6 +1761,10 @@ class ImageMixin(object):
         check_valid_boolean(value=gpu, source=f'{ImageMixin.get_blob_locations.__name__} verbose')
         if gpu and not check_nvidea_gpu_available():
             raise FFMPEGCodecGPUError(msg='No GPU detected, try to set GPU to False', source=ImageMixin.get_blob_locations.__name__)
+        if inclusion_zone is not None:
+            check_instance(source=f'{ImageMixin.get_blob_locations} inclusion_zone', instance=inclusion_zone, accepted_types=(MultiPolygon, Polygon,), raise_error=True)
+        if window_size is not None:
+            check_float(name='window_size', value=window_size, min_value=1.0, raise_error=True)
         frame_ids = list(range(0, video_meta['frame_count']))
         frame_ids = [frame_ids[i:i + batch_size] for i in range(0, len(frame_ids), batch_size)]
         core_cnt = find_core_cnt()[0]
@@ -1763,10 +1774,10 @@ class ImageMixin(object):
         for frame_batch in range(len(frame_ids)):
             start_frm, end_frm = frame_ids[frame_batch][0], frame_ids[frame_batch][-1]
             if gpu:
-                imgs = read_img_batch_from_video_gpu(video_path=video_path, start_frm=start_frm, end_frm=end_frm,  verbose=False, out_format='array', greyscale=False)
+                imgs = read_img_batch_from_video_gpu(video_path=video_path, start_frm=start_frm, end_frm=end_frm,  verbose=False, out_format='array', black_and_white=True)
             else:
-                imgs = ImageMixin.read_img_batch_from_video(video_path=video_path, start_frm=start_frm, end_frm=end_frm, verbose=verbose)
-            imgs = ImageMixin.img_stack_to_greyscale(imgs=imgs).astype(np.uint8)
+                imgs = ImageMixin.read_img_batch_from_video(video_path=video_path, start_frm=start_frm, end_frm=end_frm, verbose=verbose, black_and_white=True)
+                imgs = np.stack(list(imgs.values()))
             keys = np.arange(start_frm, end_frm+1)
             img_dict = {}
             for cnt, img_id in enumerate(range(start_frm, end_frm+1)):
@@ -1775,23 +1786,28 @@ class ImageMixin(object):
             img_dict = [{k: img_dict[k] for k in subset} for subset in np.array_split(keys, core_cnt)]
             del imgs
             with multiprocessing.Pool(core_cnt, maxtasksperchild=Defaults.LARGE_MAX_TASK_PER_CHILD.value) as pool:
-                constants = functools.partial(find_largest_blob_location, verbose=verbose, video_name=video_name)
+                constants = functools.partial(find_animal_blob_location,
+                                              verbose=verbose,
+                                              video_name=video_name,
+                                              inclusion_zone=inclusion_zone)
                 for cnt, result in enumerate(pool.imap(constants, img_dict, chunksize=1)):
                     batch_results.update(result)
             results.update(batch_results)
             pool.join()
             pool.terminate()
-        results = list(results.values())
-        results = np.stack(results, axis=0)
-        timer.stop_timer()
-        if save_path:
-            df = pd.DataFrame(results, columns=['X', 'Y'])
-            write_df(df=df, file_type=Formats.CSV.value, save_path=save_path)
-            if verbose:
-                stdout_success(f'Video {video_meta["video_name"]} blob detection complete, saved at {save_path}', elapsed_time=timer.elapsed_time_str)
-        else:
-            stdout_success(f'Video {video_meta["video_name"]} blob detection complete', elapsed_time=timer.elapsed_time_str)
-            return results.astype(np.int32)
+        results = dict(sorted(results.items()))
+        print(results)
+        # results = list(results.values())
+        # results = np.stack(results, axis=0)
+        # timer.stop_timer()
+        # if save_path:
+        #     df = pd.DataFrame(results, columns=['X', 'Y'])
+        #     write_df(df=df, file_type=Formats.CSV.value, save_path=save_path)
+        #     if verbose:
+        #         stdout_success(f'Video {video_meta["video_name"]} blob detection complete, saved at {save_path}', elapsed_time=timer.elapsed_time_str)
+        # else:
+        #     stdout_success(f'Video {video_meta["video_name"]} blob detection complete', elapsed_time=timer.elapsed_time_str)
+        #     return results.astype(np.int32)
 
     @staticmethod
     def is_video_color(video: Union[str, os.PathLike, cv2.VideoCapture]):
@@ -1859,6 +1875,11 @@ class ImageMixin(object):
         return results
 
 
+
+
+
+
+
 #x = ImageMixin.get_blob_locations(video_path=r"C:\troubleshooting\RAT_NOR\project_folder\videos\2022-06-20_NOB_DOT_4_downsampled_bg_subtracted.mp4", gpu=True)
 # imgs = ImageMixin().read_all_img_in_dir(dir='/Users/simon/Desktop/envs/simba/troubleshooting/RAT_NOR/project_folder/videos/examples')
 # imgs = np.stack(imgs.values())
@@ -1959,3 +1980,7 @@ class ImageMixin(object):
 #
 # ImageMixin.img_matrix_mse(imgs=imgs_stack)
 
+
+#if
+
+#ImageMixin.get_blob_locations(video_path=r"C:\troubleshooting\mitra\test\temp\501_MA142_Gi_Saline_0515.mp4")

{simba_uw_tf_dev-2.7.2 → simba_uw_tf_dev-2.7.4}/simba/mixins/network_mixin.py

@@ -199,10 +199,6 @@ class NetworkMixin(object):
     def graph_current_flow_closeness_centrality(graph: nx.Graph, weights: Optional[str] = "weight"):
 
         """
-
-
-
-
         :example:
         >>> graph = NetworkMixin.create_graph(data={('Animal_1', 'Animal_2'): 1.0, ('Animal_1', 'Animal_3'): 0.2, ('Animal_2', 'Animal_3'): 0.5})
         >>> NetworkMixin().graph_current_flow_closeness_centrality(graph=graph)

{simba_uw_tf_dev-2.7.2 → simba_uw_tf_dev-2.7.4}/simba/pose_importers/sleap_csv_importer.py

@@ -97,13 +97,16 @@ class SLEAPImporterCSV(ConfigReader, PoseImporterMixin):
             if INSTANCE_SCORE in data_df.columns:
                 data_df = data_df.drop([INSTANCE_SCORE], axis=1)
             idx = data_df.iloc[:, :2]
-            data_unique_tracks = list(idx[TRACK].unique())
             check_that_column_exist(df=idx, column_name=TRACK, file_name=video_name)
-            idx[TRACK] = idx[TRACK].fillna(data_unique_tracks[0])
-            idx[TRACK] = idx[TRACK].str.replace(r"[^\d.]+", "").astype(int)
-            #idx[TRACK] = idx[TRACK].str.replace(r"[^\d.]+", "", regex=True).astype(int)
+            data_unique_tracks = list(idx[TRACK].unique())
             if len(data_unique_tracks) != self.animal_cnt:
                 raise AnimalNumberError(msg=f'The SLEAP CSV file {video_data["DATA"]} contains data for {len(data_unique_tracks)} tracks (found tracks: {data_unique_tracks}). The SimBA project config says the SimBA project expects data for {self.animal_cnt} animals.')
+            if len(data_unique_tracks) == 1:
+                idx[TRACK] = 'track_0'; data_unique_tracks = ['track_0']
+
+            idx[TRACK] = idx[TRACK].fillna(data_unique_tracks[0])
+            idx[TRACK] = idx[TRACK].str.replace(r"[^\d.]+", "", regex=True).astype(int)
+
             data_df = data_df.iloc[:, 2:].fillna(0)
             if self.animal_cnt > 1:
                 self.data_df = pd.DataFrame(self.transpose_multi_animal_table(data=data_df.values, idx=idx.values, animal_cnt=self.animal_cnt))
@@ -137,6 +140,14 @@ class SLEAPImporterCSV(ConfigReader, PoseImporterMixin):
         stdout_success(msg=f"{len(list(self.data_and_videos_lk.keys()))} file(s) imported to the SimBA project {self.input_csv_dir}", source=self.__class__.__name__)
 
 
+# test = SLEAPImporterCSV(config_path=r"D:\troubleshooting\mitra\project_folder\project_config.ini",
+#                  data_folder=r'D:\troubleshooting\mitra\raw_tracking_data',
+#                  id_lst=['Track_0'],
+#                  interpolation_settings={'type': 'body-parts', 'method': 'linear'},
+#                  smoothing_settings = {'time_window': 500, 'method': 'gaussian'})
+# test.run()
+
+
 
 
 #
@@ -146,7 +157,7 @@ class SLEAPImporterCSV(ConfigReader, PoseImporterMixin):
 #                  interpolation_settings={'type': 'animals', 'method': 'linear'},
 #                  smoothing_settings = {'time_window': 500, 'method': 'gaussian'})
 # test.run()
-
+#