celldetective 1.4.1.post1__py3-none-any.whl → 1.5.0b0__py3-none-any.whl

celldetective/filters.py

@@ -1,155 +1,250 @@
-from skimage.filters import difference_of_gaussians, threshold_multiotsu, threshold_otsu, threshold_local, \
-	threshold_niblack, threshold_sauvola
-from celldetective.utils import interpolate_nan
-import scipy.ndimage as snd
+import numpy
+
+from celldetective.utils.image_cleaning import interpolate_nan
 import numpy as np
 
+
 def gauss_filter(img, sigma, interpolate=True, *kwargs):
+    import scipy.ndimage as snd
 
-	if np.any(img!=img) and interpolate:
-		img = interpolate_nan(img.astype(float))
+    if np.any(img != img) and interpolate:
+        img = interpolate_nan(img.astype(float))
+
+    return snd.gaussian_filter(img.astype(float), sigma, *kwargs)
 
-	return snd.gaussian_filter(img.astype(float), sigma, *kwargs)
 
 def median_filter(img, size, interpolate=True, *kwargs):
 
-	if np.any(img!=img) and interpolate:
-		img = interpolate_nan(img.astype(float))
+    if np.any(img != img) and interpolate:
+        img = interpolate_nan(img.astype(float))
+
+    size = int(size)
+
+    import scipy.ndimage as snd
+
+    return snd.median_filter(img, size, *kwargs)
 
-	size = int(size)
-	
-	return snd.median_filter(img, size, *kwargs)
 
 def maximum_filter(img, size, interpolate=True, *kwargs):
-	if np.any(img!=img) and interpolate:
-		img = interpolate_nan(img.astype(float))
+    if np.any(img != img) and interpolate:
+        img = interpolate_nan(img.astype(float))
+
+    import scipy.ndimage as snd
+
+    return snd.maximum_filter(img.astype(float), size, *kwargs)
 
-	return snd.maximum_filter(img.astype(float), size, *kwargs)
 
 def minimum_filter(img, size, interpolate=True, *kwargs):
-	if np.any(img!=img) and interpolate:
-		img = interpolate_nan(img.astype(float))
+    if np.any(img != img) and interpolate:
+        img = interpolate_nan(img.astype(float))
+
+    import scipy.ndimage as snd
+
+    return snd.minimum_filter(img.astype(float), size, *kwargs)
 
-	return snd.minimum_filter(img.astype(float), size, *kwargs)
 
 def percentile_filter(img, percentile, size, interpolate=True, *kwargs):
-	if np.any(img!=img) and interpolate:
-		img = interpolate_nan(img.astype(float))
+    if np.any(img != img) and interpolate:
+        img = interpolate_nan(img.astype(float))
+
+    import scipy.ndimage as snd
+
+    return snd.percentile_filter(img.astype(float), percentile, size, *kwargs)
 
-	return snd.percentile_filter(img.astype(float), percentile, size, *kwargs)
 
 def subtract_filter(img, value, *kwargs):
-	return img.astype(float) - value
+    return img.astype(float) - value
+
 
 def abs_filter(img, *kwargs):
-	return np.abs(img)
+    return np.abs(img)
+
 
 def ln_filter(img, interpolate=True, *kwargs):
-	if np.any(img!=img) and interpolate:
-		img = interpolate_nan(img.astype(float))
+    if np.any(img != img) and interpolate:
+        img = interpolate_nan(img.astype(float))
 
-	img[np.where(img>0.)] = np.log(img[np.where(img>0.)])
-	img[np.where(img<=0.)] = 0.
+    img[np.where(img > 0.0)] = np.log(img[np.where(img > 0.0)])
+    img[np.where(img <= 0.0)] = 0.0
+
+    return img
 
-	return img
 
 def variance_filter(img, size, interpolate=True):
 
-	if np.any(img!=img) and interpolate:
-		img = interpolate_nan(img.astype(float))
+    if np.any(img != img) and interpolate:
+        img = interpolate_nan(img.astype(float))
+
+    size = int(size)
+    img = img.astype(float)
+    import scipy.ndimage as snd
 
