cellprofiler-library-nightly 5.0.0.dev332__tar.gz → 5.0.0.dev336__tar.gz

{cellprofiler_library_nightly-5.0.0.dev332 → cellprofiler_library_nightly-5.0.0.dev336}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev332
+Version: 5.0.0.dev336
 Summary: cellprofiler-library implements CellProfiler's image processing and mathematical code, and is usable as a standalone library
 Author: Anne Carpenter, Thouis (Ray) Jones, Lee Kamentsky, Vebjorn Ljosa, David Logan, Mark Bray, Madison Swain-Bowden, Allen Goodman, Claire McQuinn, Alice Lucas, Callum Tromans-Coia
 Author-email: Beth Cimini <bcimini@broadinstitute.org>, David Stirling <dstirling@glencoesoftware.com>, Nodar Gogoberidze <ngogober@broadinstitute.org>

{cellprofiler_library_nightly-5.0.0.dev332 → cellprofiler_library_nightly-5.0.0.dev336}/cellprofiler_library/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '5.0.0.dev332'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev332')
+__version__ = version = '5.0.0.dev336'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev336')
 
-__commit_id__ = commit_id = 'g13c77e82d'
+__commit_id__ = commit_id = 'g144173d3c'

{cellprofiler_library_nightly-5.0.0.dev332 → cellprofiler_library_nightly-5.0.0.dev336}/cellprofiler_library/functions/image_processing.py

@@ -6,12 +6,17 @@ import centrosome.threshold
 import scipy
 import matplotlib
 import math
-from typing import Any, Optional, Tuple, Callable, Union, List
-from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask, Image2DColor, Image2DGrayscale, ImageAny, ObjectSegmentation, Image2D, Image2DMask, StructuringElement
+from numpy.typing import NDArray
+import centrosome.filter
+from typing import Any, Optional, Tuple, Callable, Union, List, TypeVar
+from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask, Image2DColor, Image2DGrayscale, ImageAny, ImageAnyMask, ObjectSegmentation, Image2D, Image2DMask, StructuringElement
 from cellprofiler_library.opts import threshold as Threshold
+from cellprofiler_library.opts.enhanceorsuppressfeatures import SpeckleAccuracy, NeuriteMethod
 from cellprofiler_library.opts.crop import RemovalMethod
 from cellprofiler_library.opts.structuring_elements import StructuringElementShape2D, StructuringElementShape3D
 
+T = TypeVar("T", bound=ImageAny)
+
 def rgb_to_greyscale(image):
     if image.shape[-1] == 4:
         output = skimage.color.rgba2rgb(image)
