cellects 0.1.0.dev1__py3-none-any.whl

cellects/utils/utilitarian.py

@@ -0,0 +1,516 @@
+
+import numpy as np
+from timeit import default_timer
+import time
+from numba.typed import Dict
+from numba import njit
+from glob import glob
+vectorized_len = np.vectorize(len)
+
+
+@njit()
+def equal_along_first_axis(array_in_1, array_in_2):
+    """
+    Compare two arrays element-wise along the first axis and return a boolean array where elements are equal.
+
+    This function checks if corresponding elements in two arrays along the first axis
+    are equal, returning a boolean array of the same shape as `array_in_1`.
+
+    Parameters
+    ----------
+    array_in_1 : ndarray
+        First array to compare.
+    array_in_2 : ndarray
+        Second array to compare.
+
+    Returns
+    -------
+    ndarray
+        Boolean array indicating equality of elements along the first axis.
+        Has the same shape as `array_in_1` and dtype of `np.bool_`.
+
+    Raises
+    ------
+    ValueError
+        If the shape of `array_in_1` and `array_in_2` do not match along all axes
+        except the first.
+
+    Examples
+    --------
+    >>> array_in_1 = np.array([[1, 2], [3, 4]])
+    >>> array_in_2 = np.array([[1, 2], [0, 4]])
+    >>> equal_along_first_axis(array_in_1, array_in_2)
+    array([[ True,  True],
+           [False,  True]])
+    >>> equal_along_first_axis(array_in_1, array_in_2).dtype
+    dtype('bool')
+    """
+    array_out = np.zeros_like(array_in_1)
+    for i, value in enumerate(array_in_2):
+        array_out[i, ...] = array_in_1[i, ...] == value
+    return array_out
+
+
+@njit()
+def greater_along_first_axis(array_in_1, array_in_2):
+    """
+    Compare two arrays element-wise along the first axis and return a boolean array,
+    where each element indicates whether the corresponding element in `array_in_1`
+    is greater than in `array_in_2`.
+
+    Parameters
+    ----------
+    array_in_1 : array_like
+        The first input array.
+    array_in_2 : array_like
+        The second input array.
+
+    Returns
+    -------
+    out : ndarray, bool
+        A boolean array indicating where `array_in_1` elements are greater than
+        corresponding `array_in_2` elements.
+
+    Examples
+    --------
+    >>> array1 = np.array([[1, 2], [3, 4]])
+    >>> array2 = np.array([[0, 1], [2, 3]])
+    >>> result = greater_along_first_axis(array1, array2)
+    >>> print(result)  # doctest: +NORMALIZE_WHITESPACE
+    [[ True False]
+     [ True False]]
+    """
+    array_out = np.zeros_like(array_in_1)
+    for i, value in enumerate(array_in_2):
+        array_out[i, ...] = array_in_1[i, ...] > value
+    return array_out
+
+
+@njit()
+def less_along_first_axis(array_in_1, array_in_2):
+    """
+    Compare two arrays element-wise along the first axis, returning a boolean array.
+
+    This function performs an element-wise comparison between two arrays along
+    the first axis and returns a boolean array. The comparison is less than, i.e.,
+    element-wise `array_in_1 < array_in_2`.
+
+    Parameters
+    ----------
+    array_in_1 : numpy.ndarray
+        The first input array.
+    array_in_2 : numpy.ndarray
+        The second input array.
+
+    Returns
+    -------
+    numpy.ndarray[bool]
+        A boolean array where each element is the result of the comparison
+        `array_in_1[i, ...] < array_in_2[i, ...]` for all indices `i` along the first axis.
+
+    Notes
+    -----
+    This function uses Numba's `@njit` decorator for performance.
+
+    Examples
+    --------
+    >>> result = less_along_first_axis(np.array([[1, 2], [3, 4]]), np.array([2, 2]))
+    >>> print(result)
+    [[ True  True]
+     [False False]]
+
+    >>> result = less_along_first_axis(np.array([[5, -1], [-3, 0]]), np.array([4.9, 2]))
+    >>> print(result)
+    [[False False]
+     [ True True]]
+    """
+    array_out = np.zeros_like(array_in_1)
+    for i, value in enumerate(array_in_2):
+        array_out[i, ...] = array_in_1[i, ...] < value
+    return array_out
+
+
+def translate_dict(old_dict):
+    """
+    Translate a dictionary to a typed dictionary and filter out non-string values.
+
+    Parameters
+    ----------
+    old_dict : dict
+        The input dictionary that may contain non-string values
+
+    Returns
+    -------
+    dict
+        A typed dictionary containing only the items from `old_dict` where the value is not a string
+
+    Examples
+    --------
+    >>> result = translate_dict({'a': 1., 'b': 'string', 'c': 2.0})
+    >>> print(result)
+    DictType[unicode_type,float64]<iv=None>({a: 1.0, c: 2.0})
+    """
+    numba_dict = Dict()
+    for k, v in old_dict.items():
+        if not isinstance(v, str):
+            numba_dict[k] = v
+    return numba_dict
+
+def reduce_path_len(pathway, to_start, from_end):
+    """
+    Reduce the length of a given pathway string by truncating it from both ends.
+
+    The function is used to shorten the `pathway` string if its length exceeds
+    a calculated maximum size. If it does, the function truncates it from both ends,
+    inserting an ellipsis ("...") in between.
+
+    Parameters
+    ----------
+    pathway : str or int
+        The pathway string to be reduced. If an integer is provided,
+        it will be converted into a string.
+    to_start : int
+        Number of characters from the start to keep in the pathway string.
+    from_end : int
+        Number of characters from the end to keep in the pathway string.
+
+    Returns
+    -------
+    str
+        The reduced version of the `pathway` string. If truncation is not necessary,
+        returns the original pathway string.
+
+    Examples
+    --------
+    >>> reduce_path_len("example/complicated/path/to/resource", 8, 12)
+    'example/.../to/resource'
+    """
+    if not isinstance(pathway, str):
+        pathway = str(pathway)
+    max_size = to_start + from_end + 3
+    if len(pathway) > max_size:
+        pathway = pathway[:to_start] + "..." + pathway[-from_end:]
+    return pathway
+
+
+def find_nearest(array, value):
+    """
+    Find the element in an array that is closest to a given value.
+
+    Parameters
+    ----------
+    array : array_like
+        Input array. Can be any array-like data structure.
+    value :
+        The value to find the closest element to.
+
+    Returns
+    -------
+    :obj:`array` type
+        The element in `array` that is closest to `value`.
+
+    Examples
+    --------
+    >>> find_nearest([1, 2, 3, 4], 2.5)
+    2
+    """
+    array = np.asarray(array)
+    idx = (np.abs(array - value)).argmin()
+    return array[idx]
+
+
+class PercentAndTimeTracker:
+    """
+    Initialize a progress bar object to track and display the progress of an iteration.
+
+    Parameters
+    ----------
+    total : int
+        The total number of iterations.
+    compute_with_elements_number : bool, optional
+        If True, create an element vector. Default is False.
+    core_number : int, optional
+        The number of cores to use. Default is 1.
+
+    Attributes
+    ----------
+    starting_time : float
+        The time when the ProgressBar object is initialized.
+    total : int
+        The total number of iterations.
+    current_step : int
+        The current iteration step (initialized to 0).
+    element_vector : numpy.ndarray, optional
+        A vector of zeros with the same length as `total`, created if
+        `compute_with_elements_number` is True.
+    core_number : int
+        The number of cores.
+
+    Examples
+    --------
+    >>> p = PercentAndTimeTracker(10)
+    >>> print(p.total)  # prints: 10
+    >>> p = PercentAndTimeTracker(10, compute_with_elements_number=True)
+    >>> print(p.element_vector)  # prints: [0 0 0 0 0 0 0 0 0 0]
+
+    Notes
+    -----
+    Starting time is recorded for potential performance tracking.
+
+    """
+    def __init__(self, total, compute_with_elements_number=False, core_number=1):
+        """
+        Initialize a progress bar object to track and display the progress of an iteration.
+
+        Parameters
+        ----------
+        total : int
+            The total number of iterations.
+        compute_with_elements_number : bool, optional
+            If True, create an element vector. Default is False.
+        core_number : int, optional
+            The number of cores to use. Default is 1.
+
+        Attributes
+        ----------
+        starting_time : float
+            The time when the ProgressBar object is initialized.
+        total : int
+            The total number of iterations.
+        current_step : int
+            The current iteration step (initialized to 0).
+        element_vector : numpy.ndarray, optional
+            A vector of zeros with the same length as `total`, created if
+            `compute_with_elements_number` is True.
+        core_number : int
+            The number of cores.
+
+        Examples
+        --------
+        >>> p = PercentAndTimeTracker(10)
+        >>> print(p.total)  # prints: 10
+
+        Notes
+        -----
+        Starting time is recorded for potential performance tracking.
+
+        """
+        self.starting_time = default_timer()
+        self.total = total
+        self.current_step = 0
+        if compute_with_elements_number:
+            self.element_vector = np.zeros(total, dtype=np.int64)
+        self.core_number = core_number
+
+    def get_progress(self, step=None, element_number=None):
+        """
+        Calculate and update the current progress, including elapsed time and estimated remaining time.
+
+        This function updates the internal state of the object to reflect progress
+        based on the current step and element number. It calculates elapsed time,
+        estimates total time, and computes the estimated time of arrival (ETA).
+
+        Parameters
+        ----------
+        step : int or None, optional
+            The current step of the process. If ``None``, the internal counter is incremented.
+        element_number : int or None, optional
+            The current element number. If ``None``, no update is made to the element vector.
+
+        Returns
+        -------
+        tuple
+            A tuple containing:
+            - `int`: The current progress percentage.
+            - `str`: A string with the ETA and remaining time.
+
+        Raises
+        ------
+        ValueError
+            If ``step`` or ``element_number`` are invalid.
+
+        Notes
+        -----
+        The function uses linear regression to estimate future progress values when the current step is sufficiently large.
+
+        Examples
+        --------
+        >>> PercentAndTimeTracker(10, compute_with_elements_number=True).get_progress(9, 5)
+        (0, ', wait to get a more accurate ETA...')
+        """
+        if step is not None:
+            self.current_step = step
+        if element_number is not None:
+            self.element_vector[self.current_step] = element_number
+
+        if self.current_step > 0:
+            elapsed_time = default_timer() - self.starting_time
+            if element_number is None or element_number == 0 or self.current_step < 15:
+                if self.current_step < self.core_number:
+                    current_prop = self.core_number / self.total
+                else:
+                    current_prop = (self.current_step + 1) / self.total
+            else:
+                x_mat = np.array([np.ones(self.current_step - 4), np.arange(5, self.current_step + 1)]).T
+                coefs = np.linalg.lstsq(x_mat, self.element_vector[5:self.current_step + 1], rcond=-1)[0]
+                self.element_vector = coefs[0] + (np.arange(self.total) * coefs[1])
+                self.element_vector[self.element_vector < 0] = 0
+                current_prop = self.element_vector[:self.current_step + 1].sum() / self.element_vector.sum()
+
+            total_time = elapsed_time / current_prop
+            current_prop = int(np.round(current_prop * 100))
+            remaining_time_s = total_time - elapsed_time
+
+            local_time = time.localtime()
+            local_m = int(time.strftime("%M", local_time))
+            local_h = int(time.strftime("%H", local_time))
+            remaining_time_h = remaining_time_s // 3600
+            reste_s = remaining_time_s % 3600
+            reste_m = reste_s // 60
+            # + str(int(np.floor(reste_s % 60))) + "S"
+            hours = int(np.floor(remaining_time_h))
+            minutes = int(np.floor(reste_m))
+
+            if (local_m + minutes) < 60:
+                eta_m = local_m + minutes
+            else:
+                eta_m = (local_m + minutes) % 60
+                local_h += 1
+
+            if (local_h + hours) < 24:
+                output = current_prop, f", ETA {local_h + hours}:{eta_m} ({hours}:{minutes} left)"
+            else:
+                days = (local_h + hours) // 24
+                eta_h = (local_h + hours) % 24
+                eta_d = time.strftime("%m", local_time) + "/" + str(int(time.strftime("%d", local_time)) + days)
+                output = current_prop, f", ETA {eta_d} {eta_h}:{eta_m} ({hours}:{minutes} left)"
+            # return current_prop, str(local_h + hours) + ":" + str(local_m + minutes) + "(" + str()
+        else:
+            output = int(np.round(100 / self.total)), ", wait..."
+        if step is None:
+            self.current_step += 1
+        if element_number is not None:
+            if self.current_step < 50:
+                output = int(0), ", wait to get a more accurate ETA..."
+        return output
+
+
+def insensitive_glob(pattern):
+    """
+    Generates a glob pattern that matches both lowercase and uppercase letters.
+
+    Parameters
+    ----------
+    pattern : str
+        The glob pattern to be made case-insensitive.
+
+    Returns
+    -------
+    str
+        A new glob pattern that will match both lowercase and uppercase letters.
+
+    Examples
+    --------
+    >>> insensitive_glob('*.TXT')
+    """
+    def either(c):
+        return '[%s%s]' % (c.lower(), c.upper()) if c.isalpha() else c
+    return glob(''.join(map(either, pattern)))
+
+
+def smallest_memory_array(array_object, array_type='uint'):
+    """
+    Convert the given array object to the smallest possible memory type.
+
+    This function determines the optimal data type for an array
+    based on its maximum value and converts it to that data type.
+
+    Parameters
+    ----------
+    array_object : numpy.ndarray or list of lists
+        The input array object which can be either a NumPy array or a list of lists.
+
+    array_type : str, optional
+        The type of data to which the input array should be converted. Should be either 'uint' (default) or any other NumPy data type.
+
+    Returns
+    -------
+    numpy.ndarray
+        The converted array object with the smallest possible memory type.
+
+    Raises
+    ------
+    TypeError
+        If the input `array_object` is not a NumPy array or list of lists.
+
+    ValueError
+        If the specified `array_type` is not supported by NumPy.
+
+    Notes
+    -----
+    This function uses NumPy's `iinfo` to determine the information about the integer data types and finds the smallest
+    data type that can store all values in the array without overflow.
+
+    Examples
+    --------
+    >>> arr = np.array([[1, 2], [3, 4]])
+    >>> result = smallest_memory_array(arr)
+    >>> print(result.dtype)
+    uint8
+
+    >>> import numpy as np
+    >>> arr = np.array([[1000, 2000], [3000, 4000]])
+    >>> result = smallest_memory_array(arr)
+    >>> print(result.dtype)
+    uint16
+    """
+    if isinstance(array_object, np.ndarray):
+        value_max = array_object.max()
+    else:
+        if len(array_object[0]) > 0:
+            value_max = np.max((array_object[0].max(), array_object[1].max()))
+        else:
+            value_max = 0
+
+    if array_type == 'uint':
+        if value_max <= np.iinfo(np.uint8).max:
+            array_object = np.array(array_object, dtype=np.uint8)
+        elif value_max <= np.iinfo(np.uint16).max:
+            array_object = np.array(array_object, dtype=np.uint16)
+        elif value_max <= np.iinfo(np.uint32).max:
+            array_object = np.array(array_object, dtype=np.uint32)
+        else:
+            array_object = np.array(array_object, dtype=np.uint64)
+    return array_object
+
+
+def remove_coordinates(arr1, arr2):
+    """
+    Remove coordinates from `arr1` that are present in `arr2`.
+
+    Given two arrays of coordinates, remove rows from the first array
+    that match any row in the second array.
+
+    Parameters
+    ----------
+    arr1 : ndarray of shape (n, 2)
+        Array containing coordinates to filter.
+    arr2 : ndarray of shape (m, 2)
+        Array containing coordinates to match for removal.
+
+    Returns
+    -------
+    ndarray of shape (k, 2)
+        Array with coordinates from `arr1` that are not in `arr2`.
+
+    Examples
+    --------
+    >>> arr1 = np.array([[0, 0], [1, 2], [3, 4]])
+    >>> arr2 = np.array([[1, 2], [5, 6]])
+    >>> remove_coordinates(arr1, arr2)
+    array([[0, 0],
+           [3, 4]])
+    """
+    # Convert to set of tuples
+    coords_to_remove = set(map(tuple, arr2))
+    return np.array([coord for coord in arr1 if tuple(coord) not in coords_to_remove])

