spatialproteomics 0.8.2__tar.gz → 0.8.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spatialproteomics
-Version: 0.8.2
+Version: 0.8.3
 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.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spatialproteomics"
-version = "0.8.2"
+version = "0.8.3"
 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.3}/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.3}/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,104 @@ 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.
+            # cast each provided value to image dtype
+            intensity = np.asarray(intensity, dtype=img_dtype)
+
+        max_val = np.max(img)
+        assert np.all(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.3/spatialproteomics.egg-info}/PKG-INFO

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