@@ -924,3 +929,202 @@ def erase_pixels(
     else:
         cropped_pixel_data[~crop] = 0
     return cropped_pixel_data
+
+
+###############################################################################
+# EnhanceOrSuppressFeatures
+###############################################################################
+
+def __mask(
+        pixel_data: T,
+        mask:       ImageAnyMask,
+        ) -> T:
+    data = numpy.zeros_like(pixel_data)
+    data[mask] = pixel_data[mask]
+    return data
+
+def __unmask(
+        data:       T,
+        pixel_data: T, 
+        mask:       ImageAnyMask,
+        ) -> T:
+    data[~mask] = pixel_data[~mask]
+    return data
+
+def __structuring_element(
+        radius, 
+        volumetric
+        ) -> NDArray[numpy.uint8]:
+    if volumetric:
+        return skimage.morphology.ball(radius)
+
+    return skimage.morphology.disk(radius)
+
+
+def enhance_speckles(
+        im_pixel_data:  ImageGrayscale,
+        im_mask:        ImageGrayscaleMask,
+        im_volumetric:  bool,
+        radius:         float,
+        accuracy:       SpeckleAccuracy,
+        ) -> ImageGrayscale:
+    data = __mask(im_pixel_data, im_mask)
+    footprint = __structuring_element(radius, im_volumetric)
+
+    if accuracy == SpeckleAccuracy.SLOW or radius <= 3:
+        result = skimage.morphology.white_tophat(data, footprint=footprint)
+    else:
+        #
+        # white_tophat = img - opening
+        #              = img - dilate(erode)
+        #              = img - maximum_filter(minimum_filter)
+        #
+        minimum = scipy.ndimage.filters.minimum_filter(data, footprint=footprint)
+        maximum = scipy.ndimage.filters.maximum_filter(minimum, footprint=footprint)
+        result = data - maximum
+        
+    return __unmask(result, im_pixel_data, im_mask)
+
+
+def enhance_neurites(
+        im_pixel_data:      ImageGrayscale,
+        im_mask:            ImageGrayscaleMask,
+        im_volumetric:      bool,
+        im_spacing:         Tuple[float, ...],
+        smoothing_value:    float,
+        radius:             float,
+        method:             NeuriteMethod,
+        neurite_rescale:    bool,
+        ) -> ImageGrayscale:
+    data = __mask(im_pixel_data, im_mask)
+
+    if method == NeuriteMethod.GRADIENT:
+        # desired effect = img + white_tophat - black_tophat
+        footprint = __structuring_element(radius, im_volumetric)
+        white = skimage.morphology.white_tophat(data, footprint=footprint)
+        black = skimage.morphology.black_tophat(data, footprint=footprint)
+        result = data + white - black
+        result[result > 1] = 1
+        result[result < 0] = 0
+    else:
+        sigma = smoothing_value
+        smoothed = scipy.ndimage.gaussian_filter(data, numpy.divide(sigma, im_spacing))
+
+        if im_volumetric:
+            result = numpy.zeros_like(smoothed)
+            for index, plane in enumerate(smoothed):
+                hessian = centrosome.filter.hessian(plane, return_hessian=False, return_eigenvectors=False)
+                result[index] = (-hessian[:, :, 0] * (hessian[:, :, 0] < 0) * (sigma ** 2))
+        else:
+            hessian = centrosome.filter.hessian(smoothed, return_hessian=False, return_eigenvectors=False)
+            #
+            # The positive values are darker pixels with lighter
+            # neighbors. The original ImageJ code scales the result
+            # by sigma squared - I have a feeling this might be
+            # a first-order correction for e**(-2*sigma), possibly
+            # because the hessian is taken from one pixel away
+            # and the gradient is less as sigma gets larger.
+            #
+            result = -hessian[:, :, 0] * (hessian[:, :, 0] < 0) * (sigma ** 2)
+            
+    result = __unmask(result, im_pixel_data, im_mask)
+    if neurite_rescale:
+        result = skimage.exposure.rescale_intensity(result)
+    return result
+
+
+def enhance_circles(
+        im_pixel_data:  ImageGrayscale,
+        im_mask:        ImageGrayscaleMask,
+        im_volumetric:  bool,
+        radius:         float,
+        ) -> ImageGrayscale:
+    data = __mask(im_pixel_data, im_mask)
+    if im_volumetric:
+        result = numpy.zeros_like(data)
+        for index, plane in enumerate(data):
+            result[index] = skimage.transform.hough_circle(plane, radius)[0]
+    else:
+        result = skimage.transform.hough_circle(data, radius)[0]
+    return __unmask(result, im_pixel_data, im_mask)
+
+
+def enhance_texture(
+        im_pixel_data:  ImageGrayscale,
+        im_mask:        ImageGrayscaleMask,
+        sigma:          float,
+        ) -> ImageGrayscale:
+    mask = im_mask
+    data = __mask(im_pixel_data, mask)
+    gmask = skimage.filters.gaussian(mask.astype(float), sigma, mode="constant")
+    img_mean = (skimage.filters.gaussian(data, sigma, mode="constant") / gmask)
+    img_squared = (skimage.filters.gaussian(data ** 2, sigma, mode="constant")/ gmask)
+    result = img_squared - img_mean ** 2
+    return __unmask(result, im_pixel_data, mask)
+
+
+def enhance_dark_holes(
+        im_pixel_data:          ImageGrayscale,
+        im_mask:                ImageGrayscaleMask,
+        im_volumetric:          bool,
+        dark_hole_radius_min:   int,
+        dark_hole_radius_max:   int,
+        min_radius:             Optional[int] = None,
+        max_radius:             Optional[int] = None,
+        ) -> ImageGrayscale:
+    if min_radius is None:
+        min_radius = max(1, int(dark_hole_radius_min / 2))
+    if max_radius is None:
+        max_radius = int((dark_hole_radius_max + 1) / 2)
+
+    pixel_data = im_pixel_data
+    mask = im_mask
+    se = __structuring_element(1, im_volumetric)
+    inverted_image = pixel_data.max() - pixel_data
+    previous_reconstructed_image = inverted_image
+    eroded_image = inverted_image
+    smoothed_image = numpy.zeros(pixel_data.shape)
+
+    for i in range(max_radius + 1):
+        eroded_image = skimage.morphology.erosion(eroded_image, se)
+        if mask is not None:
+            eroded_image *= mask
+        reconstructed_image = skimage.morphology.reconstruction(eroded_image, inverted_image, "dilation", se)
+        output_image = previous_reconstructed_image - reconstructed_image
+        if i >= min_radius:
+            smoothed_image = numpy.maximum(smoothed_image, output_image)
+        previous_reconstructed_image = reconstructed_image
+    return smoothed_image
+
+
+def enhance_dic(
+        im_pixel_data:  ImageGrayscale,
+        im_volumetric:  bool,
+        angle:          float,
+        decay:          float,
+        smoothing:      float,
+        ) -> ImageGrayscale:
+    pixel_data = im_pixel_data
+
+    if im_volumetric:
+        result = numpy.zeros_like(pixel_data).astype(numpy.float64)
+        for index, plane in enumerate(pixel_data):
+            result[index] = centrosome.filter.line_integration(plane, angle, decay, smoothing)
+        return result
+
+    if smoothing == 0:
+        smoothing = float(numpy.finfo(float).eps)
+
+    return centrosome.filter.line_integration(pixel_data, angle, decay, smoothing)
+
+
+def suppress(
+        im_pixel_data:  ImageGrayscale, 
+        im_mask:        ImageGrayscaleMask,
+        im_volumetric:  bool,
+        radius:         float,
+        ) -> ImageGrayscale:
+    data = __mask(im_pixel_data, im_mask)
+    footprint = __structuring_element(radius, im_volumetric)
+    result = skimage.morphology.opening(data, footprint)
+    return __unmask(result, im_pixel_data, im_mask)

cellprofiler_library_nightly-5.0.0.dev336/cellprofiler_library/modules/_enhanceorsuppressfeatures.py

@@ -0,0 +1,55 @@
+from cellprofiler_library.functions.image_processing import enhance_speckles, enhance_neurites, enhance_circles, enhance_texture, enhance_dark_holes, enhance_dic, suppress
+from pydantic import Field, ConfigDict, validate_call
+from typing import Annotated
+from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask
+from ..opts.enhanceorsuppressfeatures import OperationMethod, EnhanceMethod, SpeckleAccuracy, NeuriteMethod
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def enhance_or_suppress_features(
+        im_pixel_data:          Annotated[ImageGrayscale, Field(description="Image pixel data")],  
+        im_mask:                Annotated[ImageGrayscaleMask, Field(description="Image mask")],
+        im_volumetric:          Annotated[bool, Field(description="Image is volumetric")] = False,
+        im_spacing:             Annotated[tuple[float, ...], Field(description="Image spacing")] = (1.0, 1.0, 1.0),
+        radius:                 Annotated[float, Field(description="Feature size")] = 10,
+        method:                 Annotated[OperationMethod, Field(description="Operation method")] = OperationMethod.ENHANCE,
+        enhance_method:         Annotated[EnhanceMethod, Field(description="Feature type")] = EnhanceMethod.SPECKLES,
+        speckle_accuracy:       Annotated[SpeckleAccuracy, Field(description="Speed and accuracy")] = SpeckleAccuracy.FAST,
+        neurite_choice:         Annotated[NeuriteMethod, Field(description="Neurite choice")] = NeuriteMethod.GRADIENT,
+        neurite_rescale:        Annotated[bool, Field(description="Rescale result image")] = False,
+        dark_hole_radius_min:   Annotated[int, Field(description="Dark hole radius min")] = 1,
+        dark_hole_radius_max:   Annotated[int, Field(description="Dark hole radius max")] = 10,
+        smoothing_value:        Annotated[float, Field(description="Smoothing value")] = 2.0,
+        dic_angle:              Annotated[float, Field(description="Angle")] = 0.0,
+        dic_decay:              Annotated[float, Field(description="Decay")] = 0.95,
+        ) -> ImageGrayscale:
+    if method == OperationMethod.ENHANCE:
+        if enhance_method == EnhanceMethod.SPECKLES:
+            result = enhance_speckles(im_pixel_data, im_mask, im_volumetric, radius, speckle_accuracy)
+
+        elif enhance_method == EnhanceMethod.NEURITES:
+            result = enhance_neurites(im_pixel_data, im_mask, im_volumetric, im_spacing, smoothing_value, radius, neurite_choice, neurite_rescale)
+            
+        elif enhance_method == EnhanceMethod.DARK_HOLES:
+            result = enhance_dark_holes(im_pixel_data, im_mask, im_volumetric, dark_hole_radius_min, dark_hole_radius_max)
+
+        elif enhance_method == EnhanceMethod.CIRCLES:
+            result = enhance_circles(im_pixel_data, im_mask, im_volumetric, radius)
+
+        elif enhance_method == EnhanceMethod.TEXTURE:
+            result = enhance_texture(im_pixel_data, im_mask, smoothing_value)
+
+        elif enhance_method == EnhanceMethod.DIC:
+            result = enhance_dic(im_pixel_data, im_volumetric, dic_angle, dic_decay, smoothing_value)
+        
+        else:
+            raise NotImplementedError("Unimplemented enhance method: %s" % enhance_method)
+        
+    elif method == OperationMethod.SUPPRESS:
+        result = suppress(im_pixel_data, im_mask, im_volumetric, radius)
+
+    else:
+        raise ValueError("Unknown filtering method: %s" % method)
+    
+    return result
+
+

cellprofiler_library_nightly-5.0.0.dev336/cellprofiler_library/opts/enhanceorsuppressfeatures.py

@@ -0,0 +1,21 @@
+from enum import Enum
+
+class OperationMethod(str, Enum):
+    ENHANCE = "Enhance"
+    SUPPRESS = "Suppress"
+
+class EnhanceMethod(str, Enum):
+    SPECKLES = "Speckles"
+    NEURITES = "Neurites"
+    DARK_HOLES = "Dark holes"
+    CIRCLES = "Circles"
+    TEXTURE = "Texture"
+    DIC = "DIC"
+
+class SpeckleAccuracy(str, Enum):
+    SLOW = "Slow"
+    FAST = "Fast"
+
+class NeuriteMethod(str, Enum):
+    GRADIENT = "Line structures"
+    TUBENESS = "Tubeness"

{cellprofiler_library_nightly-5.0.0.dev332 → cellprofiler_library_nightly-5.0.0.dev336}/cellprofiler_library_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev332
+Version: 5.0.0.dev336
 Summary: cellprofiler-library implements CellProfiler's image processing and mathematical code, and is usable as a standalone library
 Author: Anne Carpenter, Thouis (Ray) Jones, Lee Kamentsky, Vebjorn Ljosa, David Logan, Mark Bray, Madison Swain-Bowden, Allen Goodman, Claire McQuinn, Alice Lucas, Callum Tromans-Coia
 Author-email: Beth Cimini <bcimini@broadinstitute.org>, David Stirling <dstirling@glencoesoftware.com>, Nodar Gogoberidze <ngogober@broadinstitute.org>

{cellprofiler_library_nightly-5.0.0.dev332 → cellprofiler_library_nightly-5.0.0.dev336}/cellprofiler_library_nightly.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ cellprofiler_library/modules/_correctilluminationapply.py
 cellprofiler_library/modules/_crop.py
 cellprofiler_library/modules/_dilateimage.py
 cellprofiler_library/modules/_enhanceedges.py
+cellprofiler_library/modules/_enhanceorsuppressfeatures.py
 cellprofiler_library/modules/_erodeimage.py
 cellprofiler_library/modules/_erodeobjects.py
 cellprofiler_library/modules/_expandorshrinkobjects.py
@@ -45,6 +46,7 @@ cellprofiler_library/opts/convertobjectstoimage.py
 cellprofiler_library/opts/correctilluminationapply.py
 cellprofiler_library/opts/crop.py
 cellprofiler_library/opts/dilateimage.py
+cellprofiler_library/opts/enhanceorsuppressfeatures.py
 cellprofiler_library/opts/erodeimage.py
 cellprofiler_library/opts/erodeobjects.py
 cellprofiler_library/opts/measureimageoverlap.py