spatialproteomics 0.8.2__tar.gz → 0.8.4__tar.gz

{spatialproteomics-0.8.2/spatialproteomics.egg-info → spatialproteomics-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spatialproteomics
-Version: 0.8.2
+Version: 0.8.4
 Summary: Spatialproteomics is an interoperable toolbox for analyzing highly multiplexed fluorescence image data
 Author: Matthias Meyer-Bender, Harald Vohringer
 Requires-Python: >=3.10

{spatialproteomics-0.8.2 → spatialproteomics-0.8.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spatialproteomics"
-version = "0.8.2"
+version = "0.8.4"
 description = "Spatialproteomics is an interoperable toolbox for analyzing highly multiplexed fluorescence image data"
 readme = "README.md"
 requires-python = ">=3.10"

{spatialproteomics-0.8.2 → spatialproteomics-0.8.4}/spatialproteomics/la/label.py

@@ -76,6 +76,7 @@ def threshold_labels(
 def predict_cell_types_argmax(
     sdata,
     marker_dict: dict,
+    min_intensity: float = 0.0,
     table_key: str = SDLayers.TABLE,
     label_key: str = SDFeatures.LABELS,
     copy: bool = False,
@@ -90,6 +91,7 @@ def predict_cell_types_argmax(
     Args:
         sdata (spatialdata.SpatialData): The spatialdata object containing the expression matrix.
         marker_dict (dict): A dictionary containing the marker genes for each cell type.
+        min_intensity (float, optional): The minimum intensity threshold for assigning cells to a type. Cells with all marker intensities below this threshold will be assigned to "Unlabeled". Defaults to 0.0.
         table_key (str, optional): The key under which the expression matrix is stored in the tables attribute of the spatialdata object. Defaults to "table".
         label_key (str, optional): The key under which the cell type labels are stored in the obs attribute of the spatialdata object. Defaults to "celltype".
         copy (bool, optional): Whether to create a copy of the spatialdata object. Defaults to False.
@@ -102,7 +104,9 @@ def predict_cell_types_argmax(
     assert (
         len(set(marker_dict.keys()) - set(expression_df.columns)) == 0
     ), f"The following markers were not found in quantification layer: {set(marker_dict.keys()) - set(expression_df.columns)}."
-    celltypes = _predict_cell_types_argmax(expression_df, list(marker_dict.keys()), list(marker_dict.values()))
+    celltypes = _predict_cell_types_argmax(
+        expression_df, list(marker_dict.keys()), list(marker_dict.values()), min_intensity=min_intensity
+    )
     adata.obs[label_key] = celltypes
     adata.obs[label_key] = adata.obs[label_key].astype("category")
 
@@ -792,6 +796,7 @@ class LabelAccessor:
         overwrite_existing_labels: bool = False,
         cell_col: str = "cell",
         label_col: str = "label",
+        min_intensity: float = 0.0,
     ):
         """
         Predicts cell types based on the argmax classification of marker intensities.
@@ -802,6 +807,7 @@ class LabelAccessor:
             overwrite_existing_labels (bool, optional): Whether to overwrite existing labels. Defaults to False.
             cell_col (str, optional): The name of the column to store cell IDs in the output dataframe. Defaults to "cell".
             label_col (str, optional): The name of the column to store predicted cell types in the output dataframe. Defaults to "label".
+            min_intensity (float, optional): The minimum intensity threshold for assigning cells to a type. Defaults to 0.0.
 
         Returns:
             xr.Dataset: A new spatialproteomics object with the predicted cell types added as labels.
@@ -825,7 +831,10 @@ class LabelAccessor:
         obj = self._obj.copy()
 
         celltypes_argmax = _predict_cell_types_argmax(
-            pd.DataFrame(obj.pp[markers][key].values, columns=markers), markers=markers, celltypes=celltypes
+            pd.DataFrame(obj.pp[markers][key].values, columns=markers),
+            markers=markers,
+            celltypes=celltypes,
+            min_intensity=min_intensity,
         )
 
         # putting everything into a dataframe

{spatialproteomics-0.8.2 → spatialproteomics-0.8.4}/spatialproteomics/la/utils.py

@@ -4,6 +4,8 @@ import numpy as np
 import pandas as pd
 from skimage.segmentation import relabel_sequential
 
+from spatialproteomics.constants import Labels
+
 from ..base_logger import logger
 
 
@@ -160,11 +162,17 @@ def _predict_cell_types_argmax(
     expression_df: pd.DataFrame,
     markers: List,
     celltypes: List,
+    min_intensity: float = 0.0,
 ):
     # getting the argmax for each cell
     argmax_classification = np.argmax(expression_df[markers], axis=1)
 
     # translating the argmax classification into cell types
-    celltypes_argmax = np.array(celltypes)[argmax_classification]
+    celltypes_argmax = np.array(celltypes, dtype=object)[argmax_classification]
+
+    # if all markers are below the minimum intensity, assign UNASSIGNED
+    if min_intensity > 0.0:
+        below_threshold = (expression_df[markers].max(axis=1) < min_intensity).values
+        celltypes_argmax[below_threshold] = Labels.UNLABELED
 
     return celltypes_argmax

{spatialproteomics-0.8.2 → spatialproteomics-0.8.4}/spatialproteomics/pl/plot.py

@@ -1114,6 +1114,18 @@ class PlotAccessor:
             extent=bounds,
         )
 
+        # draw any pending boxes added via add_box()
+        for box in self._obj.attrs.pop("_pending_boxes", []):
+            rect = patches.Rectangle(
+                (box["xlim"][0], box["ylim"][0]),
+                box["xlim"][1] - box["xlim"][0],
+                box["ylim"][1] - box["ylim"][0],
+                edgecolor=box["color"],
+                linewidth=box["linewidth"],
+                facecolor="none",
+            )
+            ax.add_patch(rect)
+
         legend = []
 
         if legend_image:
@@ -1401,20 +1413,24 @@ class PlotAccessor:
         xr.Dataset
             The updated spatialproteomics object.
         """
-        if ax is None:
-            ax = plt.gca()
-
-        # Create a rectangle and add it to the axis
-        rect = patches.Rectangle(
-            (xlim[0], ylim[0]),  # Bottom-left corner
-            xlim[1] - xlim[0],  # Width
-            ylim[1] - ylim[0],  # Height
-            edgecolor=color,
-            linewidth=linewidth,
-            facecolor="none",  # Ensure it's just an outline
-        )
-        ax.add_patch(rect)
-
+        if ax is not None:
+            # existing immediate-draw behaviour when ax is explicit
+            rect = patches.Rectangle(
+                (xlim[0], ylim[0]),  # bottom left corner
+                xlim[1] - xlim[0],  # width
+                ylim[1] - ylim[0],  # height
+                edgecolor=color,
+                linewidth=linewidth,
+                facecolor="none",
+            )
+            ax.add_patch(rect)
+            return self._obj
+
+        # no ax provided: defer rendering by storing box params in the dataset attrs
+        # the boxes are then rendered in pl.imshow() when the plot is drawn
+        pending = list(self._obj.attrs.get("_pending_boxes", []))
+        pending.append(dict(xlim=xlim, ylim=ylim, color=color, linewidth=linewidth))
+        self._obj.attrs["_pending_boxes"] = pending
         return self._obj
 
     def autocrop(

{spatialproteomics-0.8.2 → spatialproteomics-0.8.4}/spatialproteomics/pp/utils.py

@@ -602,12 +602,12 @@ def _threshold(
     if (quantile is None and intensity is None) or (quantile is not None and intensity is not None):
         raise ValueError("Please provide a quantile or absolute intensity cut off.")
 
-    if isinstance(quantile, (float, int)):
+    if isinstance(quantile, (float, int, np.generic)):
         quantile = np.array([quantile])
     if isinstance(quantile, list):
         quantile = np.array(quantile)
 
-    if isinstance(intensity, (float, int)):
+    if isinstance(intensity, (float, int, np.generic)):
         intensity = np.array([intensity])
     if isinstance(intensity, list):
         intensity = np.array(intensity)
@@ -626,68 +626,106 @@ def _threshold(
         if quantile is not None:
             assert len(channels) == len(quantile), "The number of channels must match the number of quantile values."
             quantile_dict = dict(zip(channels, quantile))
-            quantile = np.array([quantile_dict.get(channel, 0) for channel in all_channels])
+            # we cannot just use 0 in the get() here, because the minimum intensity of a marker might be above 0,
+            # #in which case we would be thresholding the wrong value. Instead, we use np.nan and then check for this later on.
+            quantile = np.array([quantile_dict.get(channel, np.nan) for channel in all_channels])
         if intensity is not None:
             assert len(channels) == len(intensity), "The number of channels must match the number of intensity values."
             intensity_dict = dict(zip(channels, intensity))
-            intensity = np.array([intensity_dict.get(channel, 0) for channel in all_channels])
+            intensity = np.array([intensity_dict.get(channel, np.nan) for channel in all_channels])
     else:
         # If no channels provided, assume the threshold applies to all channels
         if quantile is not None:
             assert len(quantile) == 1 or len(quantile) == len(
                 all_channels
             ), "Quantile threshold must be a single value or a list of values with the same length as the number of channels. If you only want to threshold a subset of channels, you can use the channels argument."
-            quantile = np.full(len(all_channels), quantile.item() if quantile.size == 1 else quantile)
         if intensity is not None:
             assert len(intensity) == 1 or len(intensity) == len(
                 all_channels
             ), "Intensity threshold must be a single value or a list of values with the same length as the number of channels. If you only want to threshold a subset of channels, you can use the channels argument."
             assert np.all(intensity >= 0), "Intensity values must be positive."
-            assert np.all(
-                intensity <= np.max(image.values)
-            ), "Intensity values must be smaller than the maximum intensity."
-            intensity = np.full(len(all_channels), intensity.item() if intensity.size == 1 else intensity)
+
+    # Get underlying numpy array and its dtype
+    img = image.values  # shape (C, Y, X)
+    img_dtype = img.dtype
 
     if quantile is not None:
-        assert np.all(quantile >= 0) and np.all(quantile <= 1), "Quantile values must be between 0 and 1."
+        if quantile.size == 1:
+            quantile = np.full(len(all_channels), quantile.item(), dtype=float)
+        else:
+            quantile = np.asarray(quantile, dtype=float)
 
-        if shift:
-            # calculate quantile (and ensure the correct dtypes in order to be more memory-efficient)
-            # this is done by first clipping the values below the lower value, and subsequently subtracting the lower value from the result, which allows us to use the original dtype throughout
-            lower = np.quantile(image.values.reshape(image.values.shape[0], -1), quantile, axis=1).astype(image.dtype)
-
-            filtered = np.clip(
-                image, a_min=np.expand_dims(np.diag(lower) if lower.ndim > 1 else lower, (1, 2)), a_max=None
-            ).astype(image.dtype) - np.expand_dims(np.diag(lower) if lower.ndim > 1 else lower, (1, 2)).astype(
-                image.dtype
-            )
+    if intensity is not None:
+        if intensity.size == 1:
+            intensity = np.full(len(all_channels), intensity.item(), dtype=img_dtype)
         else:
-            # Calculate the quantile-based intensity threshold for each channel.
-            flattened_values = image.values.reshape(
-                image.values.shape[0], -1
-            )  # Flatten height and width for each channel.
-            lower = np.array(
-                [np.quantile(flattened_values[i], q) for i, q in enumerate(quantile)]
-            )  # Compute quantile per channel.
+            # casting to float here to allow for NAs (important when using the channels argument)
+            intensity = np.asarray(intensity, dtype=float)
+
+        max_val = np.max(img)
+        assert np.all(
+            intensity[~np.isnan(intensity)] <= max_val
+        ), "Intensity values must be smaller than the maximum intensity."
 
-            # Reshape lower to match the broadcasting requirements.
-            lower = lower[:, np.newaxis, np.newaxis]  # Reshape to add height and width dimensions.
+    filtered = None
 
-            # Use np.where to apply the quantile threshold without shifting.
-            filtered = np.where(image.values >= lower, image.values, 0)
+    # --- QUANTILE BRANCH ---
+    if quantile is not None:
+        assert np.all(quantile[~np.isnan(quantile)] >= 0) and np.all(
+            quantile[~np.isnan(quantile)] <= 1
+        ), "Quantile values must be between 0 and 1."
 
+        flat = img.reshape(img.shape[0], -1)
+        lower = np.array([np.quantile(flat[i], q) if not np.isnan(q) else 0.0 for i, q in enumerate(quantile)]).astype(
+            img_dtype
+        )
+
+        lower = lower[:, np.newaxis, np.newaxis]
+        filtered = np.empty_like(img)
+
+        if shift:
+            for c in range(img.shape[0]):
+                lc = lower[c, 0, 0]
+                if np.isnan(quantile[c]):  # no-op channel: copy as-is
+                    np.copyto(filtered[c], img[c])
+                else:
+                    np.maximum(img[c], lc, out=filtered[c])
+                    filtered[c] -= lc
+        else:
+            for c in range(img.shape[0]):
+                lc = lower[c, 0, 0]
+                np.copyto(filtered[c], img[c])
+                if not np.isnan(quantile[c]):  # only threshold specified channels
+                    mask = filtered[c] < lc
+                    filtered[c][mask] = img_dtype.type(0)
+
+    # --- INTENSITY BRANCH (dtype-safe & channel-wise) ---
     if intensity is not None:
+        base = img if filtered is None else filtered
+        result = np.empty_like(base)
+        n_channels = base.shape[0]
+
         if shift:
-            # calculate intensity
-            filtered = (image - intensity.reshape(-1, 1, 1)).clip(min=0)
+            for c in range(n_channels):
+                if np.isnan(intensity[c]):  # no-op channel
+                    np.copyto(result[c], base[c])
+                else:
+                    thr = img_dtype.type(intensity[c])
+                    np.maximum(base[c], thr, out=result[c])
+                    result[c] -= thr
         else:
-            # Reshape intensity to broadcast correctly across all dimensions.
-            if len(intensity) == 1:
-                intensity = intensity[0]  # This will make it a scalar for simple broadcasting.
-            else:
-                intensity = intensity[:, np.newaxis, np.newaxis]  # Add two new axes for broadcasting.
-            # Apply thresholding: set all values below the intensity threshold to 0.
-            filtered = np.where(image.values >= intensity, image.values, 0)
+            zero = img_dtype.type(0)
+            for c in range(n_channels):
+                np.copyto(result[c], base[c])
+                if not np.isnan(intensity[c]):  # only threshold specified channels
+                    thr = img_dtype.type(intensity[c])
+                    mask = result[c] < thr
+                    result[c][mask] = zero
+
+        filtered = result
+
+    if filtered is None:
+        raise RuntimeError("Internal error: neither quantile nor intensity branch produced a result.")
 
     return filtered
 

{spatialproteomics-0.8.2 → spatialproteomics-0.8.4/spatialproteomics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spatialproteomics
-Version: 0.8.2
+Version: 0.8.4
 Summary: Spatialproteomics is an interoperable toolbox for analyzing highly multiplexed fluorescence image data
 Author: Matthias Meyer-Bender, Harald Vohringer
 Requires-Python: >=3.10

{spatialproteomics-0.8.2 → spatialproteomics-0.8.4}/tests/test_to_zarr.py

@@ -7,7 +7,7 @@ def test_to_zarr_image(ds_image):
     with tempfile.TemporaryDirectory() as temp_dir:
         output_path = os.path.join(temp_dir, "zarr_writing_test.zarr")
         try:
-            ds_image.drop_encoding().to_zarr(output_path)
+            ds_image.drop_encoding().to_zarr(output_path, consolidated=False)
             assert os.path.exists(output_path) and os.path.isdir(
                 output_path
             ), f"Directory {output_path} was not created."
@@ -21,7 +21,7 @@ def test_to_zarr_segmentation(ds_segmentation):
     with tempfile.TemporaryDirectory() as temp_dir:
         output_path = os.path.join(temp_dir, "zarr_writing_test.zarr")
         try:
-            ds_segmentation.drop_encoding().to_zarr(output_path)
+            ds_segmentation.drop_encoding().to_zarr(output_path, consolidated=False)
             assert os.path.exists(output_path) and os.path.isdir(
                 output_path
             ), f"Directory {output_path} was not created."
@@ -35,7 +35,7 @@ def test_to_zarr_labels(ds_labels):
     with tempfile.TemporaryDirectory() as temp_dir:
         output_path = os.path.join(temp_dir, "zarr_writing_test.zarr")
         try:
-            ds_labels.drop_encoding().to_zarr(output_path)
+            ds_labels.drop_encoding().to_zarr(output_path, consolidated=False)
             assert os.path.exists(output_path) and os.path.isdir(
                 output_path
             ), f"Directory {output_path} was not created."
@@ -49,7 +49,7 @@ def test_to_zarr_neighborhoods(ds_neighborhoods):
     with tempfile.TemporaryDirectory() as temp_dir:
         output_path = os.path.join(temp_dir, "zarr_writing_test.zarr")
         try:
-            ds_neighborhoods.drop_encoding().to_zarr(output_path)
+            ds_neighborhoods.drop_encoding().to_zarr(output_path, consolidated=False)
             assert os.path.exists(output_path) and os.path.isdir(
                 output_path
             ), f"Directory {output_path} was not created."