spatialproteomics 0.8.4__tar.gz → 0.8.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spatialproteomics
-Version: 0.8.4
+Version: 0.8.6
 Summary: Spatialproteomics is an interoperable toolbox for analyzing highly multiplexed fluorescence image data
 Author: Matthias Meyer-Bender, Harald Vohringer
 Requires-Python: >=3.10
@@ -33,6 +33,8 @@ Provides-Extra: anndata
 Requires-Dist: anndata; extra == "anndata"
 Provides-Extra: astir
 Requires-Dist: astir>=0.1.5; extra == "astir"
+Provides-Extra: spotiflow
+Requires-Dist: spotiflow; extra == "spotiflow"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.1.2; extra == "dev"
 Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
@@ -41,6 +43,7 @@ Requires-Dist: isort>=5.10.1; extra == "dev"
 Requires-Dist: flake8>=5.0.4; extra == "dev"
 Requires-Dist: bandit>=1.7.4; extra == "dev"
 Requires-Dist: safety>=2.1.1; extra == "dev"
+Requires-Dist: typing_extensions>=4.16; extra == "dev"
 Provides-Extra: all
 Requires-Dist: spatialdata; extra == "all"
 Requires-Dist: cellpose; extra == "all"
@@ -60,7 +63,7 @@ Dynamic: license-file
 
 ## Principles
 
-Multiplexed imaging data comprises at least 3 dimensions (i.e. `channels`, `x`, and `y`) and has often additional data such as segmentation masks or cell type annotations associated with it. In `spatialproteomics`, we use `xarray` to create a data structure that keeps all of these data dimension in sync. This data structure can then be used to apply all sorts of operations to the data. Users can segment cells, perform different image processing steps, quantify protein expression, predict cell types, and plot their data in various ways. By providing researchers with those tools, `spatialproteomics` can be used to quickly explore highly multiplexed spatial proteomics data directly within jupyter notebooks.
+Multiplexed imaging data comprises at least 3 dimensions (i.e. `channels`, `x`, and `y`) and often contains additional data such as segmentation masks or cell type annotations associated with it. In `spatialproteomics`, we use `xarray` to create a data structure that keeps all of these data dimension in sync. This data structure can then be used to apply all sorts of operations to the data. Users can segment cells, perform different image processing steps, quantify protein expression, predict cell types, and plot their data in various ways. By providing researchers with those tools, `spatialproteomics` can be used to quickly explore highly multiplexed spatial proteomics data directly within jupyter notebooks.
 
 <p align="center" width="100%">
     <img src="docs/_static/img/supplementary_figure_1.png" alt="The spatialproteomics data structure enables synchronized subsetting across shared dimensions." style="width:70%;">
@@ -97,8 +100,4 @@ matplotlib
 ```
 
 ## Citation
-Spatialproteomics - an interoperable toolbox for analyzing highly multiplexed fluorescence image data
-
-Matthias Fabian Meyer-Bender, Harald Sager Voehringer, Christina Schniederjohann, Sarah Patricia Koziel, Erin Kim Chung, Ekaterina Popova, Alexander Brobeil, Lisa-Maria Held, Aamir Munir, Scverse Community, Sascha Dietrich, Peter-Martin Bruch, Wolfgang Huber
-
-bioRxiv 2025.04.29.651202; doi: https://doi.org/10.1101/2025.04.29.651202
+> Meyer-Bender, M., Voehringer, H., Schniederjohann, C., Koziel, S., Chung, E., Popova, E., ... & Huber, W. (2026). Spatialproteomics: an interoperable toolbox for analyzing highly multiplexed fluorescence image data. Nature Methods, 1-10.

{spatialproteomics-0.8.4 → spatialproteomics-0.8.6}/README.md

@@ -10,7 +10,7 @@
 
 ## Principles
 
-Multiplexed imaging data comprises at least 3 dimensions (i.e. `channels`, `x`, and `y`) and has often additional data such as segmentation masks or cell type annotations associated with it. In `spatialproteomics`, we use `xarray` to create a data structure that keeps all of these data dimension in sync. This data structure can then be used to apply all sorts of operations to the data. Users can segment cells, perform different image processing steps, quantify protein expression, predict cell types, and plot their data in various ways. By providing researchers with those tools, `spatialproteomics` can be used to quickly explore highly multiplexed spatial proteomics data directly within jupyter notebooks.
+Multiplexed imaging data comprises at least 3 dimensions (i.e. `channels`, `x`, and `y`) and often contains additional data such as segmentation masks or cell type annotations associated with it. In `spatialproteomics`, we use `xarray` to create a data structure that keeps all of these data dimension in sync. This data structure can then be used to apply all sorts of operations to the data. Users can segment cells, perform different image processing steps, quantify protein expression, predict cell types, and plot their data in various ways. By providing researchers with those tools, `spatialproteomics` can be used to quickly explore highly multiplexed spatial proteomics data directly within jupyter notebooks.
 
 <p align="center" width="100%">
     <img src="docs/_static/img/supplementary_figure_1.png" alt="The spatialproteomics data structure enables synchronized subsetting across shared dimensions." style="width:70%;">
@@ -47,8 +47,4 @@ matplotlib
 ```
 
 ## Citation
