celldetective 1.0.2.post1__py3-none-any.whl → 1.1.1__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
@@ -308,10 +309,11 @@ def drop_tonal_features(features):
 
     """
 
+    feat2 = features[:]
     for f in features:
         if 'intensity' in f:
-            features.remove(f)
-    return features
+            feat2.remove(f)
+    return feat2
 
 def measure_features(img, label, features=['area', 'intensity_mean'], channels=None,
                      border_dist=None, haralick_options=None, verbose=True, normalisation_list=None,
@@ -389,26 +391,20 @@ def measure_features(img, label, features=['area', 'intensity_mean'], channels=N
                                                       columns=['count', 'spot_mean_intensity']).reset_index()
             # Rename columns
             df_spots.columns = ['label', 'spot_count', 'spot_mean_intensity']
+        
         if normalisation_list:
             for norm in normalisation_list:
                 for index, channel in enumerate(channels):
-                    if channel == norm['target channel']:
+                    if channel == norm['target_channel']:
                         ind = index
-                if norm['mode'] == 'local':
+                if norm['correction_type'] == 'local':
                     normalised_image = normalise_by_cell(img[:, :, ind].copy(), label,
-                                                         distance=int(norm['distance']), mode=norm['type'],
-                                                         operation=norm['operation'])
+                                                         distance=int(norm['distance']), model=norm['model'],
+                                                         operation=norm['operation'], clip=norm['clip'])
                     img[:, :, ind] = normalised_image
                 else:
-                    if norm['operation'] == 'Divide':
-                        normalised_image, bg = field_normalisation(img[:, :, ind].copy(), threshold=norm['threshold'],
-                                                                   normalisation_operation=norm['operation'],
-                                                                   clip=False, mode=norm['type'])
-                    else:
-                        normalised_image, bg = field_normalisation(img[:, :, ind].copy(), threshold=norm['threshold'],
-                                                                   normalisation_operation=norm['operation'],
-                                                                   clip=norm['clip'], mode=norm['type'])
-                    img[:, :, ind] = normalised_image
+                    corrected_image = field_correction(img[:,:,ind].copy(), threshold_on_std=norm['threshold_on_std'], operation=norm['operation'], model=norm['model'], clip=norm['clip'])
+                    img[:, :, ind] = corrected_image
 
     extra_props = getmembers(extra_properties, isfunction)
     extra_props = [extra_props[i][0] for i in range(len(extra_props))]
@@ -725,7 +721,7 @@ def measure_isotropic_intensity(positions, # Dataframe of cell positions @ t
 
     """
 
-
+    epsilon = -10000
     assert ((img.ndim==2)|(img.ndim==3)),f'Invalid image shape to compute the Haralick features. Expected YXC, got {img.shape}...'
 
     if img.ndim==2:
@@ -753,7 +749,7 @@ def measure_isotropic_intensity(positions, # Dataframe of cell positions @ t
 
             pad_value_x = mask.shape[0]//2 + 1
             pad_value_y = mask.shape[1]//2 + 1
-            frame_padded = np.pad(img, [(pad_value_x,pad_value_x),(pad_value_y,pad_value_y),(0,0)])
+            frame_padded = np.pad(img.astype(float), [(pad_value_x,pad_value_x),(pad_value_y,pad_value_y),(0,0)], constant_values=[(epsilon,epsilon),(epsilon,epsilon),(0,0)])
 
             # Find a way to measure intensity in mask
             for tid,group in positions.groupby(column_labels['track']):
@@ -770,11 +766,17 @@ def measure_isotropic_intensity(positions, # Dataframe of cell positions @ t
 
                 expanded_mask = np.expand_dims(mask, axis=-1)  # shape: (X, Y, 1)
                 crop = frame_padded[ymin:ymax,xmin:xmax]
-                projection = np.multiply(crop, expanded_mask)
+
+                crop_temp = crop.copy()
+                crop_temp[crop_temp==epsilon] = 0.
+                projection = np.multiply(crop_temp, expanded_mask)
+
+                projection[crop==epsilon] = epsilon
+                projection[expanded_mask[:,:,0]==0.,:] = epsilon
 
                 for op in operations:
                     func = eval('np.'+op)
-                    intensity_values = func(projection, axis=(0,1), where=projection!=0.)
+                    intensity_values = func(projection, axis=(0,1), where=projection>epsilon)
                     for k in range(crop.shape[-1]):
                         if isinstance(r,list):
                             positions.loc[group.index, f'{channels[k]}_ring_{min(r)}_{max(r)}_{op}'] = intensity_values[k]
@@ -806,7 +808,7 @@ def measure_isotropic_intensity(positions, # Dataframe of cell positions @ t
 
             for op in operations:
                 func = eval('np.'+op)
-                intensity_values = func(projection, axis=(0,1), where=projection!=0.)
+                intensity_values = func(projection, axis=(0,1), where=projection==projection)
                 for k in range(crop.shape[-1]):
                     positions.loc[group.index, f'{channels[k]}_custom_kernel_{op}'] = intensity_values[k]
 
@@ -860,7 +862,7 @@ def measure_at_position(pos, mode, return_measurements=False, threads=1):
         return None
 
 
-def local_normalisation(image, labels, background_intensity, mode, operation):
+def local_normalisation(image, labels, background_intensity, measurement='intensity_median', operation='subtract', clip=False):
     """
      Perform local normalization on an image based on labels.
 
@@ -900,19 +902,23 @@ def local_normalisation(image, labels, background_intensity, mode, operation):
        based on the mode specified.
      - The background intensity values should be provided in the same order as the labels.
      """
+    
     for index, cell in enumerate(np.unique(labels)):
         if cell == 0:
             continue
-        if operation == 'Subtract':
+        if operation == 'subtract':
             image[np.where(labels == cell)] = image[np.where(labels == cell)].astype(float) - \
-                                              background_intensity[f'intensity_{mode.lower()}'][index-1].astype(float)
-        elif operation == 'Divide':
+                                              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_{mode.lower()}'][index-1].astype(float)
+                                              background_intensity[measurement][index-1].astype(float)
+    if clip:
+        image[image<=0.] = 0.
+
     return image.astype(float)
 
 
-def normalise_by_cell(image, labels, distance, mode, operation):
+def normalise_by_cell(image, labels, distance=5, model='median', operation='subtract', clip=False):
     """
     Normalize an image based on cell regions.
 
@@ -950,250 +956,24 @@ def normalise_by_cell(image, labels, distance, mode, operation):
     - The operation determines whether to subtract or divide the background intensity from the image.
     """
     border = contour_of_instance_segmentation(label=labels, distance=distance * (-1))
-    if mode == 'Mean':
+    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'])
-    elif mode == 'Median':
-        median = []
-        median.append(getattr(extra_properties, 'intensity_median'))
+                                                 extra_properties=extra_props)
+    elif model == '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, mode=mode,
-                                           operation=operation)
+                                           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=100)
-    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=100)
-    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"
+}