Follow-ups from the coding session on 2025-03-11

src/imcflibs/imagej/bioformats.py

@@ -289,3 +289,243 @@
     reader = Memoizer(ImageReader())
     reader.setId(path_to_file)
     reader.close()
+
+
+def get_metadata_from_file(path_to_image):
+    """Extract metadata from an image file using Bio-Formats.
+
+    This function reads an image file using the Bio-Formats library and extracts
+    various metadata properties including physical dimensions, pixel dimensions,
+    and other image characteristics.
+
+    Parameters
+    ----------
+    path_to_image : str or pathlib.Path
+        Path to the image file from which metadata should be extracted.
+
+    Returns
+    -------
+    dict
+        A dictionary containing the following metadata:
+
+            {
+                unit_width : float,  # physical width of a pixel
+                unit_height : float,  # physical height of a pixel
+                unit_depth : float,  # physical depth of a voxel
+                pixel_width : int,  # width of the image in pixels
+                pixel_height : int,  # height of the image in pixels
+                slice_count : int,  # number of Z-slices
+                channel_count : int,  # number of channels
+                timepoints_count : int,  # number of timepoints
+                dimension_order : str,  # order of dimensions, e.g. "XYZCT"
+                pixel_type : str,  # data type of the pixel values
+            }
+    """
+    reader = ImageReader()
+    ome_meta = MetadataTools.createOMEXMLMetadata()
+    reader.setMetadataStore(ome_meta)
+    reader.setId(str(path_to_image))
+
+    phys_size_x = ome_meta.getPixelsPhysicalSizeX(0)
+    phys_size_y = ome_meta.getPixelsPhysicalSizeY(0)
+    phys_size_z = ome_meta.getPixelsPhysicalSizeZ(0)
+    pixel_size_x = ome_meta.getPixelsSizeX(0)
+    pixel_size_y = ome_meta.getPixelsSizeY(0)
+    pixel_size_z = ome_meta.getPixelsSizeZ(0)
+    channel_count = ome_meta.getPixelsSizeC(0)
+    timepoints_count = ome_meta.getPixelsSizeT(0)
+    dimension_order = ome_meta.getPixelsDimensionOrder(0)
+    pixel_type = ome_meta.getPixelsType(0)
+
+    image_calibration = {
+        "unit_width": phys_size_x.value(),
+        "unit_height": phys_size_y.value(),
+        "unit_depth": phys_size_z.value(),
+        "pixel_width": pixel_size_x.getNumberValue(),
+        "pixel_height": pixel_size_y.getNumberValue(),
+        "slice_count": pixel_size_z.getNumberValue(),
+        "channel_count": channel_count.getNumberValue(),
+        "timepoints_count": timepoints_count.getNumberValue(),
+        "dimension_order": dimension_order,
+        "pixel_type": pixel_type,
+    }
+
+    reader.close()
+
+    return image_calibration
+
+
+def get_stage_coords(source, filenames):
+    """Get stage coordinates and calibration for a given list of images.
+
+    Parameters
+    ----------
+    source : str
+        Path to the images.
+    filenames : list of str
+        List of images filenames.
+
+    Returns
+    -------
+    dict
+
+        {
+            dimensions : int,  # number of dimensions (2D or 3D)
+            stage_coordinates_x : list,  # absolute stage x-coordinated
+            stage_coordinates_y : list,  # absolute stage y-coordinated
+            stage_coordinates_z : list,  # absolute stage z-coordinated
+            relative_coordinates_x : list,  # relative stage x-coordinates in px
+            relative_coordinates_y : list,  # relative stage y-coordinates in px
+            relative_coordinates_z : list,  # relative stage z-coordinates in px
+            image_calibration : list,  # x,y,z image calibration in unit/px
+            calibration_unit : str,  # image calibration unit
+            image_dimensions_czt : list,  # number of images in dimensions c,z,t
+            series_names : list of str,  # names of all series in the files
+            max_size : list of int,  # max size (x/y/z) across all files
+        }
+    """
+
+    # open an array to store the abosolute stage coordinates from metadata
+    stage_coordinates_x = []
+    stage_coordinates_y = []
+    stage_coordinates_z = []
+    series_names = []
+
+    for counter, image in enumerate(filenames):
+        # parse metadata
+        reader = ImageReader()
+        reader.setFlattenedResolutions(False)
+        omeMeta = MetadataTools.createOMEXMLMetadata()
+        reader.setMetadataStore(omeMeta)
+        reader.setId(source + str(image))
+        series_count = reader.getSeriesCount()
+
+        # get hyperstack dimensions from the first image
+        if counter == 0:
+            frame_size_x = reader.getSizeX()
+            frame_size_y = reader.getSizeY()
+            frame_size_z = reader.getSizeZ()
+            frame_size_c = reader.getSizeC()
+            frame_size_t = reader.getSizeT()
+
+            # note the dimensions
+            if frame_size_z == 1:
+                dimensions = 2
+            if frame_size_z > 1:
+                dimensions = 3
+
+            # get the physical calibration for the first image series
+            physSizeX = omeMeta.getPixelsPhysicalSizeX(0)
+            physSizeY = omeMeta.getPixelsPhysicalSizeY(0)
+            physSizeZ = omeMeta.getPixelsPhysicalSizeZ(0)
+
+            # workaround to get the z-interval if physSizeZ.value() returns None.
+            z_interval = 1
+            if physSizeZ is not None:
+                z_interval = physSizeZ.value()
+
+            if frame_size_z > 1 and physSizeZ is None:
+                log.debug("no z calibration found, trying to recover")
+                first_plane = omeMeta.getPlanePositionZ(0, 0)
+                next_plane_imagenumber = frame_size_c + frame_size_t - 1
+                second_plane = omeMeta.getPlanePositionZ(0, next_plane_imagenumber)
+                z_interval = abs(abs(first_plane.value()) - abs(second_plane.value()))
+                log.debug("z-interval seems to be: " + str(z_interval))
+
+            # create an image calibration
+            image_calibration = [
+                physSizeX.value(),
+                physSizeY.value(),
+                z_interval,
+            ]
+            calibration_unit = physSizeX.unit().getSymbol()
+            image_dimensions_czt = [
+                frame_size_c,
+                frame_size_z,
+                frame_size_t,
+            ]
+
+        reader.close()
+
+        for series in range(series_count):
+            if omeMeta.getImageName(series) == "macro image":
+                continue
+
+            if series_count > 1 and not str(image).endswith(".vsi"):
+                series_names.append(omeMeta.getImageName(series))
+            else:
+                series_names.append(str(image))
+            # get the plane position in calibrated units
+            current_position_x = omeMeta.getPlanePositionX(series, 0)
+            current_position_y = omeMeta.getPlanePositionY(series, 0)
+            current_position_z = omeMeta.getPlanePositionZ(series, 0)
+
+            physSizeX_max = (
+                physSizeX.value()
+                if physSizeX.value() >= omeMeta.getPixelsPhysicalSizeX(series).value()
+                else omeMeta.getPixelsPhysicalSizeX(series).value()
+            )
+            physSizeY_max = (
+                physSizeY.value()
+                if physSizeY.value() >= omeMeta.getPixelsPhysicalSizeY(series).value()
+                else omeMeta.getPixelsPhysicalSizeY(series).value()
+            )
+            if omeMeta.getPixelsPhysicalSizeZ(series):
+                physSizeZ_max = (
+                    physSizeZ.value()
+                    if physSizeZ.value()
+                    >= omeMeta.getPixelsPhysicalSizeZ(series).value()
+                    else omeMeta.getPixelsPhysicalSizeZ(series).value()
+                )
+
+            else:
+                physSizeZ_max = 1.0
+
+            # get the absolute stage positions and store them
+            pos_x = current_position_x.value()
+            pos_y = current_position_y.value()
+
+            if current_position_z is None:
+                log.debug("the z-position is missing in the ome-xml metadata.")
+                pos_z = 1.0
+            else:
+                pos_z = current_position_z.value()
+
+            stage_coordinates_x.append(pos_x)
+            stage_coordinates_y.append(pos_y)
+            stage_coordinates_z.append(pos_z)
+
+    max_size = [physSizeX_max, physSizeY_max, physSizeZ_max]
+
+    # calculate the store the relative stage movements in px (for the grid/collection stitcher)
+    relative_coordinates_x_px = []
+    relative_coordinates_y_px = []
+    relative_coordinates_z_px = []
+
+    for i in range(len(stage_coordinates_x)):
+        rel_pos_x = (
+            stage_coordinates_x[i] - stage_coordinates_x[0]
+        ) / physSizeX.value()
+        rel_pos_y = (
+            stage_coordinates_y[i] - stage_coordinates_y[0]
+        ) / physSizeY.value()
+        rel_pos_z = (stage_coordinates_z[i] - stage_coordinates_z[0]) / z_interval
+
+        relative_coordinates_x_px.append(rel_pos_x)
+        relative_coordinates_y_px.append(rel_pos_y)
+        relative_coordinates_z_px.append(rel_pos_z)
+
+    return {
+        "dimensions": dimensions,
+        "stage_coordinates_x": stage_coordinates_x,
+        "stage_coordinates_y": stage_coordinates_y,
+        "stage_coordinates_z": stage_coordinates_z,
+        "relative_coordinates_x": relative_coordinates_x_px,
+        "relative_coordinates_y": relative_coordinates_y_px,
+        "relative_coordinates_z": relative_coordinates_z_px,
+        "image_calibration": image_calibration,
+        "calibration_unit": calibration_unit,
+        "image_dimensions_czt": image_dimensions_czt,
+        "series_names": series_names,
+        "max_size": max_size,
+    }

