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

{cellprofiler_library_nightly-5.0.0.dev454 → cellprofiler_library_nightly-5.0.0.dev466}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev454
+Version: 5.0.0.dev466
 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.dev466}/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.dev466'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev466')
 
-__commit_id__ = commit_id = 'g957fa6e04'
+__commit_id__ = commit_id = 'ge958a4dc2'

{cellprofiler_library_nightly-5.0.0.dev454 → cellprofiler_library_nightly-5.0.0.dev466}/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,234 @@ 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
+
+
+###############################################################################
+# GrayToColor
+###############################################################################
+
+def gray_to_rgb(
+        pixel_data_arr: List[Optional[Image2DGrayscale]],
+        adjustment_factor_array: List[float],
+        intensities: List[Tuple[float, ...]]=[(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)],
+        wants_rescale: bool=True,
+        ) -> Image2DColor:
+    assert(len(pixel_data_arr) == len(adjustment_factor_array)), f"pixel_data_arr and adjustment_factor_array must be the same length. pixel_data_arr has {len(pixel_data_arr)} elements, adjustment_factor_array has {len(adjustment_factor_array)} elements."
+    assert(len(pixel_data_arr) == len(intensities)), f"pixel_data_arr and intensities must be the same length. pixel_data_arr has {len(pixel_data_arr)} elements, intensities has {len(intensities)} elements."
+
+    parent_image = None
+    rgb_pixel_data = None
+    for pixel_data, adjustment_factor, intensity_triplet in zip(pixel_data_arr, adjustment_factor_array, intensities):
+        if pixel_data is None:
+            continue
+        multiplier = numpy.array(intensity_triplet) * adjustment_factor
+        if wants_rescale:
+            pixel_data = pixel_data /numpy.max(pixel_data)
+        if parent_image is not None:
+            if parent_image.shape != pixel_data.shape:
+                raise ValueError(
+                    "The input images have different sizes (%s vs %s)"
+                    % (
+                        parent_image.shape, 
+                        pixel_data.shape,
+                    )
+                )
+            rgb_pixel_data += numpy.dstack([pixel_data] * 3) * multiplier
+        else:
+            parent_image = pixel_data
+            rgb_pixel_data = numpy.dstack([pixel_data] * 3) * multiplier
+    return rgb_pixel_data
+
+def gray_to_cmyk(*args, **kwargs):
+    # gray to cmyk has the same implementation as gray to rgb but with different intensities
+    return gray_to_rgb(*args, **kwargs)
+
+
+def gray_to_composite_color(
+        pixel_data_arr: List[Optional[Image2DGrayscale]],
+        color_array: List[Tuple[int, int, int]],
+        weight_array: List[float],
+        wants_rescale: bool,
+) -> Image2DColor:
+    source_channels = pixel_data_arr
+    parent_image = pixel_data_arr[0]
+    for idx, pd in enumerate(source_channels):
+        if pd is None:
+            continue
+        if pd.shape != source_channels[0].shape:
+            raise ValueError(
+                "The input images have different sizes (%s vs %s)"
+                % (
+                    source_channels[0].shape,
+                    pd.shape,
+                )
+            )
+
+    colors: List[NDArray[numpy.float32]] = []
+    pixel_data = parent_image
+    if wants_rescale:
+        pixel_data = pixel_data / numpy.max(pixel_data)
+    for color_tuple, weight in zip(color_array, weight_array):
+        color = (weight * numpy.array(color_tuple).astype(pixel_data.dtype) / 255)
+        colors += [color[numpy.newaxis, numpy.newaxis, :]]
+    rgb_pixel_data = pixel_data[:, :, numpy.newaxis] * colors[0]
+    for image, color in zip(source_channels[1:], colors[1:]):
+        if wants_rescale:
+            image = image / numpy.max(image)
+        rgb_pixel_data = rgb_pixel_data + image[:, :, numpy.newaxis] * color
+
+    return rgb_pixel_data
+    
+
+def gray_to_stacked_color(
+    pixel_data_arr: List[Optional[Image2DGrayscale]]
+) -> Image2DColor:
+    source_channels = pixel_data_arr
+    rgb_pixel_data = numpy.dstack(source_channels)
+    return rgb_pixel_data

cellprofiler_library_nightly-5.0.0.dev466/cellprofiler_library/modules/_graytocolor.py

