celldetective 1.1.0__py3-none-any.whl → 1.1.1.post1__py3-none-any.whl

celldetective/measure.py

@@ -27,6 +27,7 @@ from skimage.draw import disk as dsk
 from celldetective.filters import std_filter, gauss_filter
 from celldetective.utils import rename_intensity_column, create_patch_mask, remove_redundant_features, \
     remove_trajectory_measurements
+from celldetective.preprocessing import field_correction
 import celldetective.extra_properties as extra_properties
 from celldetective.extra_properties import *
 import cv2
@@ -771,7 +772,7 @@ def measure_isotropic_intensity(positions, # Dataframe of cell positions @ t
                 projection = np.multiply(crop_temp, expanded_mask)
 
                 projection[crop==epsilon] = epsilon
-                projection[expanded_mask==0.] = epsilon
+                projection[expanded_mask[:,:,0]==0.,:] = epsilon
 
                 for op in operations:
                     func = eval('np.'+op)
@@ -861,7 +862,7 @@ def measure_at_position(pos, mode, return_measurements=False, threads=1):
         return None
 
 
-def local_normalisation(image, labels, background_intensity, model='median', operation='subtract', clip=False):
+def local_normalisation(image, labels, background_intensity, measurement='intensity_median', operation='subtract', clip=False):
     """
      Perform local normalization on an image based on labels.
 
@@ -907,10 +908,10 @@ def local_normalisation(image, labels, background_intensity, model='median', ope
             continue
         if operation == 'subtract':
             image[np.where(labels == cell)] = image[np.where(labels == cell)].astype(float) - \
-                                              background_intensity[f'intensity_{model.lower()}'][index-1].astype(float)
+                                              background_intensity[measurement][index-1].astype(float)
         elif operation == 'divide':
             image[np.where(labels == cell)] = image[np.where(labels == cell)].astype(float) / \
-                                              background_intensity[f'intensity_{model.lower()}'][index-1].astype(float)
+                                              background_intensity[measurement][index-1].astype(float)
     if clip:
         image[image<=0.] = 0.
 
@@ -956,249 +957,23 @@ def normalise_by_cell(image, labels, distance=5, model='median', operation='subt
     """
     border = contour_of_instance_segmentation(label=labels, distance=distance * (-1))
     if model == 'mean':
+        measurement = 'intensity_nanmean'
+        extra_props = [getattr(extra_properties, measurement)]
         background_intensity = regionprops_table(intensity_image=image, label_image=border,
-                                                 properties=['intensity_mean'])
+                                                 extra_properties=extra_props)
     elif model == 'median':
-        median = []
-        median.append(getattr(extra_properties, 'intensity_median'))
+        measurement = 'intensity_median'
+        extra_props = [getattr(extra_properties, measurement)]
         background_intensity = regionprops_table(intensity_image=image, label_image=border,
-                                                 extra_properties=median)
+                                                 extra_properties=extra_props)
+
     normalised_frame = local_normalisation(image=image.astype(float).copy(),
-                                           labels=labels, background_intensity=background_intensity, model=model,
+                                           labels=labels, background_intensity=background_intensity, measurement=measurement,
                                            operation=operation, clip=clip)
 
     return normalised_frame
 
 