-Spatialproteomics - an interoperable toolbox for analyzing highly multiplexed fluorescence image data
-
-Matthias Fabian Meyer-Bender, Harald Sager Voehringer, Christina Schniederjohann, Sarah Patricia Koziel, Erin Kim Chung, Ekaterina Popova, Alexander Brobeil, Lisa-Maria Held, Aamir Munir, Scverse Community, Sascha Dietrich, Peter-Martin Bruch, Wolfgang Huber
-
-bioRxiv 2025.04.29.651202; doi: https://doi.org/10.1101/2025.04.29.651202
+> Meyer-Bender, M., Voehringer, H., Schniederjohann, C., Koziel, S., Chung, E., Popova, E., ... & Huber, W. (2026). Spatialproteomics: an interoperable toolbox for analyzing highly multiplexed fluorescence image data. Nature Methods, 1-10.

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

@@ -1,6 +1,6 @@
 [project]
 name = "spatialproteomics"
-version = "0.8.4"
+version = "0.8.6"
 description = "Spatialproteomics is an interoperable toolbox for analyzing highly multiplexed fluorescence image data"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -40,6 +40,7 @@ cellpose = ["cellpose>=3.1.0"]
 stardist = ["stardist>=0.9.1"]
 anndata = ["anndata"]
 astir = ["astir>=0.1.5"]