-	size = int(size)
-	img = img.astype(float)
-	win_mean = snd.uniform_filter(img, (size,size), mode='wrap')
-	win_sqr_mean = snd.uniform_filter(img**2, (size,size), mode='wrap')
-	img = win_sqr_mean - win_mean**2
+    win_mean = snd.uniform_filter(img, (size, size), mode="wrap")
+    win_sqr_mean = snd.uniform_filter(img**2, (size, size), mode="wrap")
+    img = win_sqr_mean - win_mean**2
+
+    return img
 
-	return img
 
 def std_filter(img, size, interpolate=True):
 
-	if np.any(img!=img) and interpolate:
-		img = interpolate_nan(img.astype(float))
-	
-	size = int(size)
-	img = img.astype(float)
-	
-	win_mean = snd.uniform_filter(img, (size,size), mode='wrap')
-	win_sqr_mean = snd.uniform_filter(img**2, (size, size), mode='wrap')
-	win_sqr_mean[win_sqr_mean<=0.] = 0. # add this to prevent sqrt from breaking
-	
-	sub = np.subtract(win_sqr_mean,win_mean**2)
-	sub[sub<=0.] = 0.
-	img = np.sqrt(sub)
-
-	return img
+    if np.any(img != img) and interpolate:
+        img = interpolate_nan(img.astype(float))
+
+    size = int(size)
+    img = img.astype(float)
+
+    import scipy.ndimage as snd
+
+    win_mean = snd.uniform_filter(img, (size, size), mode="wrap")
+    win_sqr_mean = snd.uniform_filter(img**2, (size, size), mode="wrap")
+    win_sqr_mean[win_sqr_mean <= 0.0] = 0.0  # add this to prevent sqrt from breaking
+
+    sub = np.subtract(win_sqr_mean, win_mean**2)
+    sub[sub <= 0.0] = 0.0
+    img = np.sqrt(sub)
+
+    return img
+
 
 def laplace_filter(img, output=float, interpolate=True, *kwargs):
-	if np.any(img!=img) and interpolate:
-		img = interpolate_nan(img.astype(float))
-	return snd.laplace(img.astype(float), *kwargs)
-
-def dog_filter(img, blob_size=None, sigma_low=1, sigma_high=2, interpolate=True, *kwargs):
-	
-	if np.any(img!=img) and interpolate:
-		img = interpolate_nan(img.astype(float))
-	if blob_size is not None:
-		sigma_low = 1.0 / (1.0 + np.sqrt(2)) * blob_size
-		sigma_high = np.sqrt(2)*sigma_low
-	return difference_of_gaussians(img.astype(float), sigma_low, sigma_high, *kwargs)
+    if np.any(img != img) and interpolate:
+        img = interpolate_nan(img.astype(float))
+    import scipy.ndimage as snd
+
+    return snd.laplace(img.astype(float), *kwargs)
+
+
+def dog_filter(
+    img, blob_size=None, sigma_low=1, sigma_high=2, interpolate=True, *kwargs
+):
+
+    if np.any(img != img) and interpolate:
+        img = interpolate_nan(img.astype(float))
+    if blob_size is not None:
+        sigma_low = 1.0 / (1.0 + np.sqrt(2)) * blob_size
+        sigma_high = np.sqrt(2) * sigma_low
+    from skimage.filters import difference_of_gaussians
+
+    return difference_of_gaussians(img.astype(float), sigma_low, sigma_high, *kwargs)
+
 
 def otsu_filter(img, *kwargs):
-	thresh = threshold_otsu(img.astype(float))
-	binary = img >= thresh
-	return binary.astype(float)
+    from skimage.filters import threshold_otsu
+
+    thresh = threshold_otsu(img.astype(float))
+    binary = img >= thresh
+    return binary.astype(float)
+
 
 def multiotsu_filter(img, classes=3, *kwargs):
-	thresholds = threshold_multiotsu(img, classes=classes)
-	regions = np.digitize(img, bins=thresholds)
-	return regions.astype(float)
-	
+    from skimage.filters import threshold_multiotsu
+
+    thresholds = threshold_multiotsu(img, classes=classes)
+    regions = np.digitize(img, bins=thresholds)
+    return regions.astype(float)
+
+
 def local_filter(img, *kwargs):