@@ -0,0 +1,58 @@
+import numpy
+from numpy.typing import NDArray
+from typing import List, Tuple, Optional
+from pydantic import validate_call, ConfigDict
+from cellprofiler_library.opts.graytocolor import Scheme
+from cellprofiler_library.types import Image2DGrayscale, Image2DColor
+from cellprofiler_library.functions.image_processing import gray_to_rgb, gray_to_cmyk, gray_to_composite_color, gray_to_stacked_color
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def gray_to_color(
+    pixel_data_arr: List[Optional[Image2DGrayscale]],
+    scheme: Scheme,
+    color_array: Optional[List[Tuple[int, int, int]]] = None,
+    weight_array: Optional[List[float]] = None,
+    adjustment_factor_array: Optional[List[float]] = None,
+    intensities: List[Tuple[float, ...]]=[(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)],
+    wants_rescale: bool=True,
+) -> Image2DColor:
+    rgb_pixel_data = None
+    if scheme == Scheme.RGB:
+        assert adjustment_factor_array is not None, "adjustment_factor_array must be provided for RGB mode"
+        assert intensities is not None, "intensities must be provided for RGB mode"
+        rgb_pixel_data = gray_to_rgb(
+            pixel_data_arr = pixel_data_arr,
+            adjustment_factor_array = adjustment_factor_array,
+            intensities = intensities,
+            wants_rescale = wants_rescale,
+        )
+    elif scheme == Scheme.CMYK:
+        assert adjustment_factor_array is not None, "adjustment_factor_array must be provided for CMYK mode"
+        assert intensities is not None, "intensities must be provided for CMYK mode"
+        rgb_pixel_data = gray_to_cmyk(
+            pixel_data_arr = pixel_data_arr,
+            adjustment_factor_array = adjustment_factor_array,
+            intensities = intensities,
+            wants_rescale = wants_rescale,
+        )
+    elif scheme == Scheme.COMPOSITE:
+        assert color_array is not None, "color_array must be provided for composite mode"
+        assert weight_array is not None, "weight_array must be provided for composite mode"
+        rgb_pixel_data = gray_to_composite_color(
+            pixel_data_arr = pixel_data_arr,
+            color_array = color_array,
+            weight_array = weight_array,
+            wants_rescale = wants_rescale,
+        )
+    elif scheme == Scheme.STACK:
+        assert pixel_data_arr is not None, "pixel_data_arr must be provided for stack mode"
+        rgb_pixel_data = gray_to_stacked_color(
+            pixel_data_arr = pixel_data_arr,
+        )
+    else:
+        raise ValueError(f"Unimplemented scheme: {scheme}")
+    if scheme.value != Scheme.STACK and wants_rescale:
+        # If we rescaled, clip values that went out of range after multiplication
+        rgb_pixel_data[rgb_pixel_data > 1] = 1
+    return rgb_pixel_data
+

cellprofiler_library_nightly-5.0.0.dev466/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.dev466/cellprofiler_library/opts/graytocolor.py

@@ -0,0 +1,20 @@
+from enum import Enum
+
+class Scheme(str, Enum):
+    RGB = "RGB"
+    CMYK = "CMYK"
+    STACK = "Stack"
+    COMPOSITE = "Composite"
+    LEAVE_THIS_BLACK = "Leave this black"
+
+DEFAULT_COLORS = [
+    "#%02x%02x%02x" % color
+    for color in (
+        (255, 0, 0),
+        (0, 255, 0),
+        (0, 0, 255),
+        (128, 128, 0),
+        (128, 0, 128),
+        (0, 128, 128),
+    )
+]

cellprofiler_library_nightly-5.0.0.dev466/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.dev466}/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.dev466
 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.dev466}/cellprofiler_library_nightly.egg-info/SOURCES.txt

@@ -29,9 +29,11 @@ cellprofiler_library/modules/_erodeobjects.py
 cellprofiler_library/modules/_expandorshrinkobjects.py
 cellprofiler_library/modules/_fillobjects.py
 cellprofiler_library/modules/_gaussianfilter.py
+cellprofiler_library/modules/_graytocolor.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
@@ -59,9 +61,11 @@ cellprofiler_library/opts/dilateobjects.py
 cellprofiler_library/opts/enhanceorsuppressfeatures.py
 cellprofiler_library/opts/erodeimage.py
 cellprofiler_library/opts/erodeobjects.py
+cellprofiler_library/opts/graytocolor.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