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

{cellprofiler_library_nightly-5.0.0.dev454 → 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.dev454
+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.dev454 → 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.dev454'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev454')
+__version__ = version = '5.0.0.dev462'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev462')
 
-__commit_id__ = commit_id = 'g957fa6e04'
+__commit_id__ = commit_id = 'g8dcb1b2d8'

{cellprofiler_library_nightly-5.0.0.dev454 → 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])
@@ -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

cellprofiler_library_nightly-5.0.0.dev462/cellprofiler_library/modules/_imagemath.py

@@ -0,0 +1,64 @@
+import numpy
+from typing import Callable, Optional, List, Tuple, cast, Union, Annotated
+from numpy import isscalar as _isscalar
+from pydantic import validate_call, ConfigDict, Field
+from cellprofiler_library.opts.imagemath import Operator, BINARY_OUTPUT_OPS, UNARY_INPUT_OPS, BINARY_INPUT_OPS
+from cellprofiler_library.types import ImageAny, ImageAnyMask
+from cellprofiler_library.functions.image_processing import imagemath_apply_binary_operation, imagemath_apply_unary_operation
+isscalar = cast(Callable[[Optional[ImageAny]], bool], _isscalar)
+
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def image_math(
+        opval:              Annotated[Operator, Field(description=" Operator to apply to the images or measurements")],
+        operands:           Annotated[List[Union[ImageAny, float]], Field(description=" List of images and/or measurements to apply the operator to")],
+        masks:              Annotated[Optional[List[Optional[Union[ImageAnyMask, bool]]]], Field(description=" List of masks for the images. Use `True` for measurement operands")],
+        output_pixel_data:  Annotated[ImageAny, Field(description=" Output image or measurement")],
+        output_mask:        Annotated[Optional[ImageAnyMask], Field(description=" Output mask")],
+        ignore_mask:        Annotated[bool, Field(description=" Ignore the masks")],
+        image_factors:      Annotated[Optional[List[float]], Field(description=" List of image factors to multiply the images by")],
+        exponent:           Annotated[Optional[float], Field(description=" Exponent to raise the images by")],
+        after_factor:       Annotated[Optional[float], Field(description=" Multiply the images by this value after the operation")],
+        addend:             Annotated[Optional[float], Field(description=" Add this value to the images")],
+        truncate_low:       Annotated[Optional[bool], Field(description=" Truncate the images below 0")],
+        truncate_high:      Annotated[Optional[bool], Field(description=" Truncate the images above 0")],
+        replace_nan:        Annotated[Optional[bool], Field(description=" Replace invalid values with 0")],
+        ) -> Tuple[
+            ImageAny, Optional[ImageAnyMask]
+        ]:
+    if opval in BINARY_INPUT_OPS:
+        output_pixel_data, output_mask = imagemath_apply_binary_operation(opval, operands, masks, output_pixel_data, output_mask, image_factors, ignore_mask)
+
+    elif opval in UNARY_INPUT_OPS:
+        output_pixel_data, output_mask = imagemath_apply_unary_operation(opval, operands, masks, output_pixel_data, output_mask, ignore_mask)
+
+    else:
+        raise NotImplementedError(
+            "The operation %s has not been implemented" % opval
+        )
+
+    # Check to see if there was a measurement & image w/o mask. If so
+    # set mask to none
+    if isscalar(output_mask):
+        output_mask = None
+    if opval not in BINARY_OUTPUT_OPS:
+        #
+        # Post-processing: exponent, multiply, add
+        #
+        if exponent is not None and exponent != 1:
+            output_pixel_data **= exponent
+        if after_factor is not None and after_factor != 1:
+            output_pixel_data *= after_factor
+        if addend is not None and addend != 0:
+            output_pixel_data += addend
+
+        #
+        # truncate values
+        #
+        if truncate_low:
+            output_pixel_data[output_pixel_data < 0] = 0
+        if truncate_high:
+            output_pixel_data[output_pixel_data > 1] = 1
+        if replace_nan:
+            output_pixel_data[numpy.isnan(output_pixel_data)] = 0
+    return output_pixel_data, output_mask

cellprofiler_library_nightly-5.0.0.dev462/cellprofiler_library/opts/imagemath.py

@@ -0,0 +1,30 @@
+from enum import Enum
+
+class Operator(str, Enum):
+    ADD = "Add"
+    SUBTRACT = "Subtract"
+    DIFFERENCE = "Absolute Difference"
+    MULTIPLY = "Multiply"
+    DIVIDE = "Divide"
+    AVERAGE = "Average"
+    MINIMUM = "Minimum"
+    MAXIMUM = "Maximum"
+    STDEV = "Standard Deviation"
+    INVERT = "Invert"
+    COMPLEMENT = "Complement"
+    LOG_TRANSFORM_LEGACY = "Log transform (legacy)"
+    LOG_TRANSFORM = "Log transform (base 2)"
+    NONE = "None"
+    OR = "Or"
+    AND = "And"
+    NOT = "Not"
+    EQUALS = "Equals"
+
+
+class Operand(str, Enum):
+    IMAGE = "Image"
+    MEASUREMENT = "Measurement"
+
+BINARY_OUTPUT_OPS = [Operator.AND, Operator.OR, Operator.NOT, Operator.EQUALS]
+UNARY_INPUT_OPS = [Operator.STDEV, Operator.INVERT, Operator.NOT, Operator.LOG_TRANSFORM, Operator.LOG_TRANSFORM_LEGACY, Operator.NONE]
+BINARY_INPUT_OPS = [Operator.ADD, Operator.SUBTRACT, Operator.DIFFERENCE, Operator.MULTIPLY, Operator.DIVIDE, Operator.AVERAGE, Operator.MAXIMUM, Operator.MINIMUM, Operator.AND, Operator.OR, Operator.EQUALS]

{cellprofiler_library_nightly-5.0.0.dev454 → cellprofiler_library_nightly-5.0.0.dev462}/cellprofiler_library_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev454
+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.dev454 → cellprofiler_library_nightly-5.0.0.dev462}/cellprofiler_library_nightly.egg-info/SOURCES.txt

@@ -32,6 +32,7 @@ cellprofiler_library/modules/_gaussianfilter.py
 cellprofiler_library/modules/_identifyprimaryobjects.py
 cellprofiler_library/modules/_identifysecondaryobjects.py
 cellprofiler_library/modules/_identifytertiaryobjects.py
+cellprofiler_library/modules/_imagemath.py
 cellprofiler_library/modules/_measureimageoverlap.py
 cellprofiler_library/modules/_measureobjectsizeshape.py
 cellprofiler_library/modules/_medialaxis.py
@@ -62,6 +63,7 @@ cellprofiler_library/opts/erodeobjects.py
 cellprofiler_library/opts/identifyprimaryobjects.py
 cellprofiler_library/opts/identifysecondaryobjects.py
 cellprofiler_library/opts/identifytertiaryobjects.py
+cellprofiler_library/opts/imagemath.py
 cellprofiler_library/opts/measureimageoverlap.py
 cellprofiler_library/opts/morph.py
 cellprofiler_library/opts/objectsizeshapefeatures.py