DiSTNet2D 0.2.2__tar.gz → 0.2.3__tar.gz

{distnet2d-0.2.2 → distnet2d-0.2.3}/DiSTNet2D.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: DiSTNet2D
-Version: 0.2.2
+Version: 0.2.3
 Summary: tensorflow/keras implementation of DiSTNet 2D
 Home-page: https://github.com/jeanollion/distnet2d
-Download-URL: https://github.com/jeanollion/distnet2d/releases/download/v0.2.2/distnet2d-0.2.2.tar.gz
+Download-URL: https://github.com/jeanollion/distnet2d/releases/download/v0.2.3/distnet2d-0.2.3.tar.gz
 Author: Jean Ollion
 Author-email: jean.ollion@sabilab.fr
 Keywords: Segmentation,Tracking,Cell,Tensorflow,Keras

{distnet2d-0.2.2 → distnet2d-0.2.3}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: DiSTNet2D
-Version: 0.2.2
+Version: 0.2.3
 Summary: tensorflow/keras implementation of DiSTNet 2D
 Home-page: https://github.com/jeanollion/distnet2d
-Download-URL: https://github.com/jeanollion/distnet2d/releases/download/v0.2.2/distnet2d-0.2.2.tar.gz
+Download-URL: https://github.com/jeanollion/distnet2d/releases/download/v0.2.3/distnet2d-0.2.3.tar.gz
 Author: Jean Ollion
 Author-email: jean.ollion@sabilab.fr
 Keywords: Segmentation,Tracking,Cell,Tensorflow,Keras

{distnet2d-0.2.2 → distnet2d-0.2.3}/distnet_2d/utils/metrics_tf.py

@@ -1,16 +1,16 @@
 import tensorflow as tf
 from .objectwise_computation_tf import get_max_by_object_fun, coord_distance_fun, get_argmax_2d_by_object_fun, \
     get_mean_by_object_fun, get_label_size, IoU, objectwise_compute, objectwise_compute_channel, reduce_pop_size, \
-    FPR
+    FP
 
 
-def get_metrics_fun(center_scale: float, max_objects_number: int = 0, category:bool = False, tracking:bool=True):
+def get_metrics_fun(scale: float, max_objects_number: int = 0, category:bool = False, tracking:bool=True):
     """
     return metric function for disnet2D
     assumes iterator in return_central_only= True mode (thus framewindow = 1 and next = true)
     Parameters
     ----------
-    center_scale
+    scale
     max_objects_number
     reduce
 
@@ -19,7 +19,6 @@ def get_metrics_fun(center_scale: float, max_objects_number: int = 0, category:b
 
     """
 
-    scale = tf.cast(center_scale, tf.float32)
     coord_distance_function = coord_distance_fun(max=True, sqrt=True, pop_fraction=0.25)
     spa_max_fun = get_argmax_2d_by_object_fun()
     mean_fun = get_mean_by_object_fun()