cellects-0.1.0.dev1.dist-info/METADATA

@@ -0,0 +1,131 @@
+Metadata-Version: 2.2
+Name: cellects
+Version: 0.1.0.dev1
+Summary: Cell Expansion Computer Tracking Software.
+Author: Aurèle Boussard
+Project-URL: Homepage, https://github.com/Aurele-B/Cellects
+Project-URL: Issues, https://github.com/Aurele-B/Cellects/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Requires-Python: <3.13,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.odt
+Requires-Dist: coloredlogs
+Requires-Dist: exif
+Requires-Dist: ExifRead
+Requires-Dist: numba
+Requires-Dist: opencv-python
+Requires-Dist: pandas
+Requires-Dist: psutil
+Requires-Dist: PySide6>=6.5
+Requires-Dist: scipy
+Requires-Dist: screeninfo
+Requires-Dist: numpy>=1.26
+Requires-Dist: scikit-image
+Requires-Dist: tqdm
+Requires-Dist: h5py
+Requires-Dist: matplotlib
+Requires-Dist: natsort
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Provides-Extra: doc
+Requires-Dist: mkdocs; extra == "doc"
+Requires-Dist: mkdocs-material; extra == "doc"
+Requires-Dist: pymdown-extensions; extra == "doc"
+
+Cellects: Cell Expansion Computer Tracking Software
+===================================================
+
+Description
+-----------
+
+Cellects is a tracking software for organisms whose shape and size change over time. 
+Cellects’ main strengths are its broad scope of action, 
+automated computation of a variety of geometrical descriptors, easy installation and user-friendly interface.
+
+
+---
+
+## Quick Start
+
+
+⚠️ **Note:** At this stage, Cellects is available **only from source**.  
+You will need **Miniconda3** and **git** installed on your system.
+
+- Install [Miniconda3](https://docs.conda.io/en/latest/miniconda.html)  
+  (choose the installer for your operating system).  
+- Install [git](https://git-scm.com/downloads)  
+  (also available through package managers like `apt`, `brew`, or `choco`).
+
+Once these prerequisites are installed, you can set up Cellects as follows:
+
+```bash
+# Clone the repository
+git clone https://github.com/Aurele-B/Cellects.git
+cd Cellects
+
+# Create and activate the environment
+conda env create -f conda/env.yml
+conda activate cellects-dev
+
+# Install the package in editable mode
+pip install -e .
+```
+
+Launch the application:
+```bash
+Cellects
+```
+
+---
+
+## Developer Guide
+
+### Run Tests
+Cellects uses `pytest` + `pytest-cov`.  
+Install test dependencies:
+
+```bash
+pip install -e ".[test]"
+```
+
+Run the test suite (with coverage enabled by default via `pyproject.toml`):
+
+```bash
+pytest
+```
+
+You can access the coverage report with `coverage html` and open `htmlcov/index.html` in your browser.
+
+```bash
+open htmlcov/index.html        # macOS
+xdg-open htmlcov/index.html    # Linux
+start htmlcov\index.html       # Windows (PowerShell)
+```
+
+Or explicitly:
+```bash
+pytest --cov=src/cellects --cov-report=term-missing
+```
+
+### Build Documentation
+Install doc dependencies:
+
+```bash
+pip install -e ".[doc]"
+```
+
+Serve the docs locally:
+```bash
+mkdocs serve
+```
+
+Open [http://127.0.0.1:8000](http://127.0.0.1:8000) in your browser.
+
+---
+
+## Resources
+- [User manual](https://github.com/Aurele-B/Cellects/blob/main/_old_doc/UserManual.md)  
+- [Usage example (video)](https://www.youtube.com/watch?v=N-k4p_aSPC0)

cellects-0.1.0.dev1.dist-info/RECORD

@@ -0,0 +1,46 @@
+cellects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cellects/__main__.py,sha256=qiUkIOuyq3RuyHmYZM3drRbqe5DWP7IVyOGsEy425Lc,1449
+cellects/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cellects/config/all_vars_dict.py,sha256=JWS4Z9ppIXG7ugQPns7Et4Vb6r6n6DPcSYTr7uUYuwE,5980
+cellects/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cellects/core/cellects_paths.py,sha256=IV3O3p61OYa2Rk0FLUG-R8PsGKvLcsOuK2kzm9oVjbc,830
+cellects/core/cellects_threads.py,sha256=bGyhasTIV8Uad9Z8AoyXYY9YzDl5HqLPp2kzVeDRKPc,88820
+cellects/core/motion_analysis.py,sha256=AbPHVksE96mFXOA2ifDVTxL6S8cZAulnxXBvePcp21k,136709
+cellects/core/one_image_analysis.py,sha256=SeT1Ps6XAyjALFfgl8hLQ28Q0hkWwMu_DKmVY84ytkc,68577
+cellects/core/one_video_per_blob.py,sha256=evhWm56amxSBfZfKfmvBJK1wSWWIS19HPyXpxs8FsF0,42981
+cellects/core/program_organizer.py,sha256=CcT0px29HNRx2VgwQOAoEbHqZPGuFyxmAPlieCAgb2E,79209
+cellects/core/script_based_run.py,sha256=Y9FuJ2I5I3_T6vwAQ6w22vdGbkxmjLVAdDWPyoziVGU,6565
+cellects/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cellects/gui/advanced_parameters.py,sha256=pE2eGZ6tBuq40DalksDzHGGQSjBJcgVr1C2MOAVyGaM,78343
+cellects/gui/cellects.py,sha256=qgHLvrAVR1YatSsuOBl5u7aXCUqVHEbhse7EFkTINOA,7574
+cellects/gui/custom_widgets.py,sha256=2WcPsRgPCp4HEjA9x8wE8IX7RJ0A4XyBpN5rv-iqVL8,35503
+cellects/gui/first_window.py,sha256=wYQaA-VQFWp_YDjbCXl0e_PgD59-y8kUXRdD2tDelbQ,24803
+cellects/gui/if_several_folders_window.py,sha256=ixi6X4WDQ5CtunEPVFJWip8Sf5ba1Hk2t801lX5CNVk,12508
+cellects/gui/image_analysis_window.py,sha256=A3N16SCbWXAvN-irHzpf-kWJ7C-CFirjb98kAH8pIYs,106073
+cellects/gui/required_output.py,sha256=YJBSi_Vp5zet2pZVh71viGrlzE8EeMpX41opt3sD8QM,11992
+cellects/gui/video_analysis_window.py,sha256=xl2qtJqUp47GvPh7f4tQoaiK8nUO9Q2Rk6qGSiFBLp8,38033
+cellects/icons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cellects/icons/cellects_icon.icns,sha256=3GM5rpVKUoy-gAYEee5gGPh9lQx9KZqh9iRqYCT83Aw,393392
+cellects/icons/cellects_icon.ico,sha256=Eqlci8zZ0zdsRh2kSQAu4aHAPbR2NEzSbJPgaRQNenI,208076
+cellects/image_analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cellects/image_analysis/cell_leaving_detection.py,sha256=f0wWTACMQASSdXpDtJGe7STJTj6xs1UO1JJzI2FgDBk,2951
+cellects/image_analysis/cluster_flux_study.py,sha256=lHKo2OFN_FvmyX9kP7ubRadTVVxuXDeuRWQuydvyAGQ,5496
+cellects/image_analysis/extract_exif.py,sha256=BcZnNk528hmxdaM8wLzcRZlVz0_VhLySdqCbPzWNyyI,3447
+cellects/image_analysis/fractal_analysis.py,sha256=xC9CZVFBD43bXJFEATeI2Vsi82mzoZbKC_XFA8FD-CI,6785
+cellects/image_analysis/fractal_functions.py,sha256=1_6HWHDhri9w4sfPPBIx45Dz2bBs8491xFVtSa3Pkzw,4393
+cellects/image_analysis/image_segmentation.py,sha256=y_cFpdTyi1fDOmlVvtJphkIgZi3a9Txda3T0SnaTZmE,12021
+cellects/image_analysis/morphological_operations.py,sha256=-jt7vwrj2r-mvBCoDuDIyZmjy0qY0A7MprpZtb8sbvo,42908
+cellects/image_analysis/network_functions.py,sha256=5IRF2qH4Lqh3u4mQfdCpXBmN9Q6zwVu1siOWsgBkkn8,65233
+cellects/image_analysis/one_image_analysis_threads.py,sha256=AjAEbJmtldlf23UxWs5my7xz2NIYy3wm25o13pnnYq8,17253
+cellects/image_analysis/progressively_add_distant_shapes.py,sha256=fYj1pfG13-0aWagfLzki20zQJbP706YDXxIK8P572EI,13723
+cellects/image_analysis/shape_descriptors.py,sha256=jOQLWWLbk4KLd00MpZIL91ROxoV6h2cviLptkh6nw_8,35138
+cellects/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cellects/utils/formulas.py,sha256=JUY7iCLmUUbCiJ6rTqosSmnHu1FyreQ5ktrvfN1U5-g,25744
+cellects/utils/load_display_save.py,sha256=igaNsl3XmVTlaRL5Glq3E8XYQEuB83ePlSynjO0hrlA,34421
+cellects/utils/utilitarian.py,sha256=VKTpAGd2IEa_AJfVfIIS_ysNn_eROncmtQjYB7g7Eic,17318
+cellects-0.1.0.dev1.dist-info/LICENSE.odt,sha256=tvKfCylOEuclQm5zOnNWBx0Fp4n7M5yqSmTr6SAekbY,37132
+cellects-0.1.0.dev1.dist-info/METADATA,sha256=-x_CDE0x7EnchG3hx_iwG4Sr2jgZQ4f0M9O7QvysNGE,3316
+cellects-0.1.0.dev1.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+cellects-0.1.0.dev1.dist-info/entry_points.txt,sha256=JT6rEvKpUuKyDPvfOYma-IMQNvfnKMstFMAoVJhXIGc,60
+cellects-0.1.0.dev1.dist-info/top_level.txt,sha256=8VlvCH4ka3bqugIpQnOVjc3UV9Vavfx5SXNyUV9_lGw,9
+cellects-0.1.0.dev1.dist-info/RECORD,,

cellects-0.1.0.dev1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (76.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+