src/imcflibs/imagej/labelimage.py

@@ -2,7 +2,7 @@
 
 """Functions to work with ImageJ label images."""
 
-from ij import IJ, ImagePlus, Prefs, ImageStack
+from ij import IJ, ImagePlus, ImageStack, Prefs
 from ij.plugin import Duplicator, ImageCalculator
 from ij.plugin.filter import ThresholdToSelection
 from ij.process import FloatProcessor, ImageProcessor
@@ -67,7 +67,7 @@
     return roi_list, max_value
 
 
-def relate_label_images(label_image_ref, label_image_to_relate):
+def cookie_cut_labels(label_image_ref, label_image_to_relate):
     """Relate label images, giving the same label to objects belonging together.
 
     ❗ NOTE: Won't work with touching labels ❗
@@ -97,6 +97,57 @@
     return ImageCalculator.run(label_image_ref, imp_dup, "Multiply create")
 
 
+def relate_label_images(outer_label_imp, inner_label_imp):
+    """Relate label images, giving the same label to objects belonging together.
+
+    Given two label images, this function will create a new label image with the
+    same labels as the reference image, but with the objects of the second image
+    using the 3D Association plugin from the 3DImageJSuite.
+
+    Parameters
+    ----------
+    outer_label_imp : ij.ImagePlus
+        The outer label image.
+    inner_label_imp : ij.ImagePlus
+        The inner label image.
+
+    Returns
+    -------
+    related_inner_imp : ij.ImagePlus
+        The related inner label image.
+
+    Notes
+    -----
+    Unlike `cookie_cut_labels`, this should work with touching labels by using
+    MereoTopology algorithms.
+    """
+
+    outer_label_imp.show()
+    inner_label_imp.show()
+
+    outer_title = outer_label_imp.getTitle()
+    inner_title = inner_label_imp.getTitle()
+
+    IJ.run(
+        "3D Association",
+        "image_a="
+        + outer_title
+        + " "
+        + "image_b="
+        + inner_title
+        + " "
+        + "method=Colocalisation min=1 max=0.000",
+    )
+
+    related_inner_imp = IJ.getImage()
+
+    outer_label_imp.hide()
+    inner_label_imp.hide()
+    related_inner_imp.hide()
+
+    return related_inner_imp
+
+
 def filter_objects(label_image, table, string, min_val, max_val):
     """Filter labels based on specific min and max values.
 
@@ -182,11 +233,11 @@
 
     # Set the minimum size for labeling if provided
     if min_vol:
-        labeler.setMinSize(min_vol)
+        labeler.setMinSizeCalibrated(min_vol)
 
     # Set the maximum size for labeling if provided
     if max_vol:
-        labeler.setMaxSize(max_vol)
+        labeler.setMinSizeCalibrated(max_vol)
 
     # Get the labeled image
     seg = labeler.getLabels(img)
@@ -229,17 +280,7 @@
         current_imp = Duplicator().run(imp, 1, 1, i, imp.getNSlices(), 1, 1)
 
         # Perform a dilation of the labels in the current slice
-        IJ.run(
-            current_imp,
-            "Label Morphological Filters",
-            "operation=Dilation radius=" + str(dilation_radius) + " from_any_label",
-        )
-
-        # Get the dilated labels
-        dilated_labels_imp = IJ.getImage()
-
-        # Hide the dilated labels to avoid visual clutter
-        dilated_labels_imp.hide()
+        dilated_labels_imp = li.dilateLabels(current_imp, dilation_radius)
 
         # Append the dilated labels to the list
         dilated_labels_list.append(dilated_labels_imp)