spatialproteomics 0.8.5__tar.gz → 0.8.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spatialproteomics
-Version: 0.8.5
+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%;">

{spatialproteomics-0.8.5 → 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%;">

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

@@ -1,6 +1,6 @@
 [project]
 name = "spatialproteomics"
-version = "0.8.5"
+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.5 → 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.5 → 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.5 → 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,6 +679,77 @@ 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,

{spatialproteomics-0.8.5 → 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.5 → spatialproteomics-0.8.6/spatialproteomics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spatialproteomics
-Version: 0.8.5
+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%;">

{spatialproteomics-0.8.5 → 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