cellprofiler-library-nightly 5.0.0.dev475__tar.gz → 5.0.0.dev496__tar.gz

{cellprofiler_library_nightly-5.0.0.dev475 → cellprofiler_library_nightly-5.0.0.dev496}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev475
+Version: 5.0.0.dev496
 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.dev475 → cellprofiler_library_nightly-5.0.0.dev496}/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.dev475'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev475')
+__version__ = version = '5.0.0.dev496'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev496')
 
-__commit_id__ = commit_id = 'gc4686c345'
+__commit_id__ = commit_id = 'g8d098d2ce'

{cellprofiler_library_nightly-5.0.0.dev475 → cellprofiler_library_nightly-5.0.0.dev496}/cellprofiler_library/functions/image_processing.py

@@ -15,9 +15,19 @@ import scipy
 import scipy.interpolate
 import matplotlib
 import math
+from centrosome.cpmorphology import fixup_scipy_ndimage_result as fix
 from typing import Any, Optional, Tuple, Callable, Union, List, cast, Dict, TypeVar
 from numpy.typing import NDArray
-from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask, Image2DColor, Image2DGrayscale, Image2DGrayscaleMask, ImageAny, ImageAnyMask, ObjectSegmentation, Image2D, Image2DMask, StructuringElement, ObjectLabelSet, ImageColor, ImageBinaryMask
+from skimage.restoration import denoise_bilateral
+from cellprofiler_library.types import (
+    ImageGrayscale, ImageGrayscaleMask, 
+    Image2DColor, 
+    Image2DGrayscale, Image2DGrayscaleMask, 
+    ImageAny, ImageAnyMask, 
+    ObjectSegmentation, 
+    Image2D, Image2DMask, 
+    StructuringElement, ObjectLabelSet, ImageColor, ImageBinaryMask,
+)
 from cellprofiler_library.opts import threshold as Threshold
 from cellprofiler_library.opts.enhanceorsuppressfeatures import SpeckleAccuracy, NeuriteMethod
 from cellprofiler_library.opts.overlayoutlines import BrightnessMode
@@ -27,6 +37,7 @@ from cellprofiler_library.opts.resize import ResizingMethod, DimensionMethod, In
 from cellprofiler_library.opts.imagemath import Operator
 from cellprofiler_library.opts.flipandrotate import RotationCoordinateAlignmnet
 from cellprofiler_library.opts.enhanceedges import EdgeDirection
+
 invert = cast(Callable[[ImageAny], ImageAny], _invert)
 isscalar = cast(Callable[[Optional[ImageAny]], bool], _isscalar)
 
@@ -716,6 +727,7 @@ def get_global_threshold(
     threshold_correction_factor: float = 1,
     assign_middle_to_foreground: Threshold.Assignment = Threshold.Assignment.FOREGROUND,
     log_transform:               bool = False,
+    max_intensity_percentage:    float = 100,
     **kwargs:                    Any,
 ) -> float:
     conversion_dict = None
