cellprofiler-library-nightly 5.0.0.dev416__tar.gz → 5.0.0.dev462__tar.gz

{cellprofiler_library_nightly-5.0.0.dev416 → cellprofiler_library_nightly-5.0.0.dev462}/PKG-INFO

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

{cellprofiler_library_nightly-5.0.0.dev416 → cellprofiler_library_nightly-5.0.0.dev462}/cellprofiler_library/functions/image_processing.py

@@ -1,8 +1,10 @@
 import numpy
+from numpy import isscalar as _isscalar
 import skimage.color
 import skimage.morphology
 import skimage.segmentation
 import skimage.util
+from skimage.util import invert as _invert
 import skimage.transform
 import skimage
 import skimage.restoration
@@ -13,16 +15,20 @@ import scipy
 import scipy.interpolate
 import matplotlib
 import math
+from typing import Any, Optional, Tuple, Callable, Union, List, cast, Dict, TypeVar
 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, 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
 from cellprofiler_library.opts.crop import RemovalMethod
 from cellprofiler_library.opts.structuring_elements import StructuringElementShape2D, StructuringElementShape3D
-from ..opts.resize import ResizingMethod, DimensionMethod, InterpolationMethod
+from cellprofiler_library.opts.resize import ResizingMethod, DimensionMethod, InterpolationMethod
+from cellprofiler_library.opts.imagemath import Operator
+
+# TODO: python_latest - remove this if later skimage versions update types
+invert = cast(Callable[[ImageAny], ImageAny], _invert)
+isscalar = cast(Callable[[Optional[ImageAny]], bool], _isscalar)
 
 T = TypeVar("T", bound=ImageAny)
 MorphImageT = TypeVar("Union[ImageGrayscale, ImageGrayscaleMask]", bound=Union[ImageGrayscale, ImageGrayscaleMask])
