cellprofiler-library-nightly 5.0.0.dev650__tar.gz → 5.0.0.dev669__tar.gz

{cellprofiler_library_nightly-5.0.0.dev650/cellprofiler_library_nightly.egg-info → cellprofiler_library_nightly-5.0.0.dev669}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev650
+Version: 5.0.0.dev669
 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.dev669/cellprofiler_library/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '5.0.0.dev669'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev669')
+
+__commit_id__ = commit_id = 'g51250caf3'

{cellprofiler_library_nightly-5.0.0.dev650 → cellprofiler_library_nightly-5.0.0.dev669}/cellprofiler_library/functions/image_processing.py

@@ -8,6 +8,7 @@ from skimage.util import invert as _invert
 import skimage.transform
 import skimage
 import skimage.restoration
+import skimage.exposure
 import centrosome
 import centrosome.threshold
 import centrosome.filter
@@ -31,7 +32,7 @@ from cellprofiler_library.types import (
     ImageAny, ImageAnyMask, 
     ObjectSegmentation, 
     Image2D, Image2DMask, 
-    StructuringElement, ObjectLabelSet, ImageColor, ImageBinaryMask, Image2DBinary, ObjectLabel, ImageBinary, Pixel
+    StructuringElement, ObjectLabelSet, ImageColor, ImageBinaryMask, Image2DBinary, ObjectLabel, ImageBinary, Pixel, PixelAny
 )
 from cellprofiler_library.opts import threshold as Threshold
 from cellprofiler_library.opts.enhanceorsuppressfeatures import SpeckleAccuracy, NeuriteMethod
@@ -42,7 +43,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
-
+from cellprofiler_library.opts.rescaleintensity import MaximumIntensityMethod, MinimumIntensityMethod
 invert = cast(Callable[[ImageAny], ImageAny], _invert)
 isscalar = cast(Callable[[Optional[ImageAny]], bool], _isscalar)
 