@@ -745,6 +757,8 @@ def get_global_threshold(
         kwargs["nbins"] = kwargs.get("nbins", 128)
         threshold = skimage.filters.threshold_multiotsu(image, **kwargs)
         threshold = threshold[bin_wanted]
+    elif threshold_method.casefold() == Threshold.Method.MAX_INTENSITY_PERCENTAGE:
+        threshold = max_intensity_percentage * numpy.max(image) / 100
     else:
         raise NotImplementedError(f"Threshold method {threshold_method} not supported.")
 
@@ -976,10 +990,10 @@ def get_rectangle_cropping(
 
 
 def crop_image(
-        image:          Union[Image2D, Image2DMask],
-        crop_mask:      Image2DMask,
+        image:          Union[ImageAny, ImageAnyMask],
+        crop_mask:      ImageAnyMask,
         crop_internal:  Optional[bool]=False
-    ) -> Union[Image2D, Image2DMask]:
+    ) -> Union[ImageAny, ImageAnyMask]:
     """Crop an image to the size of the nonzero portion of a crop mask"""
     i_histogram = crop_mask.sum(axis=1)
     i_cumsum = numpy.cumsum(i_histogram != 0)
@@ -2068,3 +2082,120 @@ def rotate_image_coordinates(pixel_data: Image2D, mask: Image2DMask, rotate_poin
             "Unknown axis: %s" % rotate_coordinate_alignment.value
         )
     return angle
+
+
+###############################################################################
+# Smoothing
+###############################################################################
+
+def smoothing_gaussian(pixel_data: Image2D, mask: Optional[Image2DMask], sigma: float) -> Image2D:
+    def fn(image: Image2D) -> Image2D:
+            return scipy.ndimage.gaussian_filter(
+                image, sigma, mode="constant", cval=0
+            )
+    return centrosome.smooth.smooth_with_function_and_mask(pixel_data, fn, mask)
+     
+
+def smoothing_median(pixel_data: Image2D, mask: Optional[Image2DMask], obj_size: float) -> Image2D:
+    return centrosome.filter.median_filter(pixel_data, mask, obj_size / 2 + 1)
+
+
+def smoothing_keeping_edges(pixel_data: Image2D, multichannel: bool, sigma_range: float, sigma: float) -> Image2D:
+    assert sigma_range is not None, "sigma_range must be provided for smooth_keeping_edges"
+    return denoise_bilateral(
+        image=pixel_data.astype(float),
+        channel_axis=2 if multichannel else None,
+        sigma_color=sigma_range,
+        sigma_spatial=sigma,
+    )
+
+
+def smoothing_fit_polynomial(pixel_data: Image2D, mask: Optional[Image2DMask], clip: bool) -> Image2D:
+    return centrosome.smooth.fit_polynomial(pixel_data, mask, clip)
+
+
+def smoothing_circular_average(pixel_data: Image2D, mask: Optional[Image2DMask], obj_size: float) -> Image2D:
+    return centrosome.filter.circular_average_filter(pixel_data, obj_size / 2 + 1, mask)
+
+def smoothing_smooth_to_average(pixel_data: Image2D, mask: Optional[Image2DMask]) -> Image2D:
+    if mask is not None:
+        mean = numpy.mean(pixel_data[mask])
+    else:
+        mean = numpy.mean(pixel_data)
+    return numpy.ones(pixel_data.shape, pixel_data.dtype) * mean
+
+
+################################################################################
+# MeasureColocalization
+################################################################################
+
+def crop_image_similarly(
+        this_image: ImageAny, 
+        other_image: ImageAny,
+        this_crop_mask: Optional[ImageAny] = None,
+    ):
+    """Crop a 2-d or 3-d image (other_image) using this image's crop mask
+    crop mask is the binary image used to crop the parent image to the
+    dimensions of the child (this) image. The crop_mask is the same size as
+    the parent image.
+    image - a np.ndarray to be cropped (of any type)
+    """
+    if other_image.shape[:2] == this_image.shape[:2]:
+        # Same size - no cropping needed
+        return other_image
+    if any(
+        [
+            my_size > other_size
+            for my_size, other_size in zip(this_image.shape, other_image.shape)
+        ]
+    ):
+        raise ValueError(
+            "Image to be cropped is smaller: %s vs %s"
+            % (repr(other_image.shape), repr(this_image.shape))
+        )
+    if this_crop_mask is None:
+        raise RuntimeError(
+            "Images are of different size and no crop mask available.\n"
+            "Use the Crop and Align modules to match images of different sizes."
+        )
+    cropped_image = crop_image(other_image, this_crop_mask)
+    if cropped_image.shape[0:2] != this_image.shape[0:2]:
+        raise ValueError(
+            "Cropped image is not the same size as the reference image: %s vs %s"
+            % (repr(cropped_image.shape), repr(this_image.shape))
+        )
+    return cropped_image
+
+def apply_threshold_to_objects(
+        image:              ImageGrayscale,
+        segmented:          ObjectSegmentation,
+        threshold_value:    float,
+        mask:               Optional[ImageGrayscaleMask] = None,
+        ) -> ImageGrayscaleMask:
+    output_image_arr = numpy.zeros_like(image)
+    if mask is None:
+        # Create a fake mask if one isn't provided
+        mask = numpy.full(segmented.shape, True)
+    assert (image.shape == segmented.shape)
+    mask = (segmented > 0) & mask & (~numpy.isnan(image))
+    segmented = segmented.copy()
+    segmented = segmented[mask]
+    n_objects = len(numpy.unique(segmented))
+    if (not (n_objects == 0)) and (not (numpy.where(mask)[0].__len__() == 0)):
+        #
+        # First get the maximum intensity of each object and create
+        # a 1d array of floats representing the threshold for each object
+        #
+        lrange = numpy.arange(n_objects, dtype=numpy.int32) + 1
+        # Threshold as percentage of maximum intensity of objects in each channel
+        scaled_image = (threshold_value / 100) * fix(
+            scipy.ndimage.maximum(image, segmented, lrange)
+        )
+
+        #
+        # Apply the threshold to the image
+        # Use the mask to apply to specific pixels
+        #
+        output_image_arr[mask] = (image >= scaled_image[segmented - 1])        
+
+    return output_image_arr