+spotiflow = ["spotiflow"]
 dev = [
     "pytest>=7.1.2",
     "pytest-cov>=3.0.0",
@@ -48,6 +49,7 @@ dev = [
     "flake8>=5.0.4",
     "bandit>=1.7.4",
     "safety>=2.1.1",
+    "typing_extensions>=4.16",  # to avoid anndata issues
 ]
 all = ["spatialdata", "cellpose", "stardist", "astir"]
 

{spatialproteomics-0.8.4 → spatialproteomics-0.8.6}/spatialproteomics/container.py

@@ -106,9 +106,6 @@ def load_image_data(
             if neighborhood is not None:
                 dataset = dataset.nh.add_neighborhoods_from_dataframe(neighborhood, neighborhood_col=neighborhood_col)
 
-    else:
-        dataset = xr.Dataset(data_vars={Layers.IMAGE: im})
-
     return dataset
 
 

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

@@ -797,6 +797,7 @@ class LabelAccessor:
         cell_col: str = "cell",
         label_col: str = "label",
         min_intensity: float = 0.0,
+        ignore_neighborhoods: bool = False,
     ):
         """
         Predicts cell types based on the argmax classification of marker intensities.
@@ -808,6 +809,7 @@ class LabelAccessor:
             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.
+            ignore_neighborhoods (bool, optional): Whether to remove existing neighborhoods when predicting cell types. Defaults to False.
 
         Returns:
             xr.Dataset: A new spatialproteomics object with the predicted cell types added as labels.
@@ -869,7 +871,7 @@ class LabelAccessor:
             obj = obj.pp.drop_layers(Layers.LA_PROPERTIES)
 
         # adding the new labels
-        return obj.la.add_labels_from_dataframe(celltype_prediction_df)
+        return obj.la.add_labels_from_dataframe(celltype_prediction_df, ignore_neighborhoods=ignore_neighborhoods)
 
     def _threshold_label(
         self, channel: str, threshold: float, layer_key: str = Layers.INTENSITY, label: Optional[str] = None

{spatialproteomics-0.8.4 → spatialproteomics-0.8.6}/spatialproteomics/pp/preprocessing.py

@@ -866,7 +866,7 @@ class PreprocessingAccessor:
             from_layer = segmentation
             segmentation = self._obj[segmentation].values.squeeze()
 
-        assert segmentation.ndim == 2, "A segmentation mask must 2 dimensional."
+        assert segmentation.ndim == 2, "A segmentation mask must be 2-dimensional."
         assert ~np.any(segmentation < 0), "A segmentation mask may not contain negative numbers."
 
         y_dim, x_dim = segmentation.shape
@@ -939,14 +939,14 @@ class PreprocessingAccessor:
         """
         # checking that the layer does not exist yet
         assert key_added not in self._obj, f"Layer {key_added} already exists."
-        assert array.ndim in [2, 3], "The array to add mask must 2 or 3-dimensional."
+        assert array.ndim in [2, 3], "The array to add mask must be 2- or 3-dimensional."
 
         if array.ndim == 2:
             # in the case of a 2D array
             y_dim, x_dim = array.shape
             assert (x_dim == self._obj.sizes[Dims.X]) & (
                 y_dim == self._obj.sizes[Dims.Y]
-            ), f"The shape of array does not match that of the image. Image has shape ({self._obj.sizes[Dims.Y]}, {self._obj.sizes[Dims.X]}), array has shape {array.shape}."
+            ), f"The shape of the array does not match that of the image. Image has shape ({self._obj.sizes[Dims.Y]}, {self._obj.sizes[Dims.X]}), array has shape {array.shape}."
 
             # create a data array with the new layer
             da = xr.DataArray(

{spatialproteomics-0.8.4 → spatialproteomics-0.8.6}/spatialproteomics/tl/__init__.py

@@ -1,4 +1,4 @@
-from .tool import ToolAccessor, astir, cellpose, mesmer, stardist
+from .tool import ToolAccessor, astir, cellpose, mesmer, spotiflow, stardist
 
 __all__ = [
     "ToolAccessor",
@@ -6,4 +6,5 @@ __all__ = [
     "mesmer",
     "stardist",
     "astir",
+    "spotiflow",
 ]

{spatialproteomics-0.8.4 → spatialproteomics-0.8.6}/spatialproteomics/tl/tool.py

@@ -7,7 +7,12 @@ import xarray as xr
 
 from ..base_logger import logger
 from ..constants import Dims, Features, Layers, Props, SDLayers
-from ..sd.utils import _get_channels_spatialdata, _process_adata, _process_image
+from ..sd.utils import (
+    _get_channels_spatialdata,
+    _process_adata,
+    _process_image,
+    _process_segmentation,
+)
 from .utils import (
     _astir,
     _cellpose,
@@ -15,6 +20,7 @@ from .utils import (
     _convert_masks_to_data_array,
     _get_channels,
     _mesmer,
+    _spotiflow,
     _stardist,
 )
 
@@ -262,6 +268,96 @@ def astir(
         return sdata
 
 
+def spotiflow(
+    sdata,
+    channel: Optional[str] = None,
+    image_key: str = SDLayers.IMAGE,
+    segmentation_key: str = SDLayers.SEGMENTATION,
+    table_key: str = SDLayers.TABLE,
+    key_added: str = "spotiflow",
+    key_added_suffix: str = "_spots",
+    pretrained_name: str = "general",
+    model_kwargs: Optional[dict] = {"verbose": False},
+    predict_kwargs: Optional[dict] = {"verbose": False},
+    copy: bool = False,
+):
+    """
+    This function applies the Spotiflow algorithm to detect spots in the provided image data.
+    It extracts the image data from the spatialdata object, applies the Spotiflow algorithm,
+    and adds the detected spots to the spatialdata object.
+    The detected spots are stored in the points attribute of the spatialdata object.
+
+    Args:
+        sdata (spatialdata.SpatialData): The spatialdata object containing the image data.
+        channel (Optional[str]): The channel(s) to be used for spot detection. If None, all channels will be used.
+        image_key (str, optional): The key for the image data in the spatialdata object. Defaults to "image".
+        segmentation_key (str, optional): The key for the segmentation mask in the spatialdata object. Defaults to "segmentation".
+        table_key (str, optional): The key for the table in the spatialdata object. Defaults to "table".
+        key_added (str, optional): The key under which the detected spots will be stored in the points attribute of the spatialdata object. Defaults to "spotiflow".
+        key_added_suffix (str, optional): The suffix to be added to the channel names in the detected spots. Defaults to "_spots".
+        pretrained_name (str, optional): The name of the pretrained model to be used for spot detection. Defaults to "general".
+        model_kwargs (Optional[dict], optional): Additional keyword arguments to be passed to the Spotiflow model. Defaults to {'verbose': False}.
+        predict_kwargs (Optional[dict], optional): Additional keyword arguments to be passed to the Spotiflow prediction method. Defaults to {'verbose': False}.
+        copy (bool, optional): Whether to create a copy of the spatialdata object. Defaults to False.
+
+    Returns:
+        spatialdata.SpatialData: The spatialdata object with the detected spots added to the points attribute.
+    """
+    import spatialdata as sd
+    from spatialdata.transformations import get_transformation, set_transformation
+
+    assert image_key in sdata, f"Image key {image_key} not found in the object."
+    assert segmentation_key in sdata, f"Segmentation key {segmentation_key} not found in the object."
+    assert table_key in sdata, f"Table key {table_key} not found in the object."
+
+    if copy:
+        sdata = cp.deepcopy(sdata)
+
+    channels = _get_channels_spatialdata(channel)
+    img = _process_image(sdata, channels=channel, image_key=image_key, key_added=None)
+    adata = _process_adata(sdata, table_key=table_key)
+
+    points_df = _spotiflow(
+        img,
+        channel_names=channels,
+        pretrained_name=pretrained_name,
+        model_kwargs=model_kwargs,
+        predict_kwargs=predict_kwargs,
+    )
+
+    seg = _process_segmentation(sdata, segmentation_key=segmentation_key)
+    yy = points_df["y"].round().astype(int).clip(0, seg.shape[0] - 1)
+    xx = points_df["x"].round().astype(int).clip(0, seg.shape[1] - 1)
+    points_df["cell_id"] = seg[yy, xx]
+    points_df = points_df[points_df["cell_id"] > 0]  # drop background detections
+
+    # --- counts per cell, per channel -------------------------------------
+    counts = points_df.groupby(["cell_id", "channel"]).size().unstack(fill_value=0)
+    counts.columns = [f"{ch}{key_added_suffix}" for ch in counts.columns]
+
+    # --- counts per cell, per channel -------------------------------------
+    counts = points_df.groupby(["cell_id", "channel"]).size().unstack(fill_value=0)
+    counts.columns = [f"{ch}{key_added_suffix}" for ch in counts.columns]
+    new_cols = counts.columns.tolist()  # remember which columns are new
+
+    # get transformations
+    transformation = get_transformation(sdata[image_key])
+
+    # write points to spatialdata
+    sdata.points[key_added] = sd.models.PointsModel.parse(points_df, coordinates={"x": "x", "y": "y"})
+    set_transformation(sdata.points[key_added], transformation)
+
+    # merge counts to existing obs
+    obs = adata.obs
+    obs = obs.merge(counts, left_on="id", right_index=True, how="left")
+    obs[new_cols] = obs[new_cols].fillna(0).astype(int)  # only fill the newly merged columns
+
+    sdata.tables[table_key].obs = obs
+
+    if copy:
+        return sdata
+
+
 # === SPATIALPROTEOMICS ACCESSOR ===
 @xr.register_dataset_accessor("tl")
 class ToolAccessor:
@@ -418,7 +514,7 @@ class ToolAccessor:
             self._obj.pp[channels]._image.values,
             scale=scale,
             n_tiles=n_tiles,
-            normalize=n_tiles,
+            normalize=normalize,
             predict_big=predict_big,
             postprocess_func=postprocess_func,
             **kwargs,
@@ -583,11 +679,83 @@ class ToolAccessor:
             assigned_cell_types, cell_col=cell_id_col, label_col=cell_type_col
         )
 
+    def spotiflow(
+        self,
+        channel: Optional[str] = None,
+        image_key: str = Layers.IMAGE,
+        segmentation_key: str = Layers.SEGMENTATION,
+        key_added_suffix: str = "_spots",
+        pretrained_name: str = "general",
+        return_spots: bool = False,
+        model_kwargs: Optional[dict] = {"verbose": False},
+        predict_kwargs: Optional[dict] = {"verbose": False},
+    ):
+        """
+        This method detects spots in the image using the Spotiflow algorithm and counts the number of spots per cell, per channel.
+
+        Parameters
+        ----------
+        channel : str, optional
+            Channel to use for spot detection. If None, all channels are used.
+        image_key : str, optional
+            Key to the image layer in the spatialproteomics object. Default is 'image'.
+        segmentation_key : str, optional
+            Key to the segmentation layer in the spatialproteomics object. Default is 'segmentation'.
+        key_added_suffix : str, optional
+            Suffix to add to the channel names in the resulting counts. Default is '_spots'.
+        pretrained_name : str, optional
+            Name of the pretrained model to use for spot detection. Default is 'general'.
+        return_spots : bool, optional
+            Whether to return the detected spots as a DataFrame. Default is False.
+        model_kwargs : dict, optional
+            Additional keyword arguments to pass to the Spotiflow model. Default is {'verbose': False}.
+        predict_kwargs : dict, optional
+            Additional keyword arguments to pass to the Spotiflow prediction method. Default is {'verbose': False}.
+
+        Returns
+        -------
+        xr.Dataset
+            Dataset containing the counts of spots per cell, per channel. If return_spots is True, also returns a DataFrame of the detected spots with their coordinates and assigned cell IDs.
+        """
+        assert image_key in self._obj, f"Image key {image_key} not found in the object."
+        assert segmentation_key in self._obj, f"Segmentation key {segmentation_key} not found in the object."
+        channels = _get_channels(self._obj, key_added=None, channel=channel)
+        img = self._obj.pp[channels][image_key].values
+        points_df = _spotiflow(
+            img,
+            channel_names=channels,
+            pretrained_name=pretrained_name,
+            model_kwargs=model_kwargs,
+            predict_kwargs=predict_kwargs,
+        )
+
+        # assign each point to a cell via the segmentation mask
+        seg = self._obj[segmentation_key].values
+        yy = points_df["y"].round().astype(int).clip(0, seg.shape[0] - 1)
+        xx = points_df["x"].round().astype(int).clip(0, seg.shape[1] - 1)
+        points_df["cell_id"] = seg[yy, xx]
+        points_df = points_df[points_df["cell_id"] > 0]  # drop background detections
+
+        # count points per cell, per channel
+        counts = (
+            points_df.groupby(["cell_id", "channel"])
+            .size()
+            .unstack(fill_value=0)
+            .reindex(index=self._obj.cells.values, columns=channels, fill_value=0)
+        )
+        counts.columns = [f"{ch}{key_added_suffix}" for ch in counts.columns]
+
+        if return_spots:
+            return self._obj.pp.add_obs_from_dataframe(counts.reset_index(drop=True)), points_df
+
+        return self._obj.pp.add_obs_from_dataframe(counts.reset_index(drop=True))
+
     def convert_to_anndata(
         self,
         expression_matrix_key: str = Layers.INTENSITY,
         obs_key: str = Layers.OBS,
         additional_layers: Optional[dict] = None,
+        additional_obsm: Optional[dict] = None,
         additional_uns: Optional[dict] = None,
     ):
         """
@@ -601,6 +769,8 @@ class ToolAccessor:
             The key of the observation data in the spatialproteomics object. Default is '_obs'.
         additional_layers : dict, optional
             Additional layers to include in the anndata.AnnData object. The keys are the names of the layers and the values are the corresponding keys in the spatialproteomics object.
+        additional_obsm : dict, optional
+            Additional obsm data to include in the anndata.AnnData object. The keys are the names of the obsm data and the values are the corresponding keys in the spatialproteomics object.
         additional_uns : dict, optional
             Additional uns data to include in the anndata.AnnData object. The keys are the names of the uns data and the values are the corresponding keys in the spatialproteomics object.
 
@@ -612,7 +782,7 @@ class ToolAccessor:
         Raises
         ------
         AssertionError
-            If the expression matrix key or additional layers are not found in the spatialproteomics object.
+            If additional layers, obsm entries, or uns entries are not found in the spatialproteomics object, or if additional layers or obsm entries have incompatible shapes.
 
         Notes
         -----
@@ -633,6 +803,11 @@ class ToolAccessor:
             for key, layer in additional_layers.items():
                 # checking that the additional layer is present in the object
                 assert layer in self._obj, f"Layer {layer} not found in the object."
+                # checking that layer has the same shape as the expression matrix
+                assert self._obj[layer].shape == expression_matrix.shape, (
+                    f"Layer {layer} has shape {self._obj[layer].shape}, but AnnData layers must match "
+                    f"the shape of the expression matrix {expression_matrix.shape}."
+                )
                 adata.layers[key] = self._obj[layer].values
         adata.var_names = self._obj.coords[Dims.CHANNELS].values
 
@@ -661,9 +836,21 @@ class ToolAccessor:
                 adata.obs[Features.Y] = adata.obs[Features.Y].astype(float)
                 adata.obsm["spatial"] = np.array(adata.obs[[Features.X, Features.Y]])
 
+        if additional_obsm:
+            for key, layer in additional_obsm.items():
+                # checking that the additional obsm source layer is present in the object
+                assert layer in self._obj, f"Layer {layer} not found in the object."
+                # checking that the additional obsm layer has the same number of observations as the expression matrix
+                assert self._obj[layer].shape[0] == expression_matrix.shape[0], (
+                    f"Layer {layer} has {self._obj[layer].shape[0]} observations, but the expression "
+                    f"matrix has {expression_matrix.shape[0]} observations. AnnData obsm entries must match "
+                    "the number of observations in the expression matrix."
+                )
+                adata.obsm[key] = self._obj[layer].values
+
         if additional_uns:
             for key, layer in additional_uns.items():
-                # checking that the additional layer is present in the object
+                # checking that the additional uns source layer is present in the object
                 assert layer in self._obj, f"Layer {layer} not found in the object."
                 adata.uns[key] = self._obj.pp.get_layer_as_df(layer)
 

{spatialproteomics-0.8.4 → spatialproteomics-0.8.6}/spatialproteomics/tl/utils.py

@@ -12,7 +12,7 @@ from ..pp.utils import _normalize
 
 
 def _get_channels(obj, key_added, channel):
-    if key_added in obj:
+    if key_added is not None and key_added in obj:
         raise KeyError(f'The key "{key_added}" already exists. Please choose another key.')
 
     if channel is not None:
@@ -248,6 +248,43 @@ def _astir(
     return assigned_cell_types
 
 
+def _spotiflow(
+    img,
+    channel_names,
+    pretrained_name: str = "general",
+    model_kwargs: dict = None,
+    predict_kwargs: dict = None,
+):
+    model_kwargs = model_kwargs or {}
+    predict_kwargs = predict_kwargs or {}
+
+    from spotiflow.model import Spotiflow
+
+    if img.ndim not in [2, 3]:
+        raise ValueError(f"Input image must be 2D or 3D, got {img.ndim}.")
+
+    if img.ndim == 2:
+        img = img[np.newaxis, :, :]
+        channel_names = [channel_names] if np.isscalar(channel_names) else channel_names
+
+    assert img.shape[0] == len(channel_names), "Number of channels in image does not match number of channel names."
+
+    model = Spotiflow.from_pretrained(pretrained_name, **model_kwargs)
+
+    dfs = []
+    for ch_idx, ch_name in enumerate(channel_names):
+        single_image = img[ch_idx]
+        points, _ = model.predict(single_image, **predict_kwargs)
+        # spotiflow returns points as (row, col) == (y, x)
+        df = pd.DataFrame(points, columns=["y", "x"])
+        df["channel"] = ch_name
+        dfs.append(df)
+
+    df = pd.concat(dfs, ignore_index=True)
+    df.index.name = "points"
+    return df
+
+
 def _compute_transformation(x_coords, y_coords):
     from spatialdata.transformations import Affine
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spatialproteomics
-Version: 0.8.4
+Version: 0.8.6
 Summary: Spatialproteomics is an interoperable toolbox for analyzing highly multiplexed fluorescence image data
 Author: Matthias Meyer-Bender, Harald Vohringer
 Requires-Python: >=3.10
@@ -33,6 +33,8 @@ Provides-Extra: anndata
 Requires-Dist: anndata; extra == "anndata"
 Provides-Extra: astir
 Requires-Dist: astir>=0.1.5; extra == "astir"
+Provides-Extra: spotiflow
+Requires-Dist: spotiflow; extra == "spotiflow"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.1.2; extra == "dev"
 Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
@@ -41,6 +43,7 @@ Requires-Dist: isort>=5.10.1; extra == "dev"
 Requires-Dist: flake8>=5.0.4; extra == "dev"
 Requires-Dist: bandit>=1.7.4; extra == "dev"
 Requires-Dist: safety>=2.1.1; extra == "dev"
+Requires-Dist: typing_extensions>=4.16; extra == "dev"
 Provides-Extra: all
 Requires-Dist: spatialdata; extra == "all"
 Requires-Dist: cellpose; extra == "all"
@@ -60,7 +63,7 @@ Dynamic: license-file
 
 ## Principles
 
-Multiplexed imaging data comprises at least 3 dimensions (i.e. `channels`, `x`, and `y`) and has often additional data such as segmentation masks or cell type annotations associated with it. In `spatialproteomics`, we use `xarray` to create a data structure that keeps all of these data dimension in sync. This data structure can then be used to apply all sorts of operations to the data. Users can segment cells, perform different image processing steps, quantify protein expression, predict cell types, and plot their data in various ways. By providing researchers with those tools, `spatialproteomics` can be used to quickly explore highly multiplexed spatial proteomics data directly within jupyter notebooks.
+Multiplexed imaging data comprises at least 3 dimensions (i.e. `channels`, `x`, and `y`) and often contains additional data such as segmentation masks or cell type annotations associated with it. In `spatialproteomics`, we use `xarray` to create a data structure that keeps all of these data dimension in sync. This data structure can then be used to apply all sorts of operations to the data. Users can segment cells, perform different image processing steps, quantify protein expression, predict cell types, and plot their data in various ways. By providing researchers with those tools, `spatialproteomics` can be used to quickly explore highly multiplexed spatial proteomics data directly within jupyter notebooks.
 
 <p align="center" width="100%">
     <img src="docs/_static/img/supplementary_figure_1.png" alt="The spatialproteomics data structure enables synchronized subsetting across shared dimensions." style="width:70%;">
@@ -97,8 +100,4 @@ matplotlib
 ```
 
 ## Citation
-Spatialproteomics - an interoperable toolbox for analyzing highly multiplexed fluorescence image data
-
-Matthias Fabian Meyer-Bender, Harald Sager Voehringer, Christina Schniederjohann, Sarah Patricia Koziel, Erin Kim Chung, Ekaterina Popova, Alexander Brobeil, Lisa-Maria Held, Aamir Munir, Scverse Community, Sascha Dietrich, Peter-Martin Bruch, Wolfgang Huber
-
-bioRxiv 2025.04.29.651202; doi: https://doi.org/10.1101/2025.04.29.651202
+> Meyer-Bender, M., Voehringer, H., Schniederjohann, C., Koziel, S., Chung, E., Popova, E., ... & Huber, W. (2026). Spatialproteomics: an interoperable toolbox for analyzing highly multiplexed fluorescence image data. Nature Methods, 1-10.

{spatialproteomics-0.8.4 → spatialproteomics-0.8.6}/spatialproteomics.egg-info/requires.txt

@@ -32,6 +32,7 @@ isort>=5.10.1
 flake8>=5.0.4
 bandit>=1.7.4
 safety>=2.1.1
+typing_extensions>=4.16
 
 [docs]
 Sphinx>=7.0.0
@@ -44,5 +45,8 @@ IPython>=8.0.0
 [spatialdata]
 spatialdata>=0.4.0
 
+[spotiflow]
+spotiflow
+
 [stardist]
 stardist>=0.9.1