@@ -382,7 +388,7 @@ def get_threshold_robust_background(
     upper_outlier_fraction: float = 0.05,
     averaging_method:       Threshold.AveragingMethod = Threshold.AveragingMethod.MEAN,
     variance_method:        Threshold.VarianceMethod = Threshold.VarianceMethod.STANDARD_DEVIATION,
-    number_of_deviations:   int = 2,
+    number_of_deviations:   float = 2.0,
 ) -> float:
     """Calculate threshold based on mean & standard deviation.
     The threshold is calculated by trimming the top and bottom 5% of
@@ -1702,3 +1708,149 @@ def fill_holes(image: ImageAny, diameter: float) -> ImageAny:
     size = numpy.pi * factor
 
     return skimage.morphology.remove_small_holes(image, size)
+
+################################################################################
+# ImageMath
+################################################################################
+
+def imagemath_apply_on_image(
+        output_pixel_data: ImageAny, 
+        pd: ImageAny, 
+        comparitor: ImageAny, 
+        op: Callable[[ImageAny, ImageAny], ImageAny], 
+        opval: Operator,
+        ) -> ImageAny:
+    assert isinstance(output_pixel_data, numpy.ndarray), "output_pixel_data must be a numpy array" # Pylance needs to understand this is a numpy array
+    if not isscalar(pd) and output_pixel_data.ndim != pd.ndim:
+        if output_pixel_data.ndim == 2:
+            output_pixel_data = output_pixel_data[:, :, numpy.newaxis]
+            if opval == Operator.EQUALS and not isscalar(comparitor):
+                comparitor = comparitor[:, :, numpy.newaxis]
+        if pd.ndim == 2:
+            pd = pd[:, :, numpy.newaxis]
+    if opval == Operator.EQUALS:
+        output_pixel_data = output_pixel_data & (comparitor == pd)
+    else:
+        output_pixel_data = op(output_pixel_data, pd)
+    return output_pixel_data
+
+
+
+def imagemath_apply_binary_operation(
+    opval: Operator, 
+    operands: List[Union[ImageAny, float]], 
+    masks: Optional[List[Optional[Union[ImageAnyMask, bool]]]], 
+    output_pixel_data: ImageAny, 
+    output_mask: Optional[ImageAnyMask],
+    image_factors: Optional[List[float]], # TODO: can this be removed?
+    ignore_mask: bool, # TODO: can this be removed?
+    ) -> Tuple[
+        ImageAny, 
+        Optional[ImageAnyMask], 
+    ]:
+    #
+    # Helper function to determine if logical operations should be used
+    #
+    def use_logical_operation(pixel_data: List[ImageAny]) -> bool:
+        return all(
+            [pd.dtype == bool for pd in pixel_data if not isscalar(pd)]
+        )
+    
+    #
+    # Helper function for logical subtraction
+    #
+
+    def logical_subtract(output_pixel_data: ImageAny, pd: ImageAny) -> ImageAny:
+        output_pixel_data[pd] = False
+        return output_pixel_data
+
+    comparitor = operands[0] # fix pylance error
+    use_logical = use_logical_operation(operands)
+    op_fn_dispatch: Dict[Operator, Callable[[ImageAny, ImageAny], ImageAny]] = {
+        Operator.ADD: numpy.add,
+        Operator.SUBTRACT: logical_subtract if use_logical else numpy.subtract,
+        Operator.DIFFERENCE: numpy.logical_xor if use_logical else lambda x, y: numpy.abs(numpy.subtract(x, y)),
+        Operator.MULTIPLY: numpy.logical_and if use_logical else numpy.multiply,
+        Operator.MINIMUM: numpy.minimum,
+        Operator.MAXIMUM: numpy.maximum,
+        Operator.AVERAGE: numpy.add,
+        Operator.MAXIMUM: numpy.maximum,
+        Operator.AND: numpy.logical_and,
+        Operator.OR: numpy.logical_or,
+        Operator.EQUALS: numpy.equal,
+        Operator.NONE: lambda x, y: x,
+        Operator.DIVIDE: numpy.divide,
+    }
+    if opval not in op_fn_dispatch:
+        raise NotImplementedError(f"Unimplemented operation: {opval}")
+    #
+    # Binary operations
+    #
+    op = op_fn_dispatch[opval]
+
+    #
+    # Equals and Subtract operations need additional handling
+    #
+    if opval == Operator.EQUALS:
+        output_pixel_data = numpy.ones(operands[0].shape, bool)
+        comparitor = operands[0]
+    elif opval == Operator.SUBTRACT and use_logical:
+        output_pixel_data = operands[0].copy()
+
+    
+    # _masks is a list of Nones if masks is None. Fixes type warnings.
+    if masks is None:
+        masks = [None for _ in operands]
+
+    #
+    # Apply the operation to each image in the list
+    #
+    for pd, mask in zip(operands[1:], masks[1:]):
+        output_pixel_data = imagemath_apply_on_image(output_pixel_data, pd, comparitor, op, opval)
+        if not ignore_mask:
+            if output_mask is None:
+                output_mask = mask
+            elif mask is not None:
+                output_mask = output_mask & mask
+    #
+    # Average operation needs additional handling
+    #
+    if opval == Operator.AVERAGE:
+        if not use_logical:
+            assert image_factors is not None, "image_factors must be provided for average operation"
+            output_pixel_data /= sum(image_factors)
+    return output_pixel_data, output_mask
+
+
+def imagemath_apply_unary_operation(
+    opval: Operator, 
+    operands: List[Union[ImageAny, float]], 
+    masks: Optional[List[Optional[Union[ImageAnyMask, bool]]]], 
+    output_pixel_data: ImageAny,
+    output_mask: Optional[ImageAnyMask],
+    ignore_mask: bool,
+    ) -> Tuple[
+        ImageAny, 
+        Optional[ImageAnyMask],
+    ]:
+    if opval == Operator.STDEV:
+        pixel_array = numpy.array(operands)
+        output_pixel_data = numpy.std(pixel_array,axis=0)
+        if not ignore_mask:
+            mask_array = numpy.array(masks)
+            output_mask = mask_array.all(axis=0) 
+    elif opval == Operator.INVERT:
+        output_pixel_data = invert(output_pixel_data)
+    elif opval == Operator.NOT:
+        output_pixel_data = numpy.logical_not(output_pixel_data)
+    elif opval == Operator.LOG_TRANSFORM:
+        output_pixel_data = numpy.log2(output_pixel_data + 1)
+    elif opval == Operator.LOG_TRANSFORM_LEGACY:
+        output_pixel_data = numpy.log2(output_pixel_data)
+    elif opval == Operator.NONE:
+        output_pixel_data = output_pixel_data.copy()
+    else:
+        raise NotImplementedError(
+            "The operation %s has not been implemented" % opval
+        )
+    return output_pixel_data, output_mask