@@ -1769,21 +1770,21 @@ def fill_holes(image: ImageAny, diameter: float) -> ImageAny:
 
 def imagemath_apply_on_image(
         output_pixel_data: ImageAny, 
-        pd: ImageAny, 
-        comparitor: ImageAny, 
-        op: Callable[[ImageAny, ImageAny], ImageAny], 
+        pd: ImageAny,
+        comparator: 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 opval == Operator.EQUALS and not isscalar(comparator):
+                comparator = comparator[:, :, numpy.newaxis]
         if pd.ndim == 2:
             pd = pd[:, :, numpy.newaxis]
     if opval == Operator.EQUALS:
-        output_pixel_data = output_pixel_data & (comparitor == pd)
+        output_pixel_data = output_pixel_data & (comparator == pd)
     else:
         output_pixel_data = op(output_pixel_data, pd)
     return output_pixel_data
@@ -1818,7 +1819,7 @@ def imagemath_apply_binary_operation(
         output_pixel_data[pd] = False
         return output_pixel_data
 
-    comparitor = operands[0] # fix pylance error
+    comparator = operands[0] # fix pylance error
     use_logical = use_logical_operation(operands)
     op_fn_dispatch: Dict[Operator, Callable[[ImageAny, ImageAny], ImageAny]] = {
         Operator.ADD: numpy.add,
@@ -1847,7 +1848,7 @@ def imagemath_apply_binary_operation(
     #
     if opval == Operator.EQUALS:
         output_pixel_data = numpy.ones(operands[0].shape, bool)
-        comparitor = operands[0]
+        comparator = operands[0]
     elif opval == Operator.SUBTRACT and use_logical:
         output_pixel_data = operands[0].copy()
 
@@ -1860,7 +1861,7 @@ def imagemath_apply_binary_operation(
     # 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)
+        output_pixel_data = imagemath_apply_on_image(output_pixel_data, pd, comparator, op, opval)
         if not ignore_mask:
             if output_mask is None:
                 output_mask = mask
@@ -2870,3 +2871,205 @@ def reshape_image(
     result[: source.shape[0], : source.shape[1]] = source
     return result
 
+
+###############################################################################
+# RescaleIntensity
+###############################################################################
+
+def rescale(
+        image_pixel_data: ImageAny, 
+        in_range: Tuple[float, float],
+        out_range: Tuple[float, float] = (0.0, 1.0)
+    ) -> ImageAny:
+    data = 1.0 * image_pixel_data
+
+    rescaled = skimage.exposure.rescale_intensity(
+        data, in_range=in_range, out_range=out_range
+    )
+
+    return rescaled
+
+
+def stretch_rescale(
+        data: ImageAny, 
+        mask: ImageAnyMask, 
+        multichannel: bool = False
+    ) -> ImageAny:
+    if multichannel:
+        splitaxis = data.ndim - 1
+        singlechannels = numpy.split(data, data.shape[-1], splitaxis)
+        newchannels = []
+        for channel in singlechannels:
+            channel = numpy.squeeze(channel, axis=splitaxis)
+            if (masked_channel := channel[mask]).size == 0:
+                in_range = (0, 1)
+            else:
+                in_range = (min(masked_channel), max(masked_channel))
+
+            rescaled = rescale(channel, in_range)
+
+            newchannels.append(rescaled)
+        full_rescaled = numpy.stack(newchannels, axis=-1)
+        return full_rescaled
+    if (masked_data := data[mask]).size == 0:
+        in_range = (0, 1)
+    else:
+        in_range = (min(masked_data), max(masked_data))
+    return rescale(data, in_range)
+
+
+def manual_input_range(
+        data: ImageAny, 
+        mask: Optional[ImageAnyMask], 
+        source_high: float, 
+        source_low: float, 
+        source_scale_min: float, 
+        source_scale_max: float, 
+        auto_high: MaximumIntensityMethod, 
+        auto_low: MinimumIntensityMethod, 
+        global_min: Optional[PixelAny],
+        global_max: Optional[PixelAny],
+    ) -> ImageAny:
+    return manual_io_range(
+        data, 
+        mask, 
+        source_high, 
+        source_low, 
+        source_scale_min, 
+        source_scale_max, 
+        auto_high, 
+        auto_low, 
+        global_min,
+        global_max
+    )
+
+
+def manual_io_range(
+        data: ImageAny, 
+        mask: Optional[ImageAnyMask], 
+        source_high: float, 
+        source_low: float, 
+        source_scale_min: float, 
+        source_scale_max: float, 
+        auto_high: MaximumIntensityMethod, 
+        auto_low: MinimumIntensityMethod, 
+        global_min: Optional[PixelAny],
+        global_max: Optional[PixelAny],
+        dest_scale_min: Optional[float]=None, 
+        dest_scale_max: Optional[float]=None
+    ) -> ImageAny:
+    in_range = get_source_range(data, mask, source_high, source_low, source_scale_min, source_scale_max, auto_high, auto_low, global_min, global_max)
+    if dest_scale_min is None and dest_scale_max is None:
+        return rescale(data, in_range)
+    else:
+        out_range = (dest_scale_min, dest_scale_max)
+        return rescale(data, in_range, out_range)
+
+
+def divide(data: ImageAny, value: float) -> ImageAny:
+    if value == 0.0:
+        raise ZeroDivisionError("Cannot divide pixel intensity by 0.")
+
+    return data / value
+
+
+def divide_by_image_minimum(data: ImageAny, mask: ImageAnyMask) -> ImageAny:
+    if (masked_data := data[mask]).size == 0:
+        src_min = numpy.float64(0)
+    else:
+        src_min = numpy.min(masked_data)
+
+    return divide(data, float(src_min))
+
+
+def divide_by_image_maximum(data: ImageAny, mask: ImageAnyMask) -> ImageAny:
+    if (masked_data := data[mask]).size == 0:
+        src_max = numpy.float64(1)
+    else:
+        src_max = numpy.max(masked_data)
+
+    return divide(data, float(src_max))
+
+
+def divide_by_value(data: ImageAny, divisor_value: float):
+    return divide(data, divisor_value)
+
+
+def scale_by_image_maximum(
+        data: ImageAny, 
+        mask: ImageAnyMask, 
+        reference_data: ImageAny, 
+        reference_mask: ImageGrayscaleMask
+    ) -> ImageAny:
+    ###
+    # Scale the image by the maximum of another image
+    #
+    # Find the maximum value within the unmasked region of the input
+    # and reference image. Multiply by the reference maximum, divide
+    # by the input maximum to scale the input image to the same
+    # range as the reference image
+    ###
+    if (masked_input := data[mask]).size == 0:
+        return data
+    else:
+        image_max = numpy.max(masked_input)
+
+    if image_max == 0:
+        return data
+
+
+    if (masked_ref := reference_data[reference_mask]).size == 0:
+        reference_max = 1
+    else:
+        reference_max = numpy.max(masked_ref)
+
+    return divide(data * reference_max, float(image_max))
+
+
+def get_source_range(
+        data: ImageAny, 
+        mask: Optional[ImageAnyMask], 
+        source_high: float, 
+        source_low: float, 
+        source_scale_min: float, 
+        source_scale_max: float, 
+        auto_high: MaximumIntensityMethod, 
+        auto_low: MinimumIntensityMethod, 
+        global_min: Optional[PixelAny],
+        global_max: Optional[PixelAny],
+    ) -> Tuple[float, float]:
+    """Get the source range, accounting for automatically computed values"""
+    input_pixels = None
+    if (
+        auto_high == MaximumIntensityMethod.CUSTOM_VALUE.value
+        and auto_low == MinimumIntensityMethod.CUSTOM_VALUE.value
+    ):
+        return source_scale_min, source_scale_max
+
+    if (
+        auto_low == MinimumIntensityMethod.EACH_IMAGE.value
+        or auto_high == MaximumIntensityMethod.EACH_IMAGE.value
+    ):
+        input_pixels = data
+        if mask is not None:
+            input_pixels = input_pixels[mask]
+            if input_pixels.size == 0:
+                return 0, 1
+
+    if auto_low == MinimumIntensityMethod.ALL_IMAGES.value:
+        src_min = float(global_min or 0)
+    elif auto_low == MinimumIntensityMethod.EACH_IMAGE.value:
+        assert input_pixels is not None, "Invalid settings for automatic minimum, please check your settings and data"
+        src_min = float(numpy.min(input_pixels))
+    else:
+        src_min = source_low
+
+    if auto_high == MaximumIntensityMethod.ALL_IMAGES.value:
+        src_max = float(global_max or 0)
+    elif auto_high == MaximumIntensityMethod.EACH_IMAGE.value:
+        assert input_pixels is not None, "Invalid settings for automatic maximum, please check your settings and data"
+        src_max = float(numpy.max(input_pixels))
+    else:
+        src_max = source_high
+        
+    return src_min, src_max

{cellprofiler_library_nightly-5.0.0.dev650 → cellprofiler_library_nightly-5.0.0.dev669}/cellprofiler_library/functions/object_processing.py

@@ -5,10 +5,11 @@ import skimage.morphology
 import matplotlib.cm
 import mahotas
 import centrosome.cpmorphology
-from typing import Optional, Literal, Tuple, Union
+from typing import Optional, Literal, Tuple, Union, List, Dict, Any
 from cellprofiler_library.types import ImageAnyMask, ObjectLabel, ImageColor, ImageGrayscale, Image2DGrayscale, Image2DGrayscaleMask, ImageBinary, ImageAny, Image2DBinary
 from cellprofiler_library.functions.image_processing import crop_image_similarly, ObjectSegmentation, StructuringElement
 from cellprofiler_library.opts.identifyprimaryobjects import UnclumpMethod, WatershedMethod, FillHolesMethod
+from cellprofiler_library.opts.filterobjects import FilterMethod, OverlapAssignment
 
 
 def shrink_to_point(labels, fill):
@@ -1250,3 +1251,347 @@ def object_crop_image_similarly(
         raise ValueError("Images are of different size and no parent image")
     return crop_image_similarly(obj_parent_image, other_image, obj_parent_crop_mask)
 
+
+################################################################################
+# MeasureColocalization
+################################################################################
+
+
+def keep_one(values: NDArray[numpy.float64], filter_choice: FilterMethod) -> NDArray[numpy.int_]:
+    """
+    Return an array containing the single object to keep
+
+    values - measurement value per object
+    filter_choice - FilterMethod.MINIMAL or FilterMethod.MAXIMAL
+    """
+    if len(values) == 0:
+        return numpy.array([], int)
+    best_idx = (
+        numpy.argmax(values)
+        if filter_choice == FilterMethod.MAXIMAL.value
+        else numpy.argmin(values)
+    ) + 1
+    return numpy.array([best_idx], int)
+
+
+def keep_per_object(
+    src_labels: ObjectSegmentation,
+    enclosing_labels: ObjectSegmentation,
+    enclosing_max: int,
+    per_object_assignment: OverlapAssignment,
+    filter_choice: FilterMethod,
+    values: NDArray[numpy.float64],
+) -> Union[NDArray[numpy.int_], List[int]]:
+    """
+    Return an array containing the best object per enclosing object
+
+    src_labels - segmentation of the objects being filtered
+    enclosing_labels - segmentation of the enclosing (parent) objects
+    enclosing_max - number of enclosing objects
+    per_object_assignment - OverlapAssignment strategy for matching objects to enclosing objects
+    filter_choice - FilterMethod.MINIMAL_PER_OBJECT or FilterMethod.MAXIMAL_PER_OBJECT
+    values - measurement value per object
+    """
+    if enclosing_max == 0:
+        return numpy.array([], int)
+    enclosing_range = numpy.arange(1, enclosing_max + 1)
+
+    #
+    # Make a vector of the value of the measurement per label index.
+    # We can then label each pixel in the image with the measurement
+    # value for the object at that pixel.
+    # For unlabeled pixels, put the minimum value if looking for the
+    # maximum value and vice-versa
+    #
+    wants_max = filter_choice == FilterMethod.MAXIMAL_PER_OBJECT.value
+    if per_object_assignment == OverlapAssignment.PARENT_WITH_MOST_OVERLAP.value:
+        #
+        # Find the number of overlapping pixels in enclosing
+        # and source objects
+        #
+        mask = enclosing_labels * src_labels != 0
+        enclosing_labels = enclosing_labels[mask]
+        src_labels = src_labels[mask]
+        order = numpy.lexsort((enclosing_labels, src_labels))
+        src_labels = src_labels[order]
+        enclosing_labels = enclosing_labels[order]
+        firsts = numpy.hstack(
+            (
+                [0],
+                numpy.where(
+                    (src_labels[:-1] != src_labels[1:])
+                    | (enclosing_labels[:-1] != enclosing_labels[1:])
+                )[0]
+                + 1,
+                [len(src_labels)],
+            )
+        )
+        areas = firsts[1:] - firsts[:-1]
+        enclosing_labels = enclosing_labels[firsts[:-1]]
+        src_labels = src_labels[firsts[:-1]]
+        #
+        # Re-sort by source label value and area descending
+        #
+        if wants_max:
+            svalues = -values
+        else:
+            svalues = values
+        order = numpy.lexsort((-areas, svalues[src_labels - 1]))
+        src_labels, enclosing_labels, areas = [
+            x[order] for x in (src_labels, enclosing_labels, areas)
+        ]
+        firsts = numpy.hstack(
+            (
+                [0],
+                numpy.where(src_labels[:-1] != src_labels[1:])[0] + 1,
+                src_labels.shape[:1],
+            )
+        )
+        counts = firsts[1:] - firsts[:-1]
+        #
+        # Process them in order. The maximal or minimal child
+        # will be assigned to the most overlapping parent and that
+        # parent will be excluded.
+        #
+        best_src_label = numpy.zeros(enclosing_max + 1, int)
+        for idx, count in zip(firsts[:-1], counts):
+            for i in range(count):
+                enclosing_object_number = enclosing_labels[idx + i]
+                if best_src_label[enclosing_object_number] == 0:
+                    best_src_label[enclosing_object_number] = src_labels[idx]
+                    break
+        #
+        # Remove best source labels = 0 and sort to get the list
+        #
+        best_src_label = best_src_label[best_src_label != 0]
+        best_src_label.sort()
+        return best_src_label
+    else:
+        tricky_values = numpy.zeros((len(values) + 1,))
+        tricky_values[1:] = values
+        if wants_max:
+            tricky_values[0] = -numpy.Inf
+        else:
+            tricky_values[0] = numpy.Inf
+        src_values = tricky_values[src_labels]
+        #
+        # Now find the location of the best for each of the enclosing objects
+        #
+        fn = (
+            scipy.ndimage.maximum_position
+            if wants_max
+            else scipy.ndimage.minimum_position
+        )
+        best_pos = fn(src_values, enclosing_labels, enclosing_range)
+        best_pos = numpy.array(
+            (best_pos,) if isinstance(best_pos, tuple) else best_pos
+        )
+        best_pos = best_pos.astype(numpy.uint32)
+        #
+        # Get the label of the pixel at each location
+        #
+        # Multidimensional indexing with non-tuple values is not allowed as of numpy 1.23
+        best_pos = tuple(map(tuple, best_pos.transpose()))
+        indexes = src_labels[best_pos]
+        indexes = set(indexes)
+        indexes = list(indexes)
+        indexes.sort()
+        return indexes[1:] if len(indexes) > 0 and indexes[0] == 0 else indexes
+
+
+def keep_within_limits(limit_groups: List[Dict[str, Any]]) -> NDArray[numpy.int_]:
+    """Return an array containing the indices of objects to keep
+
+    limit_groups - a list of {"values": ndarray, "min_limit": float or None, "max_limit": float or None}
+    """
+    hits = None
+    MIN_LIM = "min_limit"
+    MAX_LIM = "max_limit"
+    VALUES = "values"
+    for group in limit_groups:
+        values = group[VALUES]
+
+        if hits is None:
+            hits = numpy.ones(len(values), bool)
+        elif len(hits) < len(values):
+            temp = numpy.ones(len(values), bool)
+            temp[~hits] = False
+            hits = temp
+        low_limit = group[MIN_LIM]
+        high_limit = group[MAX_LIM]
+        if low_limit is not None:
+            hits[values < low_limit] = False
+        if high_limit is not None:
+            hits[values > high_limit] = False
+    assert hits is not None
+    indexes = numpy.argwhere(hits)[:, 0]
+    indexes = indexes + 1
+    return indexes
+
+
+def keep_by_rules(scores: NDArray[numpy.float64], rules_class: int) -> NDArray[numpy.int_]:
+    """Return the indexes (base 1) of objects whose highest-scoring class is rules_class
+
+    scores - an MxN matrix as returned by Rules.score(): M objects x N classes.
+             The Rules object itself is never passed into the library, only
+             the plain scores it produces.
+    rules_class - the 0-based class index to keep
+    """
+    if len(scores) == 0:
+        return numpy.array([], int)
+    is_not_nan = numpy.any(~numpy.isnan(scores), 1)
+    best_class = numpy.argmax(scores[is_not_nan], 1).flatten()
+    hits = numpy.zeros(scores.shape[0], bool)
+    hits[is_not_nan] = best_class == rules_class
+    return numpy.argwhere(hits).flatten() + 1
+
+
+def keep_by_hits(hits: NDArray[numpy.bool_]) -> NDArray[numpy.int_]:
+    """Return the indexes (base 1) of objects for which hits is True
+
+    Used for classifier predictions (predicted_classes == target_class) -
+    the classifier object itself is never passed into the library, only the
+    resulting boolean hits it produces.
+    """
+    return numpy.argwhere(hits).flatten() + 1
+
+
+def discard_border_objects(labels: ObjectSegmentation, parent_image_mask: Optional[NDArray[numpy.bool_]]) -> List[int]:
+    """
+    Return an array containing the object numbers to keep
+
+    labels - segmentation of the objects being filtered
+    parent_image_mask - mask of the parent image (or None); objects touching its border are discarded
+    """
+
+    if parent_image_mask is not None:
+        mask = parent_image_mask
+        interior_pixels = scipy.ndimage.binary_erosion(mask)
+
+    else:
+        interior_pixels = scipy.ndimage.binary_erosion(numpy.ones_like(labels))
+
+    border_pixels = numpy.logical_not(interior_pixels)
+    border_labels = set(labels[border_pixels])
+    if (border_labels == {0} and parent_image_mask):
+        # The assumption here is that, if nothing touches the border,
+        # the mask is a large, elliptical mask that tells you where the
+        # well is. That's the way the old Matlab code works and it's duplicated here
+        #
+        # The operation below gets the mask pixels that are on the border of the mask
+        # The erosion turns all pixels touching an edge to zero. The not of this
+        # is the border + formerly masked-out pixels.
+
+        mask = parent_image_mask
+        interior_pixels = scipy.ndimage.binary_erosion(mask)
+        border_pixels = numpy.logical_not(interior_pixels)
+        border_labels = set(labels[border_pixels])
+
+    return list(set(labels.ravel()).difference(border_labels))
+
+
+def get_filtered_object(
+        src_objects_segmented: ObjectSegmentation,
+        indexes: Union[NDArray[numpy.int_], List[int]],
+        label_indexes: Optional[NDArray[numpy.int_]],
+        max_label: int,
+        parent_objects: Optional[NDArray[numpy.int_]],
+        keep_unassociated_objects: bool,
+    ) -> ObjectSegmentation:
+    """
+    Relabel a segmentation so it keeps only the filtered objects
+
+    src_objects_segmented - segmentation to filter and relabel
+    indexes - object numbers (base 1) to keep
+    label_indexes - mapping from old label to new label, or None to build it from indexes
+    max_label - highest label value in src_objects_segmented
+    parent_objects - parent object number per object, or None if unrelated to a parent
+    keep_unassociated_objects - whether to keep objects that have no parent
+    """
+    if label_indexes is None:
+        new_object_count = len(indexes)
+        label_indexes = numpy.zeros((max_label + 1,), int)
+        label_indexes[indexes] = numpy.arange(1, new_object_count + 1)
+
+    #
+    # Reindex the labels of the old source image
+    #
+    target_objects_segmented = reindex_labels(src_objects_segmented, max_label, label_indexes, parent_objects, keep_unassociated_objects)
+
+    return target_objects_segmented
+
+def reindex_labels(
+        src_objects_segmented: ObjectSegmentation,
+        max_label: int,
+        label_indexes: NDArray[numpy.int_],
+        parent_objects: Optional[NDArray[numpy.int_]],
+        keep_unassociated_objects: bool,
+    ) -> ObjectSegmentation:
+    """
+    Reindex a segmentation, dropping objects whose new label is 0
+
+    src_objects_segmented - segmentation to relabel
+    max_label - highest label value of the filtered object
+    label_indexes - mapping from old label to new label (0 removes the object)
+    parent_objects - parent object number per object, or None if unrelated to a parent
+    keep_unassociated_objects - whether to keep objects that have no parent
+    """
+    target_labels = src_objects_segmented.copy()
+    if parent_objects is None:
+        target_labels[target_labels > max_label] = 0
+        target_labels = label_indexes[target_labels]
+    else:
+        # Initialize target labels to keep all child objects
+        target_label_numbers = numpy.arange(1, target_labels.max() + 1)
+
+        orphan_children = target_label_numbers[parent_objects == 0]
+
+        # label == 0 indicates parent object has to be removed
+        objects_to_remove = numpy.arange(max_label+1)[label_indexes == 0][1:] # ignore the first zero as it is the background
+
+        # object is removed by setting its new label to zero
+        target_label_numbers = target_label_numbers*~numpy.isin(parent_objects, objects_to_remove)
+
+        new_child_object_count = sum(target_label_numbers != 0)
+
+        # orphan children get new labels. Labels are always continuous and start at 1
+        target_label_numbers[target_label_numbers != 0] = numpy.arange(1, new_child_object_count + 1)
+
+        # Add zero for background label
+        target_label_numbers = numpy.pad(target_label_numbers, (1, 0))
+
+        # Overwrite orphan children new labels with 0 to remove unassociated objects
+        if not keep_unassociated_objects:
+            target_label_numbers[orphan_children] = 0
+
+        # Numpy fancy indexing to relabel
+        target_labels = target_label_numbers[target_labels]
+
+    return target_labels
+
+def get_removed_objects(
+        indexes: Union[NDArray[numpy.int_], List[int]],
+        max_label: int,
+        src_objects_segmented: ObjectSegmentation,
+    ) -> ObjectSegmentation:
+    """
+    Return a segmentation containing only the objects removed by the filter
+
+    indexes - object numbers (base 1) that were kept
+    max_label - highest label value in src_objects_segmented
+    src_objects_segmented - the original, unfiltered segmentation
+    """
+    removed_labels = src_objects_segmented.copy()
+    # Isolate objects removed by the filter
+    removed_indexes = [x for x in range(1, max_label+1) if x not in indexes]
+    removed_object_count = len(removed_indexes)
+    removed_label_indexes = numpy.zeros((max_label + 1,), int)
+    removed_label_indexes[removed_indexes] = numpy.arange(1, removed_object_count + 1)
+
+    #
+    # Reindex the labels of the old source image
+    #
+    removed_labels[removed_labels > max_label] = 0
+    removed_labels = removed_label_indexes[removed_labels]
+
+    return removed_labels