-	thresh = threshold_local(img.astype(float), *kwargs)
-	binary = img >= thresh
-	return binary.astype(float)
+    from skimage.filters import threshold_local
+
+    thresh = threshold_local(img.astype(float), *kwargs)
+    binary = img >= thresh
+    return binary.astype(float)
+
 
 def niblack_filter(img, *kwargs):
 
-	thresh = threshold_niblack(img, *kwargs)
-	binary = img >= thresh
-	return binary.astype(float)
+    from skimage.filters import threshold_niblack
+
+    thresh = threshold_niblack(img, *kwargs)
+    binary = img >= thresh
+    return binary.astype(float)
+
 
 def sauvola_filter(img, *kwargs):
 
-	thresh = threshold_sauvola(img, *kwargs)
-	binary = img >= thresh
-	return binary.astype(float)
+    from skimage.filters import threshold_sauvola
+
+    thresh = threshold_sauvola(img, *kwargs)
+    binary = img >= thresh
+    return binary.astype(float)
+
 
 def log_filter(img, blob_size=None, sigma=1, interpolate=True, *kwargs):
 
-	if np.any(img!=img) and interpolate:
-		img = interpolate_nan(img.astype(float))
-	if blob_size is not None:
-		sigma_low = 1.0 / (1.0 + np.sqrt(2)) * blob_size
-		sigma_high = np.sqrt(2)*sigma_low
+    if np.any(img != img) and interpolate:
+        img = interpolate_nan(img.astype(float))
+    if blob_size is not None:
+        sigma_low = 1.0 / (1.0 + np.sqrt(2)) * blob_size
+        sigma_high = np.sqrt(2) * sigma_low
+
+    import scipy.ndimage as snd
+
+    return snd.gaussian_laplace(img.astype(float), sigma, *kwargs)
 
-	return snd.gaussian_laplace(img.astype(float), sigma, *kwargs)
 
 def tophat_filter(img, size, connectivity=4, interpolate=True, *kwargs):
-	
-	if np.any(img!=img) and interpolate:
-		img = interpolate_nan(img.astype(float))
-	structure = snd.generate_binary_structure(rank=2, connectivity=connectivity)
-	img = snd.white_tophat(img.astype(float), structure=structure, size=size, *kwargs)
-	return img
+
+    if np.any(img != img) and interpolate:
+        img = interpolate_nan(img.astype(float))
+    import scipy.ndimage as snd
+
+    structure = snd.generate_binary_structure(rank=2, connectivity=connectivity)
+    img = snd.white_tophat(img.astype(float), structure=structure, size=size, *kwargs)
+    return img
+
 
 def invert_filter(img, value=65535, *kwargs):
-	
-	img = img.astype(float)
 
-	image_fill = np.zeros_like(img)
-	image_fill[:,:] = value
+    img = img.astype(float)
+
+    image_fill = np.zeros_like(img)
+    image_fill[:, :] = value
+
+    inverted = np.subtract(image_fill, img, where=img == img)
+    return inverted
+
+
+def filter_image(img, filters=None):
+    """
+
+    Apply one or more image filters to the input image.
+
+    Parameters
+    ----------
+    img : ndarray
+            The input image to be filtered.
+    filters : list or None, optional
+            A list of filters to be applied to the image. Each filter is represented as a tuple or list with the first element being
+            the filter function name (minus the '_filter' extension, as listed in software.filters) and the subsequent elements being
+            the arguments for that filter function. If None, the original image is returned without any filtering applied. Default is None.
+
+    Returns
+    -------
+    ndarray
+            The filtered image.
+
+    Notes
+    -----
+    This function applies a series of image filters to the input image. The filters are specified as a list of tuples,
+    where each tuple contains the name of the filter function and its corresponding arguments. The filters are applied
+    sequentially to the image. If no filters are provided, the original image is returned unchanged.
+
+    Examples
+    --------
+    >>> image = np.random.rand(256, 256)
+    >>> filtered_image = filter_image(image, filters=[('gaussian', 3), ('median', 5)])
+
+    """
+
+    if filters is None:
+        return img
 
-	inverted = np.subtract(image_fill, img, where=img==img)
-	return inverted
+    if img.ndim == 3:
+        img = np.squeeze(img)
 
+    for f in filters:
+        func = eval(f[0] + "_filter")
+        img = func(img, *f[1:])
+    return img