celldetective 1.0.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

celldetective/tracking.py

@@ -606,7 +606,6 @@ def interpolate_time_gaps(trajectories, column_labels={'track': "TRACK_ID", 'tim
 	trajectories.reset_index(drop=True, inplace=True)
 	trajectories[column_labels['time']] = trajectories[column_labels['time']].astype('int64').astype(float) / 10**9
 	#trajectories[column_labels['time']] = trajectories[column_labels['time']].astype('int64')
-	print(trajectories[column_labels['time']])
 	trajectories.sort_values(by=[column_labels['track'],column_labels['time']],inplace=True)
 	
 	return trajectories

celldetective/utils.py

@@ -367,7 +367,7 @@ def compute_weights(y):
 
 	return class_weights
 
-def train_test_split(data_x, data_y1, data_y2=None, validation_size=0.25, test_size=0):
+def train_test_split(data_x, data_y1, data_class=None, validation_size=0.25, test_size=0, n_iterations=10):
 
 	"""
 
@@ -407,37 +407,56 @@ def train_test_split(data_x, data_y1, data_y2=None, validation_size=0.25, test_s
 
 	"""
 
-	n_values = len(data_x)
-	randomize = np.arange(n_values)
-	np.random.shuffle(randomize)
+	if data_class is not None:
+		print(f"Unique classes: {np.sort(np.argmax(np.unique(data_class,axis=0),axis=1))}")
 
-	train_percentage = 1- validation_size - test_size
-	chunks = split_by_ratio(randomize, train_percentage, validation_size, test_size)
+	for i in range(n_iterations):
 
-	x_train = data_x[chunks[0]]
-	y1_train = data_y1[chunks[0]]
-	if data_y2 is not None:
-		y2_train = data_y2[chunks[0]]
+		n_values = len(data_x)
+		randomize = np.arange(n_values)
+		np.random.shuffle(randomize)
 
+		train_percentage = 1 - validation_size - test_size
 
-	x_val = data_x[chunks[1]]
-	y1_val = data_y1[chunks[1]]
-	if data_y2 is not None:
-		y2_val = data_y2[chunks[1]]
+		chunks = split_by_ratio(randomize, train_percentage, validation_size, test_size)
 
-	ds = {"x_train": x_train, "x_val": x_val,
-		 "y1_train": y1_train, "y1_val": y1_val}
-	if data_y2 is not None:
-		ds.update({"y2_train": y2_train, "y2_val": y2_val})
+		x_train = data_x[chunks[0]]
+		y1_train = data_y1[chunks[0]]
+		if data_class is not None:
+			y2_train = data_class[chunks[0]]
+
+		x_val = data_x[chunks[1]]
+		y1_val = data_y1[chunks[1]]
+		if data_class is not None:
+			y2_val = data_class[chunks[1]]
+
+		if data_class is not None:
+			print(f"classes in train set: {np.sort(np.argmax(np.unique(y2_train,axis=0),axis=1))}; classes in validation set: {np.sort(np.argmax(np.unique(y2_val,axis=0),axis=1))}")
+			same_class_test = np.array_equal(np.sort(np.argmax(np.unique(y2_train,axis=0),axis=1)), np.sort(np.argmax(np.unique(y2_val,axis=0),axis=1)))
+			print(f"Check that classes are found in all sets: {same_class_test}...")
+		else:
+			same_class_test = True
+
+		if same_class_test:
+
+			ds = {"x_train": x_train, "x_val": x_val,
+				 "y1_train": y1_train, "y1_val": y1_val}
+			if data_class is not None:
+				ds.update({"y2_train": y2_train, "y2_val": y2_val})
+
+			if test_size>0:
+				x_test = data_x[chunks[2]]
+				y1_test = data_y1[chunks[2]]
+				ds.update({"x_test": x_test, "y1_test": y1_test})
+				if data_class is not None:
+					y2_test = data_class[chunks[2]]
+					ds.update({"y2_test": y2_test})
+			return ds
+		else:
+			continue
+
+	raise Exception("Some classes are missing from the train or validation set... Abort.")
 
-	if test_size>0:
-		x_test = data_x[chunks[2]]
-		y1_test = data_y1[chunks[2]]
-		ds.update({"x_test": x_test, "y1_test": y1_test})
-		if data_y2 is not None:
-			y2_test = data_y2[chunks[2]]
-			ds.update({"y2_test": y2_test})
-	return ds
 
 def remove_redundant_features(features, reference_features, channel_names=None):
 
@@ -482,7 +501,7 @@ def remove_redundant_features(features, reference_features, channel_names=None):
 
 	"""
 
-	new_features = features.copy()
+	new_features = features[:]
 
 	for f in features:
 
@@ -1201,11 +1220,32 @@ def color_from_class(cclass, recently_modified=False):
 def random_fliprot(img, mask):
 
 	"""
+	Randomly flips and rotates an image and its corresponding mask.
+
+	This function applies a series of random flips and permutations (rotations) to both the input image and its
+	associated mask, ensuring that any transformations applied to the image are also exactly applied to the mask.
+	The function is designed to handle multi-dimensional images (e.g., multi-channel images in YXC format where
+	channels are last).
+
+	Parameters
+	----------
+	img : ndarray
+		The input image to be transformed. This array is expected to have dimensions where the channel axis is last.
+	mask : ndarray
+		The mask corresponding to `img`, to be transformed in the same way as the image.
+
+	Returns
+	-------
+	tuple of ndarray
+		A tuple containing the transformed image and mask.
 
-	Perform random flipping of the image and the associated mask. 
-	Needs YXC (channel last).
+	Raises
+	------
+	AssertionError
+		If the number of dimensions of the mask exceeds that of the image, indicating incompatible shapes.
 
 	"""
+
 	assert img.ndim >= mask.ndim
 	axes = tuple(range(mask.ndim))
 	perm = tuple(np.random.permutation(axes))
@@ -1225,12 +1265,37 @@ def random_fliprot(img, mask):
 def random_shift(image,mask, max_shift_amplitude=0.1):
 
 	"""
+	Randomly shifts an image and its corresponding mask along the X and Y axes.
 
-	Perform random shift of the image in X and or Y. 
-	Needs YXC (channel last).
+	This function shifts both the image and the mask by a randomly chosen distance up to a maximum
+	percentage of the image's dimensions, specified by `max_shift_amplitude`. The shifts are applied
+	independently in both the X and Y directions. This type of augmentation can help improve the robustness
+	of models to positional variations in images.
+
+	Parameters
+	----------
+	image : ndarray
+		The input image to be shifted. Must be in YXC format (height, width, channels).
+	mask : ndarray
+		The mask corresponding to `image`, to be shifted in the same way as the image.
+	max_shift_amplitude : float, optional
+		The maximum shift as a fraction of the image's dimension. Default is 0.1 (10% of the image's size).
+
+	Returns
+	-------
+	tuple of ndarray
+		A tuple containing the shifted image and mask.
+
+	Notes
+	-----
+	- The shift values are chosen randomly within the range defined by the maximum amplitude.
+	- Shifting is performed using the 'constant' mode where missing values are filled with zeros (cval=0.0),
+	  which may introduce areas of zero-padding along the edges of the shifted images and masks.
+	- This function is designed to support data augmentation for machine learning and image processing tasks,
+	  particularly in contexts where spatial invariance is beneficial.
+
+	"""
 
-	"""	
-	
 	input_shape = image.shape[0]
 	max_shift = input_shape*max_shift_amplitude
 	
@@ -1249,9 +1314,35 @@ def random_shift(image,mask, max_shift_amplitude=0.1):
 
 
 def blur(x,max_sigma=4.0):
+
 	"""
-	Random image blur
+	Applies a random Gaussian blur to an image.
+
+	This function blurs an image by applying a Gaussian filter with a randomly chosen sigma value. The sigma
+	represents the standard deviation for the Gaussian kernel and is selected randomly up to a specified maximum.
+	The blurring is applied while preserving the range of the image's intensity values and maintaining any
+	zero-valued pixels as they are.
+
+	Parameters
+	----------
+	x : ndarray
+		The input image to be blurred. The image can have any number of channels, but must be in a format
+		where the channels are the last dimension (YXC format).
+	max_sigma : float, optional
+		The maximum value for the standard deviation of the Gaussian blur. Default is 4.0.
+
+	Returns
+	-------
+	ndarray
+		The blurred image. The output will have the same shape and type as the input image.
+
+	Notes
+	-----
+	- The function ensures that zero-valued pixels in the input image remain unchanged after the blurring,
+	  which can be important for maintaining masks or other specific regions within the image.
+	- Gaussian blurring is commonly used in image processing to reduce image noise and detail by smoothing.
 	"""
+
 	sigma = np.random.random()*max_sigma
 	loc_i,loc_j,loc_c = np.where(x==0.)
 	x = gaussian(x, sigma, channel_axis=-1, preserve_range=True)
@@ -1262,8 +1353,44 @@ def blur(x,max_sigma=4.0):
 def noise(x, apply_probability=0.5, clip_option=False):
 
 	"""
-	Apply random noise to a multichannel image
+	Applies random noise to each channel of a multichannel image based on a specified probability.
+
+	This function introduces various types of random noise to an image. Each channel of the image can be
+	modified independently with different noise models chosen randomly from a predefined list. The application
+	of noise to any given channel is determined by a specified probability, allowing for selective noise
+	addition.
+
+	Parameters
+	----------
+	x : ndarray
+		The input multichannel image to which noise will be added. The image should be in format with channels
+		as the last dimension (e.g., height x width x channels).
+	apply_probability : float, optional
+		The probability with which noise is applied to each channel of the image. Default is 0.5.
+	clip_option : bool, optional
+		Specifies whether to clip the corrupted data to stay within the valid range after noise addition.
+		If True, the output array will be clipped to the range [0, 1] or [0, 255] depending on the input
+		data type. Default is False.
+
+	Returns
+	-------
+	ndarray
+		The noised image. This output has the same shape as the input but potentially altered intensity values
+		due to noise addition.
+
+	Notes
+	-----
+	- The types of noise that can be applied include 'gaussian', 'localvar', 'poisson', and 'speckle'.
+	- The choice of noise type for each channel is randomized and the noise is only applied if a randomly
+	  generated number is less than or equal to `apply_probability`.
+	- Zero-valued pixels in the input image remain zero in the output to preserve background or masked areas.
 
+	Examples
+	--------
+	>>> import numpy as np
+	>>> x = np.random.rand(256, 256, 3)  # Example 3-channel image
+	>>> noised_image = noise(x)
+	# The image 'x' may have different types of noise applied to each of its channels with a 50% probability.
 	"""
 
 	x_noise = x.astype(float).copy()
@@ -1678,4 +1805,19 @@ def download_zenodo_file(file, output_dir):
 	if file=='db-si-NucCondensation':
 		os.rename(os.sep.join([output_dir,'db1-NucCondensation']), os.sep.join([output_dir,file]))
 
-	os.remove(path_to_zip_file)
+	os.remove(path_to_zip_file)
+
+def interpolate_nan(array_like):
+
+	array = array_like.copy()
+	
+	isnan_array = ~np.isnan(array)
+	
+	xp = isnan_array.ravel().nonzero()[0]
+	
+	fp = array[~np.isnan(array)]
+	x = np.isnan(array).ravel().nonzero()[0]
+	
+	array[np.isnan(array)] = np.interp(x, xp, fp)
+	
+	return array

celldetective-1.1.0.dist-info/METADATA

@@ -0,0 +1,305 @@
+Metadata-Version: 2.1
+Name: celldetective
+Version: 1.1.0
+Summary: description
+Home-page: http://github.com/remyeltorro/celldetective
+Author: Rémy Torro
+Author-email: remy.torro@inserm.fr
+License: GPL-3.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: wheel
+Requires-Dist: nbsphinx
+Requires-Dist: nbsphinx-link
+Requires-Dist: sphinx-rtd-theme
+Requires-Dist: sphinx ==5.0.2
+Requires-Dist: jinja2 <3.1
+Requires-Dist: ipykernel
+Requires-Dist: stardist
+Requires-Dist: cellpose <3
+Requires-Dist: scikit-learn
+Requires-Dist: btrack
+Requires-Dist: tensorflow <=2.12.1
+Requires-Dist: napari
+Requires-Dist: tqdm
+Requires-Dist: mahotas
+Requires-Dist: fonticon-materialdesignicons6
+Requires-Dist: art
+Requires-Dist: lifelines
+Requires-Dist: setuptools
+Requires-Dist: scipy
+Requires-Dist: seaborn
+Requires-Dist: opencv-python-headless ==4.7.0.72
+Requires-Dist: liblapack
+Requires-Dist: gputools
+Requires-Dist: lmfit ~=1.2.2
+Requires-Dist: superqt[cmap] >=0.6.1
+Requires-Dist: matplotlib-scalebar
+
+# Celldetective
+
+<embed>
+    <p align="center">
+    <img src="https://github.com/remyeltorro/celldetective/blob/main/celldetective/icons/logo-large.png" width="33%" />
+    </p>
+</embed>
+
+![ico1](https://img.shields.io/readthedocs/celldetective?link=https%3A%2F%2Fcelldetective.readthedocs.io%2Fen%2Flatest%2Findex.html)
+![ico17](https://github.com/remyeltorro/celldetective/actions/workflows/test.yml/badge.svg)
+![ico4](https://img.shields.io/pypi/v/celldetective)
+![ico6](https://img.shields.io/github/downloads/remyeltorro/celldetective/total)
+![ico5](https://img.shields.io/pypi/dm/celldetective)
+![ico2](https://img.shields.io/github/forks/remyeltorro/celldetective?link=https%3A%2F%2Fgithub.com%2Fremyeltorro%2Fcelldetective%2Fforks)
+![ico3](https://img.shields.io/github/stars/remyeltorro/celldetective?link=https%3A%2F%2Fgithub.com%2Fremyeltorro%2Fcelldetective%2Fstargazers)
+
+Celldetective is a python package and software to perform single-cell
+analysis on multimodal time lapse microscopy images.
+
+-   **Documentation:** <https://celldetective.readthedocs.io>
+-   **Source code:** <https://github.com/remyeltorro/celldetective>
+-   **Bug reports:**
+    <https://github.com/remyeltorro/celldetective/issues/new/choose>
+-   **Datasets, models and demos:**
+    <https://zenodo.org/records/10650279>
+
+## Overview
+
+<embed>
+    <p align="center">
+    <img src="https://github.com/remyeltorro/celldetective/blob/main/docs/source/_static/celldetective-blocks.png" width="90%" />
+    </p>
+</embed>
+
+Despite notable efforts in the development of user-friendly softwares
+that integrate state-of-the-art solutions to perform single cell
+analysis, very few are designed for time-lapse data and even less for
+multimodal problems where cells populations are mixed and can only be
+separated through the use of multimodal information. Few software
+solutions provide, to our knowledge, the extraction of response
+functions from single cell events such as the dynamic survival of a
+population directly in the GUI, as coding skills are usually required to
+do so. We want to study complex data which is often multimodal time
+lapse microscopy images of interacting cell populations, without loss of
+generality. With a high need for an easy-to-use,
+no-coding-skill-required software adapted to images and intended for
+biologists, we introduce **Celldetective**, an open-source python-based
+software with the following highlight features:
+
+-   **Comprehensive single-cell image analysis** : Celldetective ships
+    segmentation, tracking, and measurement modules, as well as event
+    detection from single-cell signals, for up to two populations of
+    interest.
+-   **Integration of state-of-the-art solutions** : Celldetective
+    harnesses state-of-the-art segmentation techniques (StarDist[^1],
+    Cellpose[^2] ,[^3]) and tracking algorithm (bTrack[^4]), as well as
+    the napari viewer[^5] where applicable. These algorithms are
+    interfaced to be well integrated and accessible for the target
+    audience, in the context of complex biological applications.
+-   **A framework for event description and annotations** : we propose a
+    broad and intuitive framework to annotate and automate the detection
+    of events from single-cell signals through Deep Learning signal
+    classification and regression. The event formulation is directly
+    exploited to define population survival responses.
+-   **A neighborhood scheme to study cell-cell interactions** : we
+    introduce a neighborhood scheme to relate the spatio-temporal
+    distribution and measurements of two cell populations, allowing the
+    study of how cell-cell interactions affect single-cell and
+    population responses.
+-   **Deep Learning customization in GUI** : Celldetective facilitates
+    the specialization of Deep Learning models or the creation of new
+    ones adapted to user data, by facilitating the creation of training
+    sets and the training of such models, without having to write a
+    single line of code.
+-   **In-software analysis** : Celldetective ships visualization tools
+    to collapse single-cell signals with respect to an event, build
+    survival curves, compare measurement distributions across biological
+    conditions.
+-   **A library of segmentation and signal models**: we created specific
+    models to investigate a co-culture of MCF-7 cells and primary NK
+    cells, that are available directly is the software with a large
+    collection of generalist models developed by the StarDist and
+    Cellpose teams, which are a perfect starting point to segment single
+    cells in a new biological system.
+-   **Accessible and open source** : Celldetective does not require any
+    coding skills. The software, its models and datasets are made fully
+    open source to encourage transparency and reproducibility.
+
+<embed>
+    <p align="center">
+    <img src="https://github.com/remyeltorro/celldetective/blob/main/docs/source/_static/signal-annotator.gif" width="90%" />
+    </p>
+</embed>
+
+# System requirements
+
+## Hardware requirements
+
+The software was tested on several machines, including:
+
+-   An Intel(R) Core(TM) i9-10850K CPU @ 3.60GHz, with a single NVIDIA
+    GeForce RTX 3070 (8 Gb of memory) and 16 Gb of memory
+-   An Intel(R) Core(TM) i7-9750H CPU @ 2.60 GHz, with 16 Gb of memory
+
+In GPU mode, succesive segmentation and DL signal analysis could be
+performed without saturating the GPU memory thanks to the subprocess
+formulation for the different modules. The GPU can be disabled in the
+startup window. The software does not require a GPU (but model inference
+will be longer). A typical analysis of a single movie with a GPU takes
+between 5 to 15 minutes. Depending on the number of cells and frames on
+the images, this computation time can increase to the order of half an
+hour on a CPU.
+
+The memory must be sufficient to load a movie stack at once in order to
+visualize it in napari. Otherwise, processing is performed frame by
+frame, therefore the memory required is extremely low.
+
+## Software requirements
+
+The software was developed simulateously on Ubuntu 20.04 and Windows 11.
+It was tested on MacOS, but Tensorflow installation can rquire extra
+steps.
+
+-   Linux: Ubuntu 20.04.6 LTS (Focal Fossa) (not tested on ulterior
+    versions)
+-   Windows: Windows 11 Home 23H2
+
+To use the software, you must install python, *e.g.* through
+[Anaconda](https://www.anaconda.com/download). We developed and tested
+the software in Python 3.9.18.
+
+# Installation
+
+## Stable release
+
+Celldetective can be installed with `pip`:
+
+``` bash
+pip install celldetective
+```
+
+We recommend that you create an environment to use Celldetective, *e.g.*
+with `conda`:
+
+``` bash
+conda create -n celldetective python=3.9.18 pyqt
+conda activate celldetective
+pip install celldetective
+```
+
+Need an update? Simply type the following in the terminal (in your
+environment):
+
+``` bash
+pip install --upgrade celldetective
+```
+
+## Development version
+
+### From GitHub
+
+If you want to run the latest development version, you can clone the
+repository to your local machine and install Celldetective in
+"development" mode. This means that any changes to the cloned repository
+will be immediately available in the python environment:
+
+``` bash
+# creates "celldetective" folder
+git clone git://github.com/remyeltorro/celldetective.git
+cd celldetective
+
+# install the celldetective package in editable/development mode
+pip install -r requirements.txt
+pip install -e .
+```
+
+To run the latest development version without cloning the repository,
+you can also use this line:
+
+``` bash
+pip install git+https//github.com/remyeltorro/celldetective.git
+```
+
+### From a zip file
+
+You can also download the repository as a compressed file. Unzip the
+file and open a terminal at the root of the folder (same level as the
+file requirements.txt). We recommend that you create a python
+environment as Celldetective relies on many packages that may interfere
+with package requirements for other projects. Run the following lines to
+create an environment named \"celldetective\":
+
+``` bash
+conda create -n celldetective python=3.9.18 pyqt
+conda activate celldetective
+pip install -r requirements.txt
+pip install .
+```
+
+The installation of the dependencies will take a few minutes (up to half
+an hour if the network is bad). The Celldetective package itself is
+light and installs in a few seconds.
+
+Before launching the software, move to a different directory as running
+the package locally can create some bugs when locating the models.
+
+# Quick start
+
+You can launch the GUI by 1) opening a terminal and 2) typing the
+following:
+
+``` bash
+python -m celldetective
+```
+
+# Documentation
+
+Read the tutorial here:
+
+<https://celldetective.readthedocs.io/>
+
+# How to cite?
+
+If you use this software in your research, please cite the
+[Celldetective](https://www.biorxiv.org/content/10.1101/2024.03.15.585250v1)
+paper (currently preprint):
+
+``` raw
+@article {Torro2024.03.15.585250,
+    author = {R{\'e}my Torro and Beatriz D{\`\i}az-Bello and Dalia El Arawi and Lorna Ammer and Patrick Chames and Kheya Sengupta and Laurent Limozin},
+    title = {Celldetective: an AI-enhanced image analysis tool for unraveling dynamic cell interactions},
+    elocation-id = {2024.03.15.585250},
+    year = {2024},
+    doi = {10.1101/2024.03.15.585250},
+    publisher = {Cold Spring Harbor Laboratory},
+    abstract = {A current key challenge in bioimaging is the analysis of multimodal and multidimensional data reporting dynamic interactions between diverse cell populations. We developed Celldetective, a software that integrates AI-based segmentation and tracking algorithms and automated signal analysis into a user-friendly graphical interface. It offers complete interactive visualization, annotation, and training capabilities. We demonstrate it by analyzing original experimental data of spreading immune effector cells as well as antibody-dependent cell cytotoxicity events using multimodal fluorescence microscopy.Competing Interest StatementThe authors have declared no competing interest.},
+    URL = {https://www.biorxiv.org/content/early/2024/03/17/2024.03.15.585250},
+    eprint = {https://www.biorxiv.org/content/early/2024/03/17/2024.03.15.585250.full.pdf},
+    journal = {bioRxiv}
+}
+```
+
+Make sure you to cite the papers of any segmentation model (StarDist,
+Cellpose) or tracker (bTrack) you used through Celldetective.
+
+# Bibliography
+
+[^1]: Schmidt, U., Weigert, M., Broaddus, C. & Myers, G. Cell Detection
+    with Star-Convex Polygons. in Medical Image Computing and Computer
+    Assisted Intervention -- MICCAI 2018 (eds. Frangi, A. F., Schnabel,
+    J. A., Davatzikos, C., Alberola-López, C. & Fichtinger, G.) 265--273
+    (Springer International Publishing, Cham, 2018).
+    <doi:10.1007/978-3-030-00934-2_30>.
+
+[^2]: Stringer, C., Wang, T., Michaelos, M. & Pachitariu, M. Cellpose: a
+    generalist algorithm for cellular segmentation. Nat Methods 18,
+    100--106 (2021).
+
+[^3]: Pachitariu, M. & Stringer, C. Cellpose 2.0: how to train your own
+    model. Nat Methods 19, 1634--1641 (2022).
+
+[^4]: Ulicna, K., Vallardi, G., Charras, G. & Lowe, A. R. Automated Deep
+    Lineage Tree Analysis Using a Bayesian Single Cell Tracking
+    Approach. Frontiers in Computer Science 3, (2021).
+
+[^5]: Ahlers, J. et al. napari: a multi-dimensional image viewer for
+    Python. Zenodo <https://doi.org/10.5281/zenodo.8115575> (2023).

celldetective-1.1.0.dist-info/RECORD

@@ -0,0 +1,80 @@
+celldetective/__init__.py,sha256=FEZpJKcskBH2IginYzeqPWoR1lVGuyYCXhv7Hnlkoo8,49
+celldetective/__main__.py,sha256=zX2ZDiUp02OlHSwsVUDJ6aCKRAAYU0SSmallsiz1HsA,14054
+celldetective/events.py,sha256=s2pWnR3Z1fcB15sET5WsF2Pi6v6qv16hks_m3WiklNs,3658
+celldetective/extra_properties.py,sha256=9tQiXgkUlhmqyE7gUMgq_Kq-XTWTeeMAtFzDNwSmCgU,3961
+celldetective/filters.py,sha256=i-XN6psgdaG_w6gjK2Qvb1OshspQaDsV_PF1WTyo2Sw,2704
+celldetective/io.py,sha256=nkMj9s8fO_I3J-fVVsuRiEDrJ4nHcdWQqN-9P20DcHQ,80323
+celldetective/measure.py,sha256=5Jr9F9LEj3KzD32ssbPuGgS7sCghRurxYV9e2qjkuj0,56981
+celldetective/neighborhood.py,sha256=WZihWn6npFhe9C_LSmGhLuPevzsvjuscmH-xPLoWO6I,49406
+celldetective/preprocessing.py,sha256=jo5mtCBTh8OwETeGRG89RHjSb3yM_75icA2bMJe35bY,24280
+celldetective/segmentation.py,sha256=L_dP3n0U4V0QQhQBl-dL5NenE4d04KEYt1zFRlRUvkM,28496
+celldetective/signals.py,sha256=q7JSyQolsbCqrClyiigDVKhWGj1KmXkWDrk-VGgvjeY,109452
+celldetective/tracking.py,sha256=uTwCc8saEEHE7bcrv0ML9BNfbiwxUM6DWYK2yBoyzIU,37526
+celldetective/utils.py,sha256=msx-aPX4Uqyrt1jSwzwbq7GIuqkLs8LL3cDqRuTOnQo,65322
+celldetective/datasets/segmentation_annotations/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+celldetective/datasets/signal_annotations/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+celldetective/gui/__init__.py,sha256=y2dvrUdJi17QMgPjl8WN3XFHYzJpu2ul4_8y7MQV1Bk,941
+celldetective/gui/about.py,sha256=i-y54Opb10pKTVNUEcJC-D6Cbiqud2EJ3ZLayXqhdqc,1715
+celldetective/gui/analyze_block.py,sha256=WD3JQQylx_dVozFCvNqrOyR6LcNHV7R1_gGh7XqOVeI,25423
+celldetective/gui/btrack_options.py,sha256=eQEf63yTUsPCN-d1LqgAMmUQpfv2FH85FqnOSaR-9Q8,35575
+celldetective/gui/classifier_widget.py,sha256=qvRl6svlelGsi-IRa7MrCGXrx4sRI8egl5xdGLH3r1A,15341
+celldetective/gui/configure_new_exp.py,sha256=ANJ-Zn4sjBphtj_aoJu6m1PFEKyv9gxeh9XqS6xOGjk,18969
+celldetective/gui/control_panel.py,sha256=Ndd6zeTNfo3KqfNeIa7XHX4Cj9GDKq5Qw1LtIsUQBgY,17466
+celldetective/gui/gui_utils.py,sha256=PidFfdc8XASeIzZO5pfKgwqe4vROG7-KpYMcBZ42jdw,22673
+celldetective/gui/json_readers.py,sha256=fTrNrlxv9NCae8ZJexBEHxI3yCLRqt6F0Yo1OeDycfA,3686
+celldetective/gui/layouts.py,sha256=6q3mvOEYdvceFYYGtWFKxAJTLKnaGj0FzYhjM3--x6g,26884
+celldetective/gui/measurement_options.py,sha256=L6NETkOM7wucRVuwY4SP7JenQ9bMNGEv-DI3C3t9JW0,52725
+celldetective/gui/neighborhood_options.py,sha256=sdKxVRliZtuKSpcPfnFxqkW4V8rN2tzjhDxOPVmElyE,20191
+celldetective/gui/plot_measurements.py,sha256=xUoGxV6uXcen-t4yWtAmcGTUayICI-FxTVKPrWMNlfg,51799
+celldetective/gui/plot_signals_ui.py,sha256=AQ_Ab6bg2tmvZv5dypbaBqJBML7IE_WlDsrkxL0dXAY,43699
+celldetective/gui/process_block.py,sha256=pI-HDU8_s0_jNNnbRBYj7RZrz7Z6cg6xVYOfrfvdwpc,53564
+celldetective/gui/retrain_segmentation_model_options.py,sha256=-rkuUzI_vFFlZC3LAAYEELoJUKcz6PmkpCrxKZindhg,27218
+celldetective/gui/retrain_signal_model_options.py,sha256=uHZy3FGsGMHfZL_nYnuFiXF57XaAMVzjYxVF2OXhYnY,24184
+celldetective/gui/seg_model_loader.py,sha256=uKp8oab-4QdTGqb-tb6bOD-FLD_154GOvgWFYz97BwY,17350
+celldetective/gui/signal_annotator.py,sha256=4ymMpo_GjSBsJSRkyNKrWRLy0EFXHINbFtp9ykDqfGE,84864
+celldetective/gui/signal_annotator_options.py,sha256=-Q7f8eCwniqbgLJqMCa91Wc-V3VHAZidwt7LPd4Z5yU,10879
+celldetective/gui/styles.py,sha256=Vw4wr6MQ4iBwhOY-ZWAxFDZZ3CNohmEnuPPazwhJaho,4129
+celldetective/gui/survival_ui.py,sha256=Y7EbLFqINSBA_Cl3_fjGImbfp2PvpFt11pHuqkcT3OM,33537
+celldetective/gui/tableUI.py,sha256=DR2HVTLkR3XYZ_Rkyt7DLObOszuG7rlxyz5d6wIO1Oc,22467
+celldetective/gui/thresholds_gui.py,sha256=vbkiJcBejiqdk45r57Ig38LDyNMqLqqmh1FnaVltxVA,47821
+celldetective/gui/viewers.py,sha256=eN4JevoDGAZGI_QdmRJ3SJRh4_XGUR9BhA_ymAF4xAY,19676
+celldetective/icons/logo-large.png,sha256=FXSwV3u6zEKcfpuSn4unnqB0oUnN9cHqQ9BCKWytrpg,36631
+celldetective/icons/logo.png,sha256=wV2OS8_dU5Td5cgdPbCOU3JpMpTwNuYLnfVcnQX0tJA,2437
+celldetective/icons/signals_icon.png,sha256=vEiKoqWTtN0-uJgVqtAlwCuP-f4QeWYOlO3sdp2tg2w,3969
+celldetective/icons/splash-test.png,sha256=W9smcuuwJUF9DU-rz4aACx7_rCmGRsxYUGPBDlDnrJk,17523
+celldetective/icons/splash.png,sha256=J_1jPJylxwHGzGF1xCGocc-BmylHtHTII9VJSLKnezY,17895
+celldetective/icons/splash0.png,sha256=qVXsrYUinm5g6-vbHcqwyjh8SIqs9lEqPWnPa1WijaQ,14233
+celldetective/icons/survival2.png,sha256=8zsualD7d9VPAecoFA4Om9TFARErqpJzMg6U7XANXf4,4479
+celldetective/icons/vignette_signals2.png,sha256=hsVOdQDpEfMGM45aaSeacEm3lvxbquRKKYutiS9qoS0,20743
+celldetective/icons/vignette_signals2.svg,sha256=muGNcQudV1jG-bmFd9FwV-Wb8PcrRV5osdZ7pHR7Ekk,5947
+celldetective/links/zenodo.json,sha256=7WKRuZY7MHTR-IChWBbU0i47H_479NtlxsCGaJn9-xM,22728
+celldetective/models/segmentation_effectors/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+celldetective/models/segmentation_generic/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+celldetective/models/segmentation_targets/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+celldetective/models/signal_detection/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+celldetective/models/tracking_configs/mcf7.json,sha256=iDjb8i6yxs0GleW39dvY3Ld5bZJatlXJrwI8PG3vCT0,1780
+celldetective/models/tracking_configs/ricm.json,sha256=L-vmwCR1f89U-qnH2Ms0cBfPFR_dxIWoe2ccH8V-QBA,2727
+celldetective/models/tracking_configs/ricm2.json,sha256=DDjJ6ScYcDWvlsy7ujPID8v8H28vcNcMuZmNR8XmGxo,2718
+celldetective/scripts/analyze_signals.py,sha256=23TXGNw-j5xT3ss4mXlnKdBgFLnQ50JUEQOC6_H7Q_0,2203
+celldetective/scripts/measure_cells.py,sha256=4uRG6Dg0WsO-N8ZaBJ4loWOvX6FdHaCblIFXq6Dtirc,11000
+celldetective/scripts/segment_cells.py,sha256=xz1wERezJFF3sI0tS3mRLD7-K0zhEIyAEH60p06DFgU,7660
+celldetective/scripts/segment_cells_thresholds.py,sha256=GbWXa6xoO8s4PinJPZIxAuosw4vpzyJ7FiFYpSURojk,4998
+celldetective/scripts/track_cells.py,sha256=AaNiYEW4osYKKR2kbdVLOUnQEBbcZIA-D0mkhcxPWTY,7985
+celldetective/scripts/train_segmentation_model.py,sha256=dBXq3OOu6F0kWyYcI3K7W_hMUYvndrwKRswBS_-zQnw,8378
+celldetective/scripts/train_signal_model.py,sha256=9-dmPCLKJ9ypjsV9AwFd-Sb6B6YaHS0QGT218H5hUPo,1861
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_events.py,sha256=eLFwwEEJfQAdwhews3-fn1HSvzozcNNFN_Qn0gOvQkE,685
+tests/test_filters.py,sha256=iJksl_HgquqGzPPv46qpNtlD4rkBpZ5eVtIotgZ7LDs,656
+tests/test_io.py,sha256=gk5FmoI7ANEczUtNXYRxc48KzkfYzemwS_eYaLq4_NI,2093
+tests/test_measure.py,sha256=FEUAs1rVHylvIvubCb0bJDNGZLVmkgXNgI3NaGQ1dA8,4542
+tests/test_neighborhood.py,sha256=gk5FmoI7ANEczUtNXYRxc48KzkfYzemwS_eYaLq4_NI,2093
+tests/test_segmentation.py,sha256=-3b7o_fUVMYxfVwX5VHFqRF0dDXObSTtylf5XQGcq1A,3493
+tests/test_signals.py,sha256=No4cah6KxplhDcKXnU8RrA7eDla4hWw6ccf7xGnBokU,3599
+tests/test_tracking.py,sha256=8hebWSqEIuttD1ABn-6dKCT7EXKRR7-4RwyFWi1WPFo,8800
+tests/test_utils.py,sha256=emElC0EgoIeCXnTweZVh-TFT2czu9XSgiRqP9sqFUX8,2175
+celldetective-1.1.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+celldetective-1.1.0.dist-info/METADATA,sha256=ilgLPeG4uYwEibAGA2uO68p83-eWwP6k7azcQIF8gT4,12412
+celldetective-1.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+celldetective-1.1.0.dist-info/entry_points.txt,sha256=2NU6_EOByvPxqBbCvjwxlVlvnQreqZ3BKRCVIKEv3dg,62
+celldetective-1.1.0.dist-info/top_level.txt,sha256=6rsIKKfGMKgud7HPuATcpq6EhdXwcg_yknBVWn9x4C4,20
+celldetective-1.1.0.dist-info/RECORD,,

{celldetective-1.0.2.dist-info → celldetective-1.1.0.dist-info}/top_level.txt

@@ -1 +1,2 @@
 celldetective
+tests