@@ -41,7 +40,7 @@ def get_metrics_fun(center_scale: float, max_objects_number: int = 0, category:b
         labels = tf.transpose(labels, perm=[2, 0, 1])  # (1, Y, X)
         edm = tf.transpose(edm, perm=[2, 0, 1]) # (1, Y, X)
         gdcm = tf.transpose(gdcm, perm=[2, 0, 1])  # (1, Y, X)
-        center_values = tf.math.exp(-tf.math.square(tf.math.divide(gdcm, scale)))
+        center_values = tf.math.exp(-tf.math.square(tf.math.divide(gdcm, tf.cast(scale/2., tf.float32))))
         ids, sizes, N = get_label_size(labels, max_objects_number)  # (1, N), (1, N)
         ids = ids[0]
         sizes = sizes[0]
@@ -61,14 +60,14 @@ def get_metrics_fun(center_scale: float, max_objects_number: int = 0, category:b
         metrics = []
 
         # EDM : foreground/background IoU
-        pred_foreground = tf.math.greater(edm, tf.cast(0.5, edm.dtype))
+        pred_foreground = tf.math.greater(edm, tf.cast(0, edm.dtype))
         true_foreground = tf.math.greater(labels, tf.cast(0, labels.dtype))
-        edm_IoU = IoU(true_foreground, pred_foreground, tolerance=False)
+        edm_IoU = IoU(true_foreground, pred_foreground, tolerance_radius=scale / 8.) #
         metrics.append(edm_IoU)
 
-        # Surface-based False Positive Rate (FPR) based on EDM
-        #fpr = FPR(true_foreground, pred_foreground, tolerance=True)
-        #metrics.append(-fpr)
+        # Surface-based False Positive Density (FPD) based on EDM
+        fp = FP(true_foreground, pred_foreground, rate=False, tolerance_radius=scale / 4.) #
+        metrics.append(-fp)
 
         # contour IoU : problem: true positive contours are usually not precise enough.
         #pred_contours = tf.math.logical_and(tf.math.greater(edm, tf.cast(0.5, edm.dtype)), tf.math.less_equal(edm, tf.cast(1.5, edm.dtype)))

{distnet2d-0.2.2 → distnet2d-0.2.3}/distnet_2d/utils/objectwise_computation_tf.py

@@ -211,32 +211,71 @@ def _generate_kernel(sizeY, sizeX, C=1, O=0):
     return kernel
 
 
-def IoU(true_foreground, pred_foreground, tolerance:bool=False):
-    true_inter = _dilate_mask(true_foreground) if tolerance else true_foreground
+def IoU(true_foreground, pred_foreground, tolerance_radius:float=0):
+    true_inter = _dilate_mask(true_foreground, radius=tolerance_radius, symmetric_padding=True) if tolerance_radius>=1 else true_foreground
     intersection = tf.math.count_nonzero(tf.math.logical_and(true_inter, pred_foreground), keepdims=False)
     union = tf.math.count_nonzero(tf.math.logical_or(true_foreground, pred_foreground), keepdims=False)
     return tf.cond(tf.math.equal(union, tf.cast(0, union.dtype)), lambda: tf.cast(1., tf.float32), lambda: tf.math.divide(tf.cast(intersection, tf.float32), tf.cast(union, tf.float32)))  # if union is null -> metric is 1
 
 
-def FPR(true_foreground, pred_foreground, tolerance:bool=False):
+def FP(true_foreground, pred_foreground, rate:bool = False, tolerance_radius:float=0):
     true_background = tf.math.logical_not(true_foreground)
     false_positives = tf.logical_and(pred_foreground, true_background)
-    false_positives = _erode_mask(false_positives) if tolerance else false_positives
-    num_fp = tf.reduce_sum(tf.cast(false_positives, tf.float32))
-    num_tn = tf.reduce_sum(tf.cast(true_background, tf.float32))
-    return tf.math.divide_no_nan(num_fp, num_tn)
+    false_positives = _erode_mask(false_positives, radius=tolerance_radius, symmetric_padding=False) if tolerance_radius>=1 else false_positives
+    fp = tf.math.count_nonzero(false_positives, keepdims=False)
+    if rate: # FPR
+        tn = tf.math.count_nonzero(true_background, keepdims=False) # for FRP
+        return tf.math.divide_no_nan(tf.cast(fp, tf.float32), tf.cast(tn, tf.float32))
+    else: # FPD
+        #return tf.cast(fp, tf.float32)
+        npix = tf.reduce_prod(tf.shape(true_background)) # for FPD
+        return tf.math.divide(tf.cast(fp, tf.float32), tf.cast(npix, tf.float32))
+
+
+def _dilate_mask(maskBYX, radius:float=1.5, tolerance:float=0.25, symmetric_padding:bool=True):
+    assert 0<=tolerance<0.5
+    maskBYX = tf.cast(maskBYX, tf.int32)
+    ker, rad = circular_kernel(radius)
+    thld = tf.math.floor(tf.cast(tf.math.reduce_sum(ker), tf.float32) * tf.cast(tolerance, tf.float32))
+    conv = _convolve(maskBYX, ker, rad, symmetric_padding=symmetric_padding)
+    return tf.math.greater(conv, tf.cast(thld, tf.int32))
 
 
-def _dilate_mask(maskBYX):
+def _erode_mask(maskBYX, radius:float=1.5, tolerance:float=0.25, symmetric_padding:bool=False):
+    assert 0 <= tolerance < 0.5
     maskBYX = tf.cast(maskBYX, tf.int32)
-    conv = _convolve(maskBYX, tf.ones(shape=[3, 3], dtype=tf.int32))
-    return tf.math.greater(conv, tf.cast(2, tf.int32))
+    ker, rad = circular_kernel(radius)
+    thld = tf.math.ceil(tf.cast(tf.math.reduce_sum(ker), tf.float32) * tf.cast(1 - tolerance, tf.float32))
+    conv = _convolve(maskBYX, ker, rad, symmetric_padding=symmetric_padding)
+    return tf.math.greater_equal(conv, tf.cast(thld, tf.int32))
 
 
-def _erode_mask(maskBYX):
-    maskBYX = tf.cast(maskBYX, tf.int32)
-    conv = _convolve(maskBYX, tf.ones(shape=[3, 3], dtype=tf.int32))
-    return tf.math.greater_equal(conv, tf.cast(7, tf.int32))
+
+def circular_kernel(radius: float) :
+    """
+    Create a circular 2D kernel of ones with a given float radius.
+    Args:
+        radius: The radius of the circle (float).
+    Returns:
+        A 2D TensorFlow tensor representing the circular kernel (dtype: tf.int32).
+    """
+    radius_int = tf.cast(radius, tf.int32)
+    diameter = tf.cast(2 * radius_int + 1, tf.int32)
+    center = diameter // 2
+
+    # Create a grid of coordinates
+    y = tf.range(-center, diameter - center, dtype=tf.float32)
+    x = tf.range(-center, diameter - center, dtype=tf.float32)
+    y_grid, x_grid = tf.meshgrid(y, x, indexing='ij')
+
+    # Compute the distance from the center
+    distance = tf.math.sqrt(x_grid**2 + y_grid**2)
+
+    # Create the circular kernel
+    kernel = tf.zeros((diameter, diameter), dtype=tf.int32)
+    kernel = tf.where(distance <= radius, tf.ones_like(kernel, dtype=tf.int32), kernel)
+
+    return kernel, radius_int
 
 
 def _contour_IoU_fun(pred_contour, mask, size):
@@ -245,13 +284,15 @@ def _contour_IoU_fun(pred_contour, mask, size):
 
 
 def _compute_contours(maskBYX):
-    kernel = [[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]]
-    conv = _convolve(maskBYX, kernel)
-    return tf.math.greater(conv, 0) # detect at least one zero in the neighborhood
+    kernel = np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]])
+    conv = _convolve(maskBYX, kernel, 1, symmetric_padding=True)
+    return tf.math.greater(conv, tf.cast(0, conv.dtype)) # detect at least one zero in the neighborhood
 
 
-def _convolve(imageBYX, kernel):
-    padded = tf.pad(imageBYX, [[0, 0], [1, 1], [1, 1]], 'SYMMETRIC')
-    input = padded[..., tf.newaxis]
-    conv = tf.nn.conv2d(input, kernel[:, :, tf.newaxis, tf.newaxis], strides=1, padding='VALID')
+def _convolve(imageBYX, kernel, radius, symmetric_padding:bool):
+    if symmetric_padding:
+        imageBYX = tf.pad(imageBYX, [[0, 0], [radius, radius], [radius, radius]], 'SYMMETRIC')
+    imageBYX = imageBYX[..., tf.newaxis]
+    kernel = tf.cast(kernel, imageBYX.dtype)
+    conv = tf.nn.conv2d(imageBYX, kernel[:, :, tf.newaxis, tf.newaxis], strides=1, padding='VALID' if symmetric_padding else "SAME")
     return conv[..., 0]

{distnet2d-0.2.2 → distnet2d-0.2.3}/setup.py

@@ -5,14 +5,14 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="DiSTNet2D",
-    version="0.2.2",
+    version="0.2.3",
     author="Jean Ollion",
     author_email="jean.ollion@sabilab.fr",
     description="tensorflow/keras implementation of DiSTNet 2D",
     long_description=long_description,
     long_description_content_type="text/markdown",
     url="https://github.com/jeanollion/distnet2d",
-    download_url='https://github.com/jeanollion/distnet2d/releases/download/v0.2.2/distnet2d-0.2.2.tar.gz',
+    download_url='https://github.com/jeanollion/distnet2d/releases/download/v0.2.3/distnet2d-0.2.3.tar.gz',
     packages=setuptools.find_packages(),
     keywords=['Segmentation', 'Tracking', 'Cell', 'Tensorflow', 'Keras'],
     classifiers=[