-def paraboloid(x, y, a, b, c, d, e, g):
-    return a * x ** 2 + b * y ** 2 + c * x * y + d * x + e * y + g
-
-
-def plane(x, y, a, b, c):
-    return a * x + b * y + c
-
-
-def fit_plane(image, cell_masks=None):
-    """
-    Fit a plane to the given image data.
-
-    Parameters:
-    - image (numpy.ndarray): The input image data.
-    - cell_masks (numpy.ndarray, optional): An array specifying cell masks. If provided, areas covered by
-                                            cell masks will be excluded from the fitting process.
-
-    Returns:
-    - numpy.ndarray: The fitted plane.
-
-    This function fits a plane to the given image data using least squares regression. It constructs a mesh
-    grid based on the dimensions of the image and fits a plane model to the data points. If cell masks are
-    provided, areas covered by cell masks will be excluded from the fitting process.
-
-    Example:
-    >>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-    >>> result = fit_plane(image)
-    >>> print(result)
-    [[1. 2. 3.]
-     [4. 5. 6.]
-     [7. 8. 9.]]
-
-    Note:
-    - The 'cell_masks' parameter allows excluding areas covered by cell masks from the fitting process.
-    """
-    data = np.empty(image.shape)
-    x = np.arange(0, image.shape[1])
-    y = np.arange(0, image.shape[0])
-    xx, yy = np.meshgrid(x, y)
-    params = Parameters()
-    params.add('a', value=1)
-    params.add('b', value=1)
-    params.add('c', value=1)
-    model = Model(plane, independent_vars=['x', 'y'])
-    weights = np.ones_like(xx, dtype=float)
-    weights[np.where(cell_masks > 0)] = 0.
-    result = model.fit(image,
-                       x=xx,
-                       y=yy,
-                       weights=weights,
-                       params=params, max_nfev=3000)
-    a = result.params['a'].value
-    b = result.params['b'].value
-    c = result.params['c'].value
-    fitted_plane = plane(xx, yy, a, b, c)
-    return fitted_plane
-
-
-def fit_paraboloid(image, cell_masks=None):
-    """
-    Fit a paraboloid to the given image data.
-
-    Parameters:
-    - image (numpy.ndarray): The input image data.
-    - cell_masks (numpy.ndarray, optional): An array specifying cell masks. If provided, areas covered by
-                                            cell masks will be excluded from the fitting process.
-
-    Returns:
-    - numpy.ndarray: The fitted paraboloid.
-
-    This function fits a paraboloid to the given image data using least squares regression. It constructs
-    a mesh grid based on the dimensions of the image and fits a paraboloid model to the data points. If cell
-    masks are provided, areas covered by cell masks will be excluded from the fitting process.
-
-    Example:
-    >>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-    >>> result = fit_paraboloid(image)
-    >>> print(result)
-    [[1. 2. 3.]
-     [4. 5. 6.]
-     [7. 8. 9.]]
-
-    Note:
-    - The 'cell_masks' parameter allows excluding areas covered by cell masks from the fitting process.
-    """
-    data = np.empty(image.shape)
-    x = np.arange(0, image.shape[1])
-    y = np.arange(0, image.shape[0])
-    xx, yy = np.meshgrid(x, y)
-    params = Parameters()
-    params.add('a', value=1)
-    params.add('b', value=1)
-    params.add('c', value=1)
-    params.add('d', value=1)
-    params.add('e', value=1)
-    params.add('g', value=1)
-    model = Model(paraboloid, independent_vars=['x', 'y'])
-    weights = np.ones_like(xx, dtype=float)
-    weights[np.where(cell_masks > 0)] = 0.
-
-    result = model.fit(image,
-                       x=xx,
-                       y=yy,
-                       weights=weights,
-                       params=params, max_nfev=3000)
-    a = result.params['a'].value
-    b = result.params['b'].value
-    c = result.params['c'].value
-    d = result.params['d'].value
-    e = result.params['e'].value
-    g = result.params['g'].value
-    fitted_paraboloid = paraboloid(xx, yy, a, b, c, d, e, g)
-    return fitted_paraboloid
-
-
-def correct_image(img, cell_masks=None, normalisation_operation=None, clip=False, mode=None):
-    """
-    Correct an image based on fitted models.
-
-    Parameters:
-    - img (numpy.ndarray): The input image data.
-    - cell_masks (numpy.ndarray, optional): An array specifying cell masks. If provided, areas covered by
-                                            cell masks will be considered during correction.
-    - normalisation_operation (str, optional): The normalisation operation ('Subtract' or 'Divide') to apply
-                                               during correction.
-    - clip (bool, optional): Whether to clip corrected values below zero to a minimum value of 0.00001.
-    - mode (str, optional): The mode of correction ('Paraboloid' or 'Plane').
-
-    Returns:
-    - tuple: A tuple containing the corrected image and the fitted model parameters.
-
-    This function corrects an image based on fitted models such as paraboloid or plane. It first fits a model
-    to the image data based on the specified mode. Then, it performs correction by subtracting or dividing the
-    image by the fitted model. Optionally, it clips corrected values below zero to a minimum value of 0.00001.
-
-    Example:
-    >>> img = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-    >>> correction, para = correct_image(img, mode='Paraboloid', normalisation_operation='Subtract', clip=True)
-    >>> print(correction)
-    [[0. 0. 0.]
-     [0. 0. 0.]
-     [0. 0. 0.]]
-    >>> print(para)
-    [[1. 2. 3.]
-     [4. 5. 6.]
-     [7. 8. 9.]]
-
-    Note:
-    - The 'cell_masks' parameter allows considering areas covered by cell masks during correction.
-    - The 'normalisation_operation' parameter specifies whether to subtract or divide the fitted model from
-      the image.
-    - If 'clip' is set to True, corrected values below zero will be clipped to a minimum value of 0.00001.
-    """
-    if mode == "Paraboloid":
-        para = fit_paraboloid(img.astype(float), cell_masks=cell_masks).astype(float)
-    elif mode == "Plane":
-        para = fit_plane(img.astype(float), cell_masks=cell_masks).astype(float)
-
-    if para is not None:
-        para = np.array(para)
-        if normalisation_operation == 'Subtract':
-            correction = img.astype(float) - para.astype(float)  # + 1000.
-        else:
-            correction = img.astype(float) / para.astype(float)  # + 1000.
-        correction = np.array(correction, dtype=float)
-        if clip:
-            correction[correction <= 0] = 0.00001
-
-    else:
-        correction = None
-
-    return correction, para
-
-
-def field_normalisation(img, threshold, normalisation_operation, clip, mode):
-    """
-        Perform field normalization on an image.
-
-        Parameters:
-        - img (numpy.ndarray): The input image data.
-        - threshold (float): The threshold value for determining regions of interest.
-        - normalisation_operation (str): The normalization operation ('Subtract' or 'Divide') to apply during correction.
-        - clip (bool): Whether to clip corrected values below zero to a minimum value of 0.00001.
-        - mode (str): The mode of correction ('Paraboloid' or 'Plane').
-
-        Returns:
-        - tuple: A tuple containing the normalized image and the fitted background model.
-
-        This function performs field normalization on an image based on regions of interest determined by the
-        specified threshold. It identifies regions with standard deviation above the threshold and considers them
-        as areas of interest. Then, it corrects the image using the 'correct_image' function based on the specified
-        mode and normalization operation.
-
-        Example:
-        >>> img = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-        >>> fluo_max, bg_fit = field_normalisation(img, threshold=0.5, normalisation_operation='Subtract', clip=True, mode='Paraboloid')
-        >>> print(fluo_max)
-        [[0. 0. 0.]
-         [0. 0. 0.]
-         [0. 0. 0.]]
-        >>> print(bg_fit)
-        [[1. 2. 3.]
-         [4. 5. 6.]
-         [7. 8. 9.]]
-
-        Note:
-        - The 'threshold' parameter determines regions of interest based on standard deviation.
-        - The 'normalisation_operation' parameter specifies whether to subtract or divide the fitted model from
-          the image during correction.
-        - If 'clip' is set to True, corrected values below zero will be clipped to a minimum value of 0.00001.
-        """
-    std_img = std_filter(gauss_filter(img, 2), 4)
-    mask = np.zeros_like(img)
-    if threshold=='':
-        pass
-    mask[np.where(std_img > float(threshold))] = 1.0
-    mask_int = mask.astype(int)
-    mask_int = binary_fill_holes(mask_int).astype(float)
-    # invert_mask = np.zeros_like(mask_int)
-    # invert_mask[mask_int == 0] = 1
-    # if isinstance(normalisation_operation,bool) and normalisation_operation:
-    #     normalisation_operation = 'Subtract'
-    # else:
-    #     normalisation_operation = 'Divide'
-    fluo_max, bg_fit = correct_image(img.astype(float), cell_masks=mask_int,
-                                     normalisation_operation=normalisation_operation, clip=clip, mode=mode)
-    return fluo_max, bg_fit
-
-
 def blob_detection(image, label, threshold, diameter):
     """
     Perform blob detection on an image based on labeled regions.

celldetective/models/segmentation_effectors/primNK_cfse/config_input.json

@@ -0,0 +1,29 @@
+{
+    "channels": [
+        "effector_fluo_channel",
+        "None"
+    ],
+    "diameter": 30.0,
+    "cellprob_threshold": 0.0,
+    "flow_threshold": 0.4,
+    "normalization_percentile": [
+        true,
+        true
+    ],
+    "normalization_clip": [
+        true,
+        true
+    ],
+    "normalization_values": [
+        [
+            0.5,
+            99.0
+        ],
+        [
+            1.0,
+            99.0
+        ]
+    ],
+    "model_type": "cellpose",
+    "spatial_calibration": 0.21783999999999998
+}

celldetective/models/segmentation_effectors/primNK_cfse/training_instructions.json

@@ -0,0 +1,37 @@
+{
+    "model_name": "cp-cfse-transfer",
+    "model_type": "cellpose",
+    "pretrained": "/home/limozin/Documents/GitHub/celldetective/celldetective/models/segmentation_generic/CP_cyto2",
+    "spatial_calibration": 0.21783999999999998,
+    "channel_option": [
+        "effector_fluo_channel",
+        "None"
+    ],
+    "normalization_percentile": [
+        true,
+        true
+    ],
+    "normalization_clip": [
+        true,
+        true
+    ],
+    "normalization_values": [
+        [
+            0.5,
+            99.0
+        ],
+        [
+            1.0,
+            99.0
+        ]
+    ],
+    "ds": [
+        "/home/limozin/Desktop/primNK_w_MCF7/dataset"
+    ],
+    "augmentation_factor": 1.5,
+    "validation_split": 0.2,
+    "learning_rate": 0.001,
+    "batch_size": 8,
+    "epochs": 3000,
+    "target_directory": "/home/limozin/Documents/GitHub/celldetective/celldetective/models/segmentation_effectors"
+}

celldetective/neighborhood.py

@@ -916,7 +916,8 @@ def mask_contact_neighborhood(setA, setB, labelsA, labelsB, distance, mode='two-
 							idx_B = np.where(mask_ids_B==int(mask_B))[0][0]
 							print(idx_A, idx_B)
 							indices_to_keep.append([idx_A,idx_B])
-						except:
+						except Exception as e:
+							print(f'{e} {t=} error something happened!!')
 							pass
 
 					print(f'Indices to keep: {indices_to_keep}...')
@@ -927,6 +928,8 @@ def mask_contact_neighborhood(setA, setB, labelsA, labelsB, distance, mode='two-
 							mask[indices_to_keep[:,1],indices_to_keep[:,0]] = False
 						dist_map[mask] = 1.0E06
 						plot_map=True
+					else:
+						dist_map[:,:] = 1.0E06
 				else:
 					dist_map[:,:] = 1.0E06