From 7ce49bc5c4e4773240c19a43fd4e1e2a807e183f Mon Sep 17 00:00:00 2001 From: tdefa Date: Wed, 5 Jun 2024 19:11:22 +0200 Subject: [PATCH 01/27] cli_comseg --- docs/cli.md | 53 +++++++++- docs/tutorials/cli_other_segmentation.md | 76 ++++++++++++++ sopa/_constants.py | 1 + sopa/cli/patchify.py | 120 ++++++++++++++++++++--- sopa/cli/resolve.py | 32 ++++++ sopa/cli/segmentation.py | 45 ++++++++- 6 files changed, 313 insertions(+), 14 deletions(-) create mode 100644 docs/tutorials/cli_other_segmentation.md diff --git a/docs/cli.md b/docs/cli.md index 674f1575..cb4e670a 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -347,12 +347,13 @@ $ sopa patchify [OPTIONS] COMMAND [ARGS]... **Commands**: -* `baysor`: Prepare the patches for Baysor segmentation +* `baysor`: Prepare patches for transcript-based segmentation with Baysor +* `comseg`: Prepare patches for transcript-based segmentation with ComSeg * `image`: Prepare patches for staining-based... #### `sopa patchify baysor` -Prepare the patches for Baysor segmentation +Prepare patches for transcript-based segmentation with Baysor **Usage**: @@ -376,6 +377,31 @@ $ sopa patchify baysor [OPTIONS] SDATA_PATH * `--use-prior / --no-use-prior`: Whether to use cellpose segmentation as a prior for baysor (if True, make sure to first run Cellpose) [default: no-use-prior] * `--help`: Show this message and exit. +#### `sopa patchify comseg` + +Prepare patches for transcript-based segmentation with ComSeg + +**Usage**: + +```console +$ sopa patchify comseg [OPTIONS] SDATA_PATH +``` + +**Arguments**: + +* `SDATA_PATH`: Path to the SpatialData `.zarr` directory [required] + +**Options**: + +* `--patch-width-microns FLOAT`: Width (and height) of each patch in microns [required] +* `--patch-overlap-microns FLOAT`: Number of overlapping microns between the patches. We advise to choose approximately twice the diameter of a cell [required] +* `--baysor-temp-dir TEXT`: Temporary directory where ComSeg inputs and outputs will be saved. By default, uses `.sopa_cache/comseg_boundaries` +* `--config-path TEXT`: Path to the baysor config (you can also directly provide the argument via the `config` option) +* `--config TEXT`: Dictionnary of baysor parameters [default: {}] +* `--cell-key TEXT`: Optional column of the transcripts dataframe that indicates in which cell-id each transcript is, in order to use prior segmentation. Default is 'cell' if cell_key=None +* `--unassigned-value INTEGER`: If --cell-key is provided, this is the value given to transcripts that are not inside any cell (if it's already 0, don't provide this argument) +* `--help`: Show this message and exit. + #### `sopa patchify image` Prepare patches for staining-based segmentation (including Cellpose) @@ -500,6 +526,28 @@ $ sopa resolve cellpose [OPTIONS] SDATA_PATH * `--patch-dir TEXT`: Directory containing the cellpose segmentation on patches (or multiple directories if using multi-step segmentation). By default, uses the `.sopa_cache/cellpose_boundaries` directory * `--help`: Show this message and exit. +#### `sopa resolve comseg` + +Resolve patches conflicts after comseg segmentation. Provide either `--baysor-temp-dir` or `--patches-dirs` + +**Usage**: + +```console +$ sopa resolve comseg [OPTIONS] SDATA_PATH +``` + +**Arguments**: + +* `SDATA_PATH`: Path to the SpatialData `.zarr` directory [required] + +**Options**: + +* `--gene-column TEXT`: Column of the transcripts dataframe containing the genes names [required] +* `--comseg-temp-dir TEXT`: Path to the directory containing all the comseg patches (see `sopa patchify`). By default, uses the `.sopa_cache/comseg_boundaries` directory +* `--min-area FLOAT`: Cells with an area less than this value (in microns^2) will be filtered [default: 0] +* `--patches-dirs TEXT`: List of patches directories inside `comseg_temp_dir` +* `--help`: Show this message and exit. + #### `sopa resolve generic` Resolve patches conflicts after generic segmentation @@ -537,6 +585,7 @@ $ sopa segmentation [OPTIONS] COMMAND [ARGS]... **Commands**: * `cellpose`: Perform cellpose segmentation. +* `comseg`: Perform ComSeg segmentation. * `generic-staining`: Perform generic staining-based segmentation. #### `sopa segmentation cellpose` diff --git a/docs/tutorials/cli_other_segmentation.md b/docs/tutorials/cli_other_segmentation.md new file mode 100644 index 00000000..edaca32c --- /dev/null +++ b/docs/tutorials/cli_other_segmentation.md @@ -0,0 +1,76 @@ + +### Option 3: ComSeg + + +[ComSeg](https://github.com/fish-quant/ComSeg) is a transcript-based segmentation method. It uses a segmentation prior (here, Cellpose) and improves it using the transcripts information. + +#### Run Cellpose to segment nuclei + +``` +sopa patchify image tuto.zarr --patch-width-pixel 1500 --patch-overlap-pixel 50 +sopa segmentation cellpose tuto.zarr --channels DAPI --diameter 35 --min-area 2000 +sopa resolve cellpose tuto.zarr +``` + +#### Save a ComSeg config file as config.jsons +More information on the parameters can be found in the [ComSeg documentation](https://comseg.readthedocs.io/en/latest/userguide/Minimal_example.html). +Below we display a minimal example of a ComSeg config file. + + +```json +{"dict_scale": {"x": 1, "y": 1, "z": 1}, +"mean_cell_diameter": 15, +"max_cell_radius": 50, +"alpha": 0.5, +"min_rna_per_cell": 5, +"gene_column": "genes"} +``` + +#### Run ComSeg with the sopa command line tool + +1) create the ComSeg patches +On the toy dataset, we will generate 4 patches. +``` +sopa patchify comseg tuto.zarr --config-path config.json --patch-width-microns 200 --patch-overlap-microns 50 +``` + +2) run ComSeg on all patches + +!!! tip + Manually running the commands below can involve using many consecutive commands, so we recommend automatizing it. For instance, this can be done using Snakemake or Nextflow. This will help you parallelize it since you can run each task on separate jobs or using multithreading. You can also see how we do it in the [Sopa Snakemake pipeline](https://github.com/gustaveroussy/sopa/blob/master/workflow/Snakefile). + + To automatically get the number of patches, you can open the `tuto.zarr/.sopa_cache/patches_file_comseg` file. This lists the names of the directories inside `tuto.zarr/.sopa_cache/comseg` related to each patch. If you selected an ROI, the excluded patches are effectively not in the `patches_file_comseg` file. + +=== "Patch 0" + ```sh + cd tuto.zarr/.sopa_cache/comseg_boundaries/0 + + # 'comseg' is the official comseg executable. If unavailable, replace it with your path to the executable + comseg run --save-polygons GeoJSON -c config.toml transcripts.csv + ``` +=== "Patch 1" + ```sh + cd tuto.zarr/.sopa_cache/comseg_boundaries/1 + + # 'comseg' is the official comseg executable. If unavailable, replace it with your path to the executable + comseg run --save-polygons GeoJSON -c config.toml transcripts.csv + ``` +=== "Patch 2" + ```sh + cd tuto.zarr/.sopa_cache/comseg_boundaries/2 + + # 'comseg' is the official comseg executable. If unavailable, replace it with your path to the executable + comseg run --save-polygons GeoJSON -c config.toml transcripts.csv + ``` +=== "Patch 3" + ```sh + cd tuto.zarr/.sopa_cache/comseg_boundaries/3 + + # 'comseg' is the official comseg executable. If unavailable, replace it with your path to the executable + comseg run --save-polygons GeoJSON -c config.toml transcripts.csv + ``` + +3) Merge the results +```sh +sopa resolve comseg tuto.zarr --gene-column genes +``` \ No newline at end of file diff --git a/sopa/_constants.py b/sopa/_constants.py index f82816a9..f6fb3b57 100644 --- a/sopa/_constants.py +++ b/sopa/_constants.py @@ -51,6 +51,7 @@ class SopaFiles: SOPA_CACHE_DIR = ".sopa_cache" PATCHES_FILE_IMAGE = "patches_file_image" PATCHES_DIRS_BAYSOR = "patches_file_baysor" + PATCHES_DIRS_COMSEG = "patches_file_comseg" TRANSCRIPTS_FILE = "transcripts.csv" CENTROIDS_FILE = "centroids.csv" JSON_CONFIG_FILE = "config.json" diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index 0cedded2..49b6292b 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -5,6 +5,7 @@ import typer from .utils import SDATA_HELPER +from .._constants import SopaKeys app_patchify = typer.Typer() @@ -36,7 +37,6 @@ def image( _save_cache(sdata_path, SopaFiles.PATCHES_FILE_IMAGE, str(len(patches))) - @app_patchify.command() def baysor( sdata_path: str = typer.Argument(help=SDATA_HELPER), @@ -59,7 +59,8 @@ def baysor( ), cell_key: str = typer.Option( None, - help="Optional column of the transcripts dataframe that indicates in which cell-id each transcript is, in order to use prior segmentation", + help="Optional column of the transcripts dataframe that indicates in which cell-id each transcript is, in order to use prior segmentation" + f" Default is '{SopaKeys.DEFAULT_CELL_KEY}' if cell_key=None", ), unassigned_value: int = typer.Option( None, @@ -69,8 +70,93 @@ def baysor( False, help="Whether to use cellpose segmentation as a prior for baysor (if True, make sure to first run Cellpose)", ), + ): + """Prepare patches for transcript-based segmentation with baysor""" + + return transcript_segmentation(sdata_path = sdata_path, method = 'baysor', patch_width_microns = patch_width_microns, + patch_overlap_microns = patch_overlap_microns, temp_dir = baysor_temp_dir, + config_path = config_path, config = config, cell_key = cell_key, + unassigned_value = unassigned_value, use_prior = use_prior) + +@app_patchify.command() +def comseg( + sdata_path: str = typer.Argument(help=SDATA_HELPER), + patch_width_microns: float = typer.Option(help="Width (and height) of each patch in microns"), + patch_overlap_microns: float = typer.Option( + help="Number of overlapping microns between the patches. We advise to choose approximately twice the diameter of a cell" + ), + baysor_temp_dir: str = typer.Option( + None, + help="Temporary directory where baysor inputs and outputs will be saved. By default, uses `.sopa_cache/comseg_boundaries`", + ), + config_path: str = typer.Option( + None, + help="Path to the ComSeg json config file (you can also directly provide the argument via the `config` option)", + ), + config: str = typer.Option( + default={}, + callback=ast.literal_eval, + help="Dictionnary of ComSeg parameters", + ), + cell_key: str = typer.Option( + None, + help="Optional column of the transcripts dataframe that indicates in which cell-id each transcript is, in order to use prior segmentation." + f" Default is {SopaKeys.DEFAULT_CELL_KEY} if cell_key=None", + ), + unassigned_value: int = typer.Option( + None, + help="If --cell-key is provided, this is the value given to transcripts that are not inside any cell (if it's already 0, don't provide this argument)", + ), + + ): + """Prepare patches for transcript-based segmentation with ComSeg""" + + return transcript_segmentation(sdata_path = sdata_path, method = 'comseg', patch_width_microns = patch_width_microns, + patch_overlap_microns = patch_overlap_microns, temp_dir = baysor_temp_dir, + config_path = config_path, config = config, cell_key = cell_key, + unassigned_value = unassigned_value, use_prior = True) +@app_patchify.command() +def transcript_segmentation( + sdata_path: str = typer.Argument(help=SDATA_HELPER), + method: str = typer.Option( + "baysor", + help="Name of the method to use, choose in ['baysor', 'comseg']. for ComSeg, make sure to first run Cellpose or " + f"manually add the segmentation boundaries to the sdata.shapes as {SopaKeys.CELLPOSE_BOUNDARIES} key" + ), + patch_width_microns: float = typer.Option(help="Width (and height) of each patch in microns"), + patch_overlap_microns: float = typer.Option( + help="Number of overlapping microns between the patches. We advise to choose approximately twice the diameter of a cell" + ), + temp_dir: str = typer.Option( + None, + help="Temporary directory where baysor inputs and outputs will be saved. By default, uses `.sopa_cache/baysor_boundaries`", + ), + config_path: str = typer.Option( + None, + help="Path to the baysor config (you can also directly provide the argument via the `config` option)", + ), + config: str = typer.Option( + default={}, + callback=ast.literal_eval, + help="Dictionnary of baysor parameters", + ), + cell_key: str = typer.Option( + None, + help="Optional column of the transcripts dataframe that indicates in which cell-id each transcript is, in order to use prior segmentation. " + f" Default is {SopaKeys.DEFAULT_CELL_KEY} if cell_key=None", + ), + unassigned_value: int = typer.Option( + None, + help="If --cell-key is provided, this is the value given to transcripts that are not inside any cell (if it's already 0, don't provide this argument)", + ), + use_prior: bool = typer.Option( + False, + help="Whether to use cellpose segmentation as a prior for baysor and comseg (if True, make sure to first run Cellpose or " + f"manually add the segmentation boundaries to the sdata.shapes as {SopaKeys.CELLPOSE_BOUNDARIES} key)", + ), + ): - """Prepare the patches for Baysor segmentation""" + """Prepare patches for transcript-based segmentation for the different available methods (baysor, comseg)""" from sopa._constants import SopaFiles, SopaKeys from sopa._sdata import get_key from sopa.io.standardize import read_zarr_standardized, sanity_check @@ -83,19 +169,31 @@ def baysor( assert ( config or config_path is not None - ), "Provide '--config-path', the path to a Baysor config file (toml)" - - if baysor_temp_dir is None: - baysor_temp_dir = _default_boundary_dir(sdata_path, SopaKeys.BAYSOR_BOUNDARIES) + ), "Provide '--config-path', the path to a Baysor config file (toml) or comseg file (jsons)" + assert method in ['baysor', 'comseg'], "method must be either 'baysor' or 'comseg'" + + + if temp_dir is None: + if method == 'baysor': + temp_dir = _default_boundary_dir(sdata_path, SopaKeys.BAYSOR_BOUNDARIES) + filename = SopaFiles.PATCHES_DIRS_BAYSOR + config_name = SopaFiles.TOML_CONFIG_FILE + elif method == 'comseg': + temp_dir = _default_boundary_dir(sdata_path, SopaKeys.COMSEG_BOUNDARIES) + filename = SopaFiles.PATCHES_DIRS_COMSEG + config_name = SopaFiles.JSON_CONFIG_FILE + else: + raise ValueError("method must be either 'baysor' or 'comseg'") df_key = get_key(sdata, "points") patches = Patches2D(sdata, df_key, patch_width_microns, patch_overlap_microns) + if method == 'comseg': + valid_indices_centroid = patches.patchify_centroids(temp_dir) + assert use_prior == True, "For ComSeg, you must use the prior segmentation of nuclei or from other staining" valid_indices = patches.patchify_transcripts( - baysor_temp_dir, cell_key, unassigned_value, use_prior, config, config_path + temp_dir, cell_key, unassigned_value, use_prior, config, config_path, config_name=config_name ) - - _save_cache(sdata_path, SopaFiles.PATCHES_DIRS_BAYSOR, "\n".join(map(str, valid_indices))) - + _save_cache(sdata_path,filename, "\n".join(map(str, valid_indices))) def _save_cache(sdata_path: str, filename: str, content: str): from pathlib import Path diff --git a/sopa/cli/resolve.py b/sopa/cli/resolve.py index 25bd6218..92f20da4 100644 --- a/sopa/cli/resolve.py +++ b/sopa/cli/resolve.py @@ -96,3 +96,35 @@ def baysor( sdata = read_zarr_standardized(sdata_path) resolve(sdata, baysor_temp_dir, gene_column, patches_dirs, min_area) + + +@app_resolve.command() +def comseg( + sdata_path: str = typer.Argument(help=SDATA_HELPER), + gene_column: str = typer.Option( + help="Column of the transcripts dataframe containing the genes names" + ), + comseg_temp_dir: str = typer.Option( + None, + help="Path to the directory containing all the comseg patches (see `sopa patchify`). By default, uses the `.sopa_cache/comseg_boundaries` directory", + ), + min_area: float = typer.Option( + 0, help="Cells with an area less than this value (in microns^2) will be filtered" + ), + patches_dirs: list[str] = typer.Option( + [], help="List of patches directories inside `comseg_temp_dir`" + ), +): + """Resolve patches conflicts after comseg segmentation. Provide either `--comseg-temp-dir` or `--patches-dirs`""" + from sopa._constants import SopaKeys + from sopa.io.standardize import read_zarr_standardized + from sopa.segmentation.transcripts import resolve + + from .utils import _default_boundary_dir + + if not len(patches_dirs) and comseg_temp_dir is None: + comseg_temp_dir = _default_boundary_dir(sdata_path, SopaKeys.COMSEG_BOUNDARIES) + + sdata = read_zarr_standardized(sdata_path) + + resolve(sdata, comseg_temp_dir, gene_column, patches_dirs, min_area, shapes_key=SopaKeys.COMSEG_BOUNDARIES) \ No newline at end of file diff --git a/sopa/cli/segmentation.py b/sopa/cli/segmentation.py index 9f4e5934..f410817c 100644 --- a/sopa/cli/segmentation.py +++ b/sopa/cli/segmentation.py @@ -1,13 +1,16 @@ from __future__ import annotations +import logging import ast import typer from .utils import SDATA_HELPER - +from pathlib import Path +from tqdm import tqdm app_segmentation = typer.Typer() +log = logging.getLogger(__name__) @app_segmentation.command() def cellpose( @@ -176,3 +179,43 @@ def _run_staining_segmentation( segmentation.write_patches_cells(patch_dir) else: segmentation.write_patch_cells(patch_dir, patch_index) + +@app_segmentation.command() +def comseg( + sdata_path: str = typer.Argument(help=SDATA_HELPER), + patch_dir: str = typer.Option( + default=None, + help="Path to the temporary the segmentation method directory inside which we will store each individual patch segmentation. By default, saves into the `.sopa_cache/` directory", + ), + patch_index: int = typer.Option( + default=None, + help="Index of the patch on which the segmentation method should be run. NB: the number of patches is `len(sdata['sopa_patches'])`", + ), +): + """Perform ComSeg segmentation. This can be done on all patches directly, or on one individual patch.""" + from .utils import _default_boundary_dir + from sopa._constants import SopaFiles, SopaKeys + from sopa.segmentation.methods import comseg_patch + import json + + config_name = SopaFiles.JSON_CONFIG_FILE + + if patch_dir is None: + patch_dir = _default_boundary_dir(sdata_path, SopaKeys.COMSEG_BOUNDARIES) + + if patch_index is None: + log.warn( + "Running segmentation in a sequential manner. This is not recommended on large images because it can be extremely slow (see https://github.com/gustaveroussy/sopa/discussions/36 for more details)" + ) + for path_index_folder in tqdm(list(Path(patch_dir).glob("*")), desc="Run all patches"): + patch_index = int(path_index_folder.stem) + config_path = Path(patch_dir) / f"{patch_index}/{config_name}" + with open(config_path, 'r') as f: + config = json.load(f) + + comseg_patch(temp_dir=patch_dir, patch_index=int(path_index_folder.stem), config=config) + else: + config_path = Path(patch_dir) / f"{patch_index}/{config_name}" + with open(config_path, 'r') as f: + config = json.load(f) + comseg_patch(temp_dir=patch_dir, patch_index=patch_index, config=config) From 16593e405377db4fd4d2e705aabb31c11940b103 Mon Sep 17 00:00:00 2001 From: tdefa Date: Wed, 5 Jun 2024 19:18:30 +0200 Subject: [PATCH 02/27] doc_cli --- docs/cli.md | 25 +++++++++++++++++++++++++ sopa/cli/segmentation.py | 8 ++++---- 2 files changed, 29 insertions(+), 4 deletions(-) diff --git a/docs/cli.md b/docs/cli.md index cb4e670a..77f7c224 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -624,6 +624,31 @@ $ sopa segmentation cellpose [OPTIONS] SDATA_PATH * `--method-kwargs TEXT`: Kwargs for the cellpose method builder. This should be a dictionnary, in inline string format. [default: {}] * `--help`: Show this message and exit. +#### `sopa segmentation comseg` + +Perform ComSeg segmentation. This can be done on all patches directly, or on one individual patch. + +!!! note "Usage" + + - [On one patch] Use this mode to run patches in parallel. Provide `--patch-index` to run one patch, and execute all patches in a parallel manner (you need to define your own parallelization, else, use the Snakemake pipeline). + + - [On all patches at once] For small images, you can run the segmentation method sequentially (`--patch-index` is not needed) + +**Usage**: + +```console +$ sopa segmentation comseg [OPTIONS] SDATA_PATH +``` + +**Arguments**: + +* `SDATA_PATH`: Path to the SpatialData `.zarr` directory [required] + +**Options**: + +* `--patch-dir TEXT`: Path to the temporary comseg directory inside which we will store each individual patch segmentation. By default, saves into the `.sopa_cache/comseg_boundaries` directory +* `--patch-index INTEGER`: Index of the patch on which cellpose should be run. NB: the number of patches is `len(sdata['sopa_patches'])` + #### `sopa segmentation generic-staining` Perform generic staining-based segmentation. This can be done on all patches directly, or on one individual patch. diff --git a/sopa/cli/segmentation.py b/sopa/cli/segmentation.py index f410817c..591f8dab 100644 --- a/sopa/cli/segmentation.py +++ b/sopa/cli/segmentation.py @@ -183,14 +183,14 @@ def _run_staining_segmentation( @app_segmentation.command() def comseg( sdata_path: str = typer.Argument(help=SDATA_HELPER), - patch_dir: str = typer.Option( - default=None, - help="Path to the temporary the segmentation method directory inside which we will store each individual patch segmentation. By default, saves into the `.sopa_cache/` directory", - ), patch_index: int = typer.Option( default=None, help="Index of the patch on which the segmentation method should be run. NB: the number of patches is `len(sdata['sopa_patches'])`", ), + patch_dir: str = typer.Option( + default=None, + help="Path to the temporary the segmentation method directory inside which we will store each individual patch segmentation. By default, saves into the `.sopa_cache/` directory", + ), ): """Perform ComSeg segmentation. This can be done on all patches directly, or on one individual patch.""" from .utils import _default_boundary_dir From 64c9f27e5ac43e19e9127e6843a0416b32be4f38 Mon Sep 17 00:00:00 2001 From: tdefa Date: Wed, 5 Jun 2024 19:21:36 +0200 Subject: [PATCH 03/27] space --- sopa/cli/resolve.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sopa/cli/resolve.py b/sopa/cli/resolve.py index 92f20da4..9a8b8cc8 100644 --- a/sopa/cli/resolve.py +++ b/sopa/cli/resolve.py @@ -127,4 +127,4 @@ def comseg( sdata = read_zarr_standardized(sdata_path) - resolve(sdata, comseg_temp_dir, gene_column, patches_dirs, min_area, shapes_key=SopaKeys.COMSEG_BOUNDARIES) \ No newline at end of file + resolve(sdata, comseg_temp_dir, gene_column, patches_dirs, min_area, shapes_key=SopaKeys.COMSEG_BOUNDARIES) From 553a740050ffcc9104f8b4d0a31a910e337b0613 Mon Sep 17 00:00:00 2001 From: tdefa Date: Wed, 5 Jun 2024 19:37:32 +0200 Subject: [PATCH 04/27] pre-commit test --- docs/tutorials/cli_other_segmentation.md | 12 ++--- sopa/cli/patchify.py | 62 ++++++++++++++++-------- sopa/cli/resolve.py | 9 +++- sopa/cli/segmentation.py | 29 +++++------ 4 files changed, 72 insertions(+), 40 deletions(-) diff --git a/docs/tutorials/cli_other_segmentation.md b/docs/tutorials/cli_other_segmentation.md index edaca32c..0d37a25f 100644 --- a/docs/tutorials/cli_other_segmentation.md +++ b/docs/tutorials/cli_other_segmentation.md @@ -18,17 +18,17 @@ Below we display a minimal example of a ComSeg config file. ```json -{"dict_scale": {"x": 1, "y": 1, "z": 1}, -"mean_cell_diameter": 15, -"max_cell_radius": 50, -"alpha": 0.5, -"min_rna_per_cell": 5, +{"dict_scale": {"x": 1, "y": 1, "z": 1}, +"mean_cell_diameter": 15, +"max_cell_radius": 50, +"alpha": 0.5, +"min_rna_per_cell": 5, "gene_column": "genes"} ``` #### Run ComSeg with the sopa command line tool -1) create the ComSeg patches +1) create the ComSeg patches On the toy dataset, we will generate 4 patches. ``` sopa patchify comseg tuto.zarr --config-path config.json --patch-width-microns 200 --patch-overlap-microns 50 diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index 49b6292b..e550adba 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -4,8 +4,8 @@ import typer -from .utils import SDATA_HELPER from .._constants import SopaKeys +from .utils import SDATA_HELPER app_patchify = typer.Typer() @@ -60,7 +60,7 @@ def baysor( cell_key: str = typer.Option( None, help="Optional column of the transcripts dataframe that indicates in which cell-id each transcript is, in order to use prior segmentation" - f" Default is '{SopaKeys.DEFAULT_CELL_KEY}' if cell_key=None", + f" Default is '{SopaKeys.DEFAULT_CELL_KEY}' if cell_key=None", ), unassigned_value: int = typer.Option( None, @@ -72,6 +72,18 @@ def baysor( ), ): """Prepare patches for transcript-based segmentation with baysor""" + return transcript_segmentation( + sdata_path=sdata_path, + method = "baysor", + patch_width_microns = patch_width_microns, + patch_overlap_microns = patch_overlap_microns, + temp_dir = baysor_temp_dir, + config_path = config_path, + config = config, + cell_key = cell_key, + unassigned_value = unassigned_value, + use_prior = use_prior, + ) return transcript_segmentation(sdata_path = sdata_path, method = 'baysor', patch_width_microns = patch_width_microns, patch_overlap_microns = patch_overlap_microns, temp_dir = baysor_temp_dir, @@ -101,27 +113,32 @@ def comseg( cell_key: str = typer.Option( None, help="Optional column of the transcripts dataframe that indicates in which cell-id each transcript is, in order to use prior segmentation." - f" Default is {SopaKeys.DEFAULT_CELL_KEY} if cell_key=None", + f" Default is {SopaKeys.DEFAULT_CELL_KEY} if cell_key=None", ), unassigned_value: int = typer.Option( None, help="If --cell-key is provided, this is the value given to transcripts that are not inside any cell (if it's already 0, don't provide this argument)", ), - - ): +): """Prepare patches for transcript-based segmentation with ComSeg""" - return transcript_segmentation(sdata_path = sdata_path, method = 'comseg', patch_width_microns = patch_width_microns, - patch_overlap_microns = patch_overlap_microns, temp_dir = baysor_temp_dir, - config_path = config_path, config = config, cell_key = cell_key, - unassigned_value = unassigned_value, use_prior = True) + return transcript_segmentation( + sdata_path = sdata_path, + method = 'comseg', + patch_width_microns = patch_width_microns, + patch_overlap_microns = patch_overlap_microns, + temp_dir = baysor_temp_dir, + config_path = config_path, + config = config, cell_key = cell_key, + unassigned_value = unassigned_value, + use_prior = True) @app_patchify.command() def transcript_segmentation( sdata_path: str = typer.Argument(help=SDATA_HELPER), - method: str = typer.Option( + method: str = typer.Option( "baysor", help="Name of the method to use, choose in ['baysor', 'comseg']. for ComSeg, make sure to first run Cellpose or " - f"manually add the segmentation boundaries to the sdata.shapes as {SopaKeys.CELLPOSE_BOUNDARIES} key" + f"manually add the segmentation boundaries to the sdata.shapes as {SopaKeys.CELLPOSE_BOUNDARIES} key" ), patch_width_microns: float = typer.Option(help="Width (and height) of each patch in microns"), patch_overlap_microns: float = typer.Option( @@ -143,7 +160,7 @@ def transcript_segmentation( cell_key: str = typer.Option( None, help="Optional column of the transcripts dataframe that indicates in which cell-id each transcript is, in order to use prior segmentation. " - f" Default is {SopaKeys.DEFAULT_CELL_KEY} if cell_key=None", + f" Default is {SopaKeys.DEFAULT_CELL_KEY} if cell_key=None", ), unassigned_value: int = typer.Option( None, @@ -152,7 +169,7 @@ def transcript_segmentation( use_prior: bool = typer.Option( False, help="Whether to use cellpose segmentation as a prior for baysor and comseg (if True, make sure to first run Cellpose or " - f"manually add the segmentation boundaries to the sdata.shapes as {SopaKeys.CELLPOSE_BOUNDARIES} key)", + f"manually add the segmentation boundaries to the sdata.shapes as {SopaKeys.CELLPOSE_BOUNDARIES} key)", ), ): @@ -172,9 +189,8 @@ def transcript_segmentation( ), "Provide '--config-path', the path to a Baysor config file (toml) or comseg file (jsons)" assert method in ['baysor', 'comseg'], "method must be either 'baysor' or 'comseg'" - if temp_dir is None: - if method == 'baysor': + if method == "baysor": temp_dir = _default_boundary_dir(sdata_path, SopaKeys.BAYSOR_BOUNDARIES) filename = SopaFiles.PATCHES_DIRS_BAYSOR config_name = SopaFiles.TOML_CONFIG_FILE @@ -187,13 +203,21 @@ def transcript_segmentation( df_key = get_key(sdata, "points") patches = Patches2D(sdata, df_key, patch_width_microns, patch_overlap_microns) - if method == 'comseg': + if method == "comseg": valid_indices_centroid = patches.patchify_centroids(temp_dir) - assert use_prior == True, "For ComSeg, you must use the prior segmentation of nuclei or from other staining" + assert ( + use_prior == True, + ), "For ComSeg, you must use the prior segmentation of nuclei or from other staining" valid_indices = patches.patchify_transcripts( - temp_dir, cell_key, unassigned_value, use_prior, config, config_path, config_name=config_name + temp_dir, + cell_key, + unassigned_value, + use_prior, + config, + config_path, + config_name=config_name ) - _save_cache(sdata_path,filename, "\n".join(map(str, valid_indices))) + _save_cache(sdata_path, filename, "\n".join(map(str, valid_indices))) def _save_cache(sdata_path: str, filename: str, content: str): from pathlib import Path diff --git a/sopa/cli/resolve.py b/sopa/cli/resolve.py index 9a8b8cc8..be6a43e8 100644 --- a/sopa/cli/resolve.py +++ b/sopa/cli/resolve.py @@ -127,4 +127,11 @@ def comseg( sdata = read_zarr_standardized(sdata_path) - resolve(sdata, comseg_temp_dir, gene_column, patches_dirs, min_area, shapes_key=SopaKeys.COMSEG_BOUNDARIES) + resolve( + sdata, + comseg_temp_dir, + gene_column, + patches_dirs, + min_area, + shapes_key=SopaKeys.COMSEG_BOUNDARIES + ) diff --git a/sopa/cli/segmentation.py b/sopa/cli/segmentation.py index 591f8dab..a781974f 100644 --- a/sopa/cli/segmentation.py +++ b/sopa/cli/segmentation.py @@ -1,13 +1,14 @@ from __future__ import annotations -import logging import ast +import logging +from pathlib import Path + import typer +from tqdm import tqdm from .utils import SDATA_HELPER -from pathlib import Path -from tqdm import tqdm app_segmentation = typer.Typer() log = logging.getLogger(__name__) @@ -182,15 +183,15 @@ def _run_staining_segmentation( @app_segmentation.command() def comseg( - sdata_path: str = typer.Argument(help=SDATA_HELPER), - patch_index: int = typer.Option( - default=None, - help="Index of the patch on which the segmentation method should be run. NB: the number of patches is `len(sdata['sopa_patches'])`", - ), - patch_dir: str = typer.Option( - default=None, - help="Path to the temporary the segmentation method directory inside which we will store each individual patch segmentation. By default, saves into the `.sopa_cache/` directory", - ), + sdata_path: str = typer.Argument(help=SDATA_HELPER), + patch_index: int = typer.Option( + default=None, + help="Index of the patch on which the segmentation method should be run. NB: the number of patches is `len(sdata['sopa_patches'])`", + ), + patch_dir: str = typer.Option( + default=None, + help="Path to the temporary the segmentation method directory inside which we will store each individual patch segmentation. By default, saves into the `.sopa_cache/` directory", + ), ): """Perform ComSeg segmentation. This can be done on all patches directly, or on one individual patch.""" from .utils import _default_boundary_dir @@ -210,12 +211,12 @@ def comseg( for path_index_folder in tqdm(list(Path(patch_dir).glob("*")), desc="Run all patches"): patch_index = int(path_index_folder.stem) config_path = Path(patch_dir) / f"{patch_index}/{config_name}" - with open(config_path, 'r') as f: + with open(config_path, "r") as f: config = json.load(f) comseg_patch(temp_dir=patch_dir, patch_index=int(path_index_folder.stem), config=config) else: config_path = Path(patch_dir) / f"{patch_index}/{config_name}" - with open(config_path, 'r') as f: + with open(config_path, "r") as f: config = json.load(f) comseg_patch(temp_dir=patch_dir, patch_index=patch_index, config=config) From 60d4da96392a36fe49d996ee17394e74725bdb5a Mon Sep 17 00:00:00 2001 From: tdefa Date: Wed, 5 Jun 2024 19:44:10 +0200 Subject: [PATCH 05/27] pre-commit test2 --- docs/tutorials/cli_other_segmentation.md | 2 +- sopa/cli/patchify.py | 28 +++++++++++++++--------- sopa/cli/resolve.py | 2 +- sopa/cli/segmentation.py | 9 +++++--- 4 files changed, 26 insertions(+), 15 deletions(-) diff --git a/docs/tutorials/cli_other_segmentation.md b/docs/tutorials/cli_other_segmentation.md index 0d37a25f..3cb62624 100644 --- a/docs/tutorials/cli_other_segmentation.md +++ b/docs/tutorials/cli_other_segmentation.md @@ -73,4 +73,4 @@ sopa patchify comseg tuto.zarr --config-path config.json --patch-width-microns 2 3) Merge the results ```sh sopa resolve comseg tuto.zarr --gene-column genes -``` \ No newline at end of file +``` diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index e550adba..11ca3aed 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -70,7 +70,7 @@ def baysor( False, help="Whether to use cellpose segmentation as a prior for baysor (if True, make sure to first run Cellpose)", ), - ): +): """Prepare patches for transcript-based segmentation with baysor""" return transcript_segmentation( sdata_path=sdata_path, @@ -85,10 +85,17 @@ def baysor( use_prior = use_prior, ) - return transcript_segmentation(sdata_path = sdata_path, method = 'baysor', patch_width_microns = patch_width_microns, - patch_overlap_microns = patch_overlap_microns, temp_dir = baysor_temp_dir, - config_path = config_path, config = config, cell_key = cell_key, - unassigned_value = unassigned_value, use_prior = use_prior) + return transcript_segmentation( + sdata_path = sdata_path, + method = 'baysor', + patch_width_microns = patch_width_microns, + patch_overlap_microns = patch_overlap_microns, + temp_dir = baysor_temp_dir, + config_path = config_path, + config = config, + cell_key = cell_key, + unassigned_value = unassigned_value, + use_prior = use_prior) @app_patchify.command() def comseg( @@ -131,14 +138,15 @@ def comseg( config_path = config_path, config = config, cell_key = cell_key, unassigned_value = unassigned_value, - use_prior = True) + use_prior = True + ) @app_patchify.command() def transcript_segmentation( sdata_path: str = typer.Argument(help=SDATA_HELPER), method: str = typer.Option( "baysor", help="Name of the method to use, choose in ['baysor', 'comseg']. for ComSeg, make sure to first run Cellpose or " - f"manually add the segmentation boundaries to the sdata.shapes as {SopaKeys.CELLPOSE_BOUNDARIES} key" + f"manually add the segmentation boundaries to the sdata.shapes as {SopaKeys.CELLPOSE_BOUNDARIES} key", ), patch_width_microns: float = typer.Option(help="Width (and height) of each patch in microns"), patch_overlap_microns: float = typer.Option( @@ -187,14 +195,14 @@ def transcript_segmentation( assert ( config or config_path is not None ), "Provide '--config-path', the path to a Baysor config file (toml) or comseg file (jsons)" - assert method in ['baysor', 'comseg'], "method must be either 'baysor' or 'comseg'" + assert method in ["baysor", "comseg"], "method must be either 'baysor' or 'comseg'" if temp_dir is None: if method == "baysor": temp_dir = _default_boundary_dir(sdata_path, SopaKeys.BAYSOR_BOUNDARIES) filename = SopaFiles.PATCHES_DIRS_BAYSOR config_name = SopaFiles.TOML_CONFIG_FILE - elif method == 'comseg': + elif method == "comseg": temp_dir = _default_boundary_dir(sdata_path, SopaKeys.COMSEG_BOUNDARIES) filename = SopaFiles.PATCHES_DIRS_COMSEG config_name = SopaFiles.JSON_CONFIG_FILE @@ -215,7 +223,7 @@ def transcript_segmentation( use_prior, config, config_path, - config_name=config_name + config_name=config_name, ) _save_cache(sdata_path, filename, "\n".join(map(str, valid_indices))) diff --git a/sopa/cli/resolve.py b/sopa/cli/resolve.py index be6a43e8..e3fbedf9 100644 --- a/sopa/cli/resolve.py +++ b/sopa/cli/resolve.py @@ -133,5 +133,5 @@ def comseg( gene_column, patches_dirs, min_area, - shapes_key=SopaKeys.COMSEG_BOUNDARIES + shapes_key=SopaKeys.COMSEG_BOUNDARIES, ) diff --git a/sopa/cli/segmentation.py b/sopa/cli/segmentation.py index a781974f..08c2e524 100644 --- a/sopa/cli/segmentation.py +++ b/sopa/cli/segmentation.py @@ -4,15 +4,16 @@ import logging from pathlib import Path - import typer from tqdm import tqdm from .utils import SDATA_HELPER + app_segmentation = typer.Typer() log = logging.getLogger(__name__) + @app_segmentation.command() def cellpose( sdata_path: str = typer.Argument(help=SDATA_HELPER), @@ -181,6 +182,7 @@ def _run_staining_segmentation( else: segmentation.write_patch_cells(patch_dir, patch_index) + @app_segmentation.command() def comseg( sdata_path: str = typer.Argument(help=SDATA_HELPER), @@ -194,10 +196,11 @@ def comseg( ), ): """Perform ComSeg segmentation. This can be done on all patches directly, or on one individual patch.""" - from .utils import _default_boundary_dir + import json from sopa._constants import SopaFiles, SopaKeys from sopa.segmentation.methods import comseg_patch - import json + from .utils import _default_boundary_dir + config_name = SopaFiles.JSON_CONFIG_FILE From cb1b77975236b8105e34bddd63bc303c94ec251f Mon Sep 17 00:00:00 2001 From: tdefa Date: Wed, 5 Jun 2024 19:48:14 +0200 Subject: [PATCH 06/27] pre-commit test3 --- sopa/cli/patchify.py | 48 ++++++++++++++++------------------------ sopa/cli/segmentation.py | 1 + 2 files changed, 20 insertions(+), 29 deletions(-) diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index 11ca3aed..ffc1338d 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -74,28 +74,17 @@ def baysor( """Prepare patches for transcript-based segmentation with baysor""" return transcript_segmentation( sdata_path=sdata_path, - method = "baysor", - patch_width_microns = patch_width_microns, - patch_overlap_microns = patch_overlap_microns, - temp_dir = baysor_temp_dir, - config_path = config_path, - config = config, - cell_key = cell_key, - unassigned_value = unassigned_value, + method="baysor", + patch_width_microns=patch_width_microns, + patch_overlap_microns=patch_overlap_microns, + temp_dir=baysor_temp_dir, + config_path=config_path, + config=config, + cell_key=cell_key, + unassigned_value=unassigned_value, use_prior = use_prior, - ) + ) - return transcript_segmentation( - sdata_path = sdata_path, - method = 'baysor', - patch_width_microns = patch_width_microns, - patch_overlap_microns = patch_overlap_microns, - temp_dir = baysor_temp_dir, - config_path = config_path, - config = config, - cell_key = cell_key, - unassigned_value = unassigned_value, - use_prior = use_prior) @app_patchify.command() def comseg( @@ -130,15 +119,16 @@ def comseg( """Prepare patches for transcript-based segmentation with ComSeg""" return transcript_segmentation( - sdata_path = sdata_path, - method = 'comseg', - patch_width_microns = patch_width_microns, - patch_overlap_microns = patch_overlap_microns, - temp_dir = baysor_temp_dir, - config_path = config_path, - config = config, cell_key = cell_key, - unassigned_value = unassigned_value, - use_prior = True + sdata_path=sdata_path, + method="comseg", + patch_width_microns=patch_width_microns, + patch_overlap_microns=patch_overlap_microns, + temp_dir=baysor_temp_dir, + config_path=config_path, + config=config, + cell_key=cell_key, + unassigned_value=unassigned_value, + use_prior=True, ) @app_patchify.command() def transcript_segmentation( diff --git a/sopa/cli/segmentation.py b/sopa/cli/segmentation.py index 08c2e524..0d79568c 100644 --- a/sopa/cli/segmentation.py +++ b/sopa/cli/segmentation.py @@ -199,6 +199,7 @@ def comseg( import json from sopa._constants import SopaFiles, SopaKeys from sopa.segmentation.methods import comseg_patch + from .utils import _default_boundary_dir From 947fc494e057404ef71c2ffe4ab812f343e1e4ad Mon Sep 17 00:00:00 2001 From: tdefa Date: Wed, 5 Jun 2024 19:50:44 +0200 Subject: [PATCH 07/27] pre-commit test4 --- sopa/cli/patchify.py | 5 ++++- sopa/cli/segmentation.py | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index ffc1338d..a5f78f52 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -37,6 +37,7 @@ def image( _save_cache(sdata_path, SopaFiles.PATCHES_FILE_IMAGE, str(len(patches))) + @app_patchify.command() def baysor( sdata_path: str = typer.Argument(help=SDATA_HELPER), @@ -82,7 +83,7 @@ def baysor( config=config, cell_key=cell_key, unassigned_value=unassigned_value, - use_prior = use_prior, + use_prior=use_prior, ) @@ -130,6 +131,7 @@ def comseg( unassigned_value=unassigned_value, use_prior=True, ) + @app_patchify.command() def transcript_segmentation( sdata_path: str = typer.Argument(help=SDATA_HELPER), @@ -217,6 +219,7 @@ def transcript_segmentation( ) _save_cache(sdata_path, filename, "\n".join(map(str, valid_indices))) + def _save_cache(sdata_path: str, filename: str, content: str): from pathlib import Path diff --git a/sopa/cli/segmentation.py b/sopa/cli/segmentation.py index 0d79568c..21005462 100644 --- a/sopa/cli/segmentation.py +++ b/sopa/cli/segmentation.py @@ -197,12 +197,12 @@ def comseg( ): """Perform ComSeg segmentation. This can be done on all patches directly, or on one individual patch.""" import json + from sopa._constants import SopaFiles, SopaKeys from sopa.segmentation.methods import comseg_patch from .utils import _default_boundary_dir - config_name = SopaFiles.JSON_CONFIG_FILE if patch_dir is None: From ea0b6eac415199f0711b3046b03ab90abf0a5fff Mon Sep 17 00:00:00 2001 From: tdefa Date: Wed, 5 Jun 2024 19:55:32 +0200 Subject: [PATCH 08/27] pre-commit test5 --- sopa/cli/patchify.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index a5f78f52..65dfb8e1 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -132,6 +132,7 @@ def comseg( use_prior=True, ) + @app_patchify.command() def transcript_segmentation( sdata_path: str = typer.Argument(help=SDATA_HELPER), @@ -171,7 +172,6 @@ def transcript_segmentation( help="Whether to use cellpose segmentation as a prior for baysor and comseg (if True, make sure to first run Cellpose or " f"manually add the segmentation boundaries to the sdata.shapes as {SopaKeys.CELLPOSE_BOUNDARIES} key)", ), - ): """Prepare patches for transcript-based segmentation for the different available methods (baysor, comseg)""" from sopa._constants import SopaFiles, SopaKeys From f1e58d43a8444754f2912a6c92133df2692a4346 Mon Sep 17 00:00:00 2001 From: tdefa Date: Wed, 5 Jun 2024 19:59:09 +0200 Subject: [PATCH 09/27] pre-commit test6 --- sopa/cli/patchify.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index 65dfb8e1..d526b573 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -204,10 +204,8 @@ def transcript_segmentation( df_key = get_key(sdata, "points") patches = Patches2D(sdata, df_key, patch_width_microns, patch_overlap_microns) if method == "comseg": - valid_indices_centroid = patches.patchify_centroids(temp_dir) - assert ( - use_prior == True, - ), "For ComSeg, you must use the prior segmentation of nuclei or from other staining" + patches.patchify_centroids(temp_dir) + assert use_prior, "For ComSeg, you must use the prior segmentation of nuclei or from other staining" valid_indices = patches.patchify_transcripts( temp_dir, cell_key, From 0609313a63087a2214feef2f44cf4e032cebfe8f Mon Sep 17 00:00:00 2001 From: tdefa Date: Wed, 5 Jun 2024 20:00:33 +0200 Subject: [PATCH 10/27] pre-commit test7 --- sopa/cli/patchify.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index d526b573..550acc10 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -205,7 +205,9 @@ def transcript_segmentation( patches = Patches2D(sdata, df_key, patch_width_microns, patch_overlap_microns) if method == "comseg": patches.patchify_centroids(temp_dir) - assert use_prior, "For ComSeg, you must use the prior segmentation of nuclei or from other staining" + assert ( + use_prior + ), "For ComSeg, you must use the prior segmentation of nuclei or from other staining" valid_indices = patches.patchify_transcripts( temp_dir, cell_key, From b1fb4e71b7d4a0c313e81e9d9db9bb2c5a1b512b Mon Sep 17 00:00:00 2001 From: tdefa Date: Wed, 5 Jun 2024 20:01:46 +0200 Subject: [PATCH 11/27] pre-commit test7 --- sopa/cli/patchify.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index 550acc10..b4ce9c28 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -207,7 +207,7 @@ def transcript_segmentation( patches.patchify_centroids(temp_dir) assert ( use_prior - ), "For ComSeg, you must use the prior segmentation of nuclei or from other staining" + ), "For ComSeg, you must use the prior segmentation of nuclei or from other staining" valid_indices = patches.patchify_transcripts( temp_dir, cell_key, From 68ba5eea91fb3b80a0e22d6a067128f3c1699f73 Mon Sep 17 00:00:00 2001 From: tdefa Date: Mon, 10 Jun 2024 13:59:12 +0200 Subject: [PATCH 12/27] fix_cli --- sopa/cli/patchify.py | 113 +++++++++++++++++---------------------- sopa/cli/segmentation.py | 12 ++--- 2 files changed, 56 insertions(+), 69 deletions(-) diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index b4ce9c28..fe1afacd 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -56,7 +56,7 @@ def baysor( config: str = typer.Option( default={}, callback=ast.literal_eval, - help="Dictionnary of baysor parameters", + help="Dictionnary of baysor parameters, overwrite the config_path argument if provided", ), cell_key: str = typer.Option( None, @@ -73,12 +73,19 @@ def baysor( ), ): """Prepare patches for transcript-based segmentation with baysor""" - return transcript_segmentation( + from sopa._constants import SopaKeys, SopaFiles + from .utils import _default_boundary_dir + + + if baysor_temp_dir is None: + baysor_temp_dir = _default_boundary_dir(sdata_path, SopaKeys.BAYSOR_BOUNDARIES) + return _transcript_segmentation( sdata_path=sdata_path, - method="baysor", patch_width_microns=patch_width_microns, patch_overlap_microns=patch_overlap_microns, temp_dir=baysor_temp_dir, + filename=SopaFiles.PATCHES_DIRS_BAYSOR, + config_name=SopaFiles.TOML_CONFIG_FILE, config_path=config_path, config=config, cell_key=cell_key, @@ -94,7 +101,7 @@ def comseg( patch_overlap_microns: float = typer.Option( help="Number of overlapping microns between the patches. We advise to choose approximately twice the diameter of a cell" ), - baysor_temp_dir: str = typer.Option( + comseg_temp_dir: str = typer.Option( None, help="Temporary directory where baysor inputs and outputs will be saved. By default, uses `.sopa_cache/comseg_boundaries`", ), @@ -105,7 +112,7 @@ def comseg( config: str = typer.Option( default={}, callback=ast.literal_eval, - help="Dictionnary of ComSeg parameters", + help="Dictionnary of ComSeg parameters, overwrite the config_path argument if provided", ), cell_key: str = typer.Option( None, @@ -118,13 +125,19 @@ def comseg( ), ): """Prepare patches for transcript-based segmentation with ComSeg""" + from sopa._constants import SopaKeys, SopaFiles + from .utils import _default_boundary_dir - return transcript_segmentation( + if comseg_temp_dir is None: + comseg_temp_dir = _default_boundary_dir(sdata_path, SopaKeys.COMSEG_BOUNDARIES) + + return _transcript_segmentation( sdata_path=sdata_path, - method="comseg", patch_width_microns=patch_width_microns, patch_overlap_microns=patch_overlap_microns, - temp_dir=baysor_temp_dir, + temp_dir=comseg_temp_dir, + filename=SopaFiles.PATCHES_DIRS_COMSEG, + config_name=SopaFiles.JSON_CONFIG_FILE, config_path=config_path, config=config, cell_key=cell_key, @@ -133,48 +146,35 @@ def comseg( ) -@app_patchify.command() -def transcript_segmentation( - sdata_path: str = typer.Argument(help=SDATA_HELPER), - method: str = typer.Option( - "baysor", - help="Name of the method to use, choose in ['baysor', 'comseg']. for ComSeg, make sure to first run Cellpose or " - f"manually add the segmentation boundaries to the sdata.shapes as {SopaKeys.CELLPOSE_BOUNDARIES} key", - ), - patch_width_microns: float = typer.Option(help="Width (and height) of each patch in microns"), - patch_overlap_microns: float = typer.Option( - help="Number of overlapping microns between the patches. We advise to choose approximately twice the diameter of a cell" - ), - temp_dir: str = typer.Option( - None, - help="Temporary directory where baysor inputs and outputs will be saved. By default, uses `.sopa_cache/baysor_boundaries`", - ), - config_path: str = typer.Option( - None, - help="Path to the baysor config (you can also directly provide the argument via the `config` option)", - ), - config: str = typer.Option( - default={}, - callback=ast.literal_eval, - help="Dictionnary of baysor parameters", - ), - cell_key: str = typer.Option( - None, - help="Optional column of the transcripts dataframe that indicates in which cell-id each transcript is, in order to use prior segmentation. " - f" Default is {SopaKeys.DEFAULT_CELL_KEY} if cell_key=None", - ), - unassigned_value: int = typer.Option( - None, - help="If --cell-key is provided, this is the value given to transcripts that are not inside any cell (if it's already 0, don't provide this argument)", - ), - use_prior: bool = typer.Option( - False, - help="Whether to use cellpose segmentation as a prior for baysor and comseg (if True, make sure to first run Cellpose or " - f"manually add the segmentation boundaries to the sdata.shapes as {SopaKeys.CELLPOSE_BOUNDARIES} key)", - ), +def _transcript_segmentation( + sdata_path: str, + patch_width_microns: float, + patch_overlap_microns: float, + temp_dir: str, + filename: str, + config_name: str, + config_path: str, + config: str, + cell_key: str, + use_prior: bool, + unassigned_value: int, ): - """Prepare patches for transcript-based segmentation for the different available methods (baysor, comseg)""" - from sopa._constants import SopaFiles, SopaKeys + """Prepare patches for transcript-based segmentation for the different available methods (baysor, comseg) + args: + sdata_path (str) : Path to the SpatialData object + patch_width_microns (float) : Width (and height) of each patch in microns + patch_overlap_microns (str) : Number of overlapping microns between the patches. We advise to choose approximately twice the diameter of a cell + temp_dir (str) : Temporary directory where baysor inputs and outputs will be saved. By default, uses `.sopa_cache/baysor_boundaries`" + filename (str) : Name of the file to indicating the patch's index + config_name (str) : Name of the config file created for each patch + config_path (str): "Path to the config file (you can also directly provide the argument via the `config` option)" + config (str): "Dictionnary of parameters" + cell_key (str): "Optional column of the transcripts dataframe that indicates in which cell-id each transcript is, in order to use prior segmentation. + " Default is cell if cell_key=None" + use_prior (bool): "Whether to use cellpose segmentation as a prior for baysor and comseg (if True, make sure to first run Cellpose)" + unassigned_value (int): "If cell-key is provided, this is the value given to transcripts that are not inside any cell (if it's already 0, don't provide this argument)" + + """ from sopa._sdata import get_key from sopa.io.standardize import read_zarr_standardized, sanity_check from sopa.patches import Patches2D @@ -187,23 +187,10 @@ def transcript_segmentation( assert ( config or config_path is not None ), "Provide '--config-path', the path to a Baysor config file (toml) or comseg file (jsons)" - assert method in ["baysor", "comseg"], "method must be either 'baysor' or 'comseg'" - - if temp_dir is None: - if method == "baysor": - temp_dir = _default_boundary_dir(sdata_path, SopaKeys.BAYSOR_BOUNDARIES) - filename = SopaFiles.PATCHES_DIRS_BAYSOR - config_name = SopaFiles.TOML_CONFIG_FILE - elif method == "comseg": - temp_dir = _default_boundary_dir(sdata_path, SopaKeys.COMSEG_BOUNDARIES) - filename = SopaFiles.PATCHES_DIRS_COMSEG - config_name = SopaFiles.JSON_CONFIG_FILE - else: - raise ValueError("method must be either 'baysor' or 'comseg'") df_key = get_key(sdata, "points") patches = Patches2D(sdata, df_key, patch_width_microns, patch_overlap_microns) - if method == "comseg": + if filename==SopaKeys.COMSEG_BOUNDARIES: patches.patchify_centroids(temp_dir) assert ( use_prior diff --git a/sopa/cli/segmentation.py b/sopa/cli/segmentation.py index 21005462..5ceaa4fb 100644 --- a/sopa/cli/segmentation.py +++ b/sopa/cli/segmentation.py @@ -1,8 +1,7 @@ from __future__ import annotations import ast -import logging -from pathlib import Path + import typer from tqdm import tqdm @@ -11,7 +10,6 @@ app_segmentation = typer.Typer() -log = logging.getLogger(__name__) @app_segmentation.command() @@ -188,11 +186,11 @@ def comseg( sdata_path: str = typer.Argument(help=SDATA_HELPER), patch_index: int = typer.Option( default=None, - help="Index of the patch on which the segmentation method should be run. NB: the number of patches is `len(sdata['sopa_patches'])`", + help="Index of the patch on which the segmentation method should be run.`", ), patch_dir: str = typer.Option( default=None, - help="Path to the temporary the segmentation method directory inside which we will store each individual patch segmentation. By default, saves into the `.sopa_cache/` directory", + help="Path to the temporary the segmentation method directory inside which we will store each individual patch segmentation. By default, saves into the `.sopa_cache/comseg` directory", ), ): """Perform ComSeg segmentation. This can be done on all patches directly, or on one individual patch.""" @@ -200,7 +198,9 @@ def comseg( from sopa._constants import SopaFiles, SopaKeys from sopa.segmentation.methods import comseg_patch - + import logging + log = logging.getLogger(__name__) + from pathlib import Path from .utils import _default_boundary_dir config_name = SopaFiles.JSON_CONFIG_FILE From b025d28a4314edf970fad587b48cf9f9cd50d222 Mon Sep 17 00:00:00 2001 From: tdefa Date: Mon, 10 Jun 2024 14:05:09 +0200 Subject: [PATCH 13/27] fix_cli --- sopa/cli/patchify.py | 4 +++- sopa/cli/segmentation.py | 8 +++++--- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index fe1afacd..cff39b8f 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -125,7 +125,9 @@ def comseg( ), ): """Prepare patches for transcript-based segmentation with ComSeg""" + from sopa._constants import SopaKeys, SopaFiles + from .utils import _default_boundary_dir if comseg_temp_dir is None: @@ -190,7 +192,7 @@ def _transcript_segmentation( df_key = get_key(sdata, "points") patches = Patches2D(sdata, df_key, patch_width_microns, patch_overlap_microns) - if filename==SopaKeys.COMSEG_BOUNDARIES: + if filename == SopaKeys.COMSEG_BOUNDARIES: patches.patchify_centroids(temp_dir) assert ( use_prior diff --git a/sopa/cli/segmentation.py b/sopa/cli/segmentation.py index 5ceaa4fb..5a3baa9f 100644 --- a/sopa/cli/segmentation.py +++ b/sopa/cli/segmentation.py @@ -2,7 +2,6 @@ import ast - import typer from tqdm import tqdm @@ -195,14 +194,17 @@ def comseg( ): """Perform ComSeg segmentation. This can be done on all patches directly, or on one individual patch.""" import json + import logging from sopa._constants import SopaFiles, SopaKeys from sopa.segmentation.methods import comseg_patch - import logging - log = logging.getLogger(__name__) + from pathlib import Path + from .utils import _default_boundary_dir + log = logging.getLogger(__name__) + config_name = SopaFiles.JSON_CONFIG_FILE if patch_dir is None: From 3c4624d4a927dcf3fa48d94a8757e1c6161afb6e Mon Sep 17 00:00:00 2001 From: tdefa Date: Mon, 10 Jun 2024 14:18:50 +0200 Subject: [PATCH 14/27] fix_cli_typo --- sopa/cli/patchify.py | 3 ++- sopa/cli/segmentation.py | 5 ++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index cff39b8f..79ff3417 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -74,6 +74,7 @@ def baysor( ): """Prepare patches for transcript-based segmentation with baysor""" from sopa._constants import SopaKeys, SopaFiles + from .utils import _default_boundary_dir @@ -126,7 +127,7 @@ def comseg( ): """Prepare patches for transcript-based segmentation with ComSeg""" - from sopa._constants import SopaKeys, SopaFiles + from sopa._constants import SopaFiles, SopaKeys from .utils import _default_boundary_dir diff --git a/sopa/cli/segmentation.py b/sopa/cli/segmentation.py index 5a3baa9f..1af75ba4 100644 --- a/sopa/cli/segmentation.py +++ b/sopa/cli/segmentation.py @@ -10,7 +10,6 @@ app_segmentation = typer.Typer() - @app_segmentation.command() def cellpose( sdata_path: str = typer.Argument(help=SDATA_HELPER), @@ -195,15 +194,15 @@ def comseg( """Perform ComSeg segmentation. This can be done on all patches directly, or on one individual patch.""" import json import logging + from pathlib import Path from sopa._constants import SopaFiles, SopaKeys from sopa.segmentation.methods import comseg_patch - from pathlib import Path from .utils import _default_boundary_dir - log = logging.getLogger(__name__) + log=logging.getLogger(__name__) config_name = SopaFiles.JSON_CONFIG_FILE From 8f436e80e36a6f582459ebdd6819a70708efadfd Mon Sep 17 00:00:00 2001 From: tdefa Date: Mon, 10 Jun 2024 14:23:09 +0200 Subject: [PATCH 15/27] fix_cli_typo --- sopa/cli/patchify.py | 2 +- sopa/cli/segmentation.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index 79ff3417..7755fa21 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -73,7 +73,7 @@ def baysor( ), ): """Prepare patches for transcript-based segmentation with baysor""" - from sopa._constants import SopaKeys, SopaFiles + from sopa._constants import SopaFiles, SopaKeys from .utils import _default_boundary_dir diff --git a/sopa/cli/segmentation.py b/sopa/cli/segmentation.py index 1af75ba4..48416d04 100644 --- a/sopa/cli/segmentation.py +++ b/sopa/cli/segmentation.py @@ -202,7 +202,7 @@ def comseg( from .utils import _default_boundary_dir - log=logging.getLogger(__name__) + log = logging.getLogger(__name__) config_name = SopaFiles.JSON_CONFIG_FILE From 792adfb6645b40bad4bcb850dedfc326c7563775 Mon Sep 17 00:00:00 2001 From: tdefa Date: Tue, 11 Jun 2024 15:11:09 +0200 Subject: [PATCH 16/27] snakemake --- sopa/cli/patchify.py | 4 +- sopa/cli/segmentation.py | 1 - workflow/Snakefile | 66 ++++++++++++++++++- workflow/config/cosmx/comseg_cellpose.yaml | 50 ++++++++++++++ workflow/config/merscope/comseg_cellpose.yaml | 52 +++++++++++++++ workflow/config/toy/uniform_comseg.yaml | 51 ++++++++++++++ workflow/utils.py | 29 +++++++- 7 files changed, 246 insertions(+), 7 deletions(-) create mode 100644 workflow/config/cosmx/comseg_cellpose.yaml create mode 100644 workflow/config/merscope/comseg_cellpose.yaml create mode 100644 workflow/config/toy/uniform_comseg.yaml diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index 7755fa21..8be3f50b 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -77,7 +77,6 @@ def baysor( from .utils import _default_boundary_dir - if baysor_temp_dir is None: baysor_temp_dir = _default_boundary_dir(sdata_path, SopaKeys.BAYSOR_BOUNDARIES) return _transcript_segmentation( @@ -178,6 +177,7 @@ def _transcript_segmentation( unassigned_value (int): "If cell-key is provided, this is the value given to transcripts that are not inside any cell (if it's already 0, don't provide this argument)" """ + from sopa._constants import SopaFiles, SopaKeys from sopa._sdata import get_key from sopa.io.standardize import read_zarr_standardized, sanity_check from sopa.patches import Patches2D @@ -193,7 +193,7 @@ def _transcript_segmentation( df_key = get_key(sdata, "points") patches = Patches2D(sdata, df_key, patch_width_microns, patch_overlap_microns) - if filename == SopaKeys.COMSEG_BOUNDARIES: + if filename == SopaFiles.PATCHES_DIRS_COMSEG: patches.patchify_centroids(temp_dir) assert ( use_prior diff --git a/sopa/cli/segmentation.py b/sopa/cli/segmentation.py index 48416d04..6518c1db 100644 --- a/sopa/cli/segmentation.py +++ b/sopa/cli/segmentation.py @@ -199,7 +199,6 @@ def comseg( from sopa._constants import SopaFiles, SopaKeys from sopa.segmentation.methods import comseg_patch - from .utils import _default_boundary_dir log = logging.getLogger(__name__) diff --git a/workflow/Snakefile b/workflow/Snakefile index a81652d5..8b42f660 100644 --- a/workflow/Snakefile +++ b/workflow/Snakefile @@ -68,6 +68,23 @@ checkpoint patchify_baysor: sopa patchify baysor {paths.sdata_path} {params.args_patchify} {params.args_baysor} {params.arg_prior} """ +checkpoint patchify_comseg: + input: + paths.sdata_zgroup, + paths.smk_cellpose_boundaries, + output: + patches_file = paths.smk_patches_file_comseg, + smk_comseg_temp_dir = directory(paths.smk_comseg_temp_dir), + params: + args_patchify = str(args["patchify"].where(contains="micron")), + args_comseg = args.dump_comseg_patchify() if args.comseg else "", + conda: + "sopa" + shell: + """ + sopa patchify comseg {paths.sdata_path} {params.args_patchify} {params.args_comseg} + """ + rule patch_segmentation_cellpose: input: paths.smk_patches_file_image, @@ -104,6 +121,20 @@ rule patch_segmentation_baysor: {config[executables][baysor]} run --save-polygons GeoJSON -c config.toml transcripts.csv {params.args_baysor_prior_seg} """ +rule patch_segmentation_comseg: + input: + patches_file = paths.smk_patches_file_comseg, + baysor_patch = paths.smk_comseg_temp_dir / "{index}", + output: + paths.smk_comseg_temp_dir / "{index}" / "segmentation_polygons.json", + paths.smk_comseg_temp_dir / "{index}" / "segmentation_counts.h5ad", + resources: + mem_mb=128_000, + shell: + """ + sopa segmentation comseg {paths.sdata_path} --patch-dir {paths.smk_comseg_temp_dir} --patch-index {wildcards.index} + """ + def get_input_resolve(name, dirs=False): def _(wilcards): with getattr(checkpoints, f"patchify_{name}").get(**wilcards).output.patches_file.open() as f: @@ -141,9 +172,38 @@ rule resolve_baysor: rm -r {paths.smk_baysor_temp_dir} # cleanup large baysor files """ +rule resolve_comseg: + input: + files = get_input_resolve("comseg"), + dirs = get_input_resolve("comseg",dirs=True), + output: + touch(paths.smk_comseg_boundaries), + touch(paths.smk_table), + conda: + "sopa" + params: + args_patches_dirs=lambda _, input: " ".join(f"--patches-dirs {directory}" for directory in input.dirs), + args_min_area=args.min_area("comseg"), + shell: + """ + sopa resolve comseg {paths.sdata_path} --gene-column {args.gene_column} {params.args_min_area} {params.args_patches_dirs} + + rm -r {paths.smk_comseg_temp_dir} # cleanup large comseg files + """ + +def get_smk_boundaries(args): + if args.baysor: + return paths.smk_baysor_boundaries + elif args.comseg: + return paths.smk_comseg_boundaries + elif args.cellpose: + return paths.smk_cellpose_boundaries + else: + raise ValueError("No segmentation method selected") + rule aggregate: input: - paths.smk_baysor_boundaries if args.baysor else paths.smk_cellpose_boundaries, + get_smk_boundaries(args), output: touch(paths.smk_aggregation), conda: @@ -194,7 +254,7 @@ rule image_write: rule report: input: - paths.smk_baysor_boundaries if args.baysor else paths.smk_cellpose_boundaries, + get_smk_boundaries(args), paths.smk_aggregation, paths.annotations if args.annotate else [], output: @@ -208,7 +268,7 @@ rule report: rule explorer: input: - paths.smk_baysor_boundaries if args.baysor else paths.smk_cellpose_boundaries, + get_smk_boundaries(args), paths.smk_aggregation, paths.annotations if args.annotate else [], output: diff --git a/workflow/config/cosmx/comseg_cellpose.yaml b/workflow/config/cosmx/comseg_cellpose.yaml new file mode 100644 index 00000000..bd1ad1a5 --- /dev/null +++ b/workflow/config/cosmx/comseg_cellpose.yaml @@ -0,0 +1,50 @@ +# For parameters details, see this commented example: https://github.com/gustaveroussy/sopa/blob/master/workflow/config/example_commented.yaml +read: + technology: cosmx + +patchify: + patch_width_pixel: 6000 + patch_overlap_pixel: 150 + patch_width_microns: 800 + patch_overlap_microns: 50 + +segmentation: + cellpose: + diameter: 60 + channels: ["DNA"] + flow_threshold: 2 + cellprob_threshold: -6 + min_area: 2000 + + comseg: + min_area: 10 + config: + dict_scale: + x: 1 + y: 1 + z: 1 + mean_cell_diameter: 8 + max_cell_radius: 15 + alpha: 0.5 + min_rna_per_cell: 5 + gene_column: "genes", + allow_disconnected_polygon : true + +aggregate: + average_intensities: true + min_transcripts: 10 # [optional] cells whose transcript count is below that this threshold are filtered + +# Comment this out if you want to use tangram --> + +# annotation: +# method: tangram +# args: +# sc_reference_path: "..." +# cell_type_key: ct + +explorer: + gene_column: "target" + ram_threshold_gb: 4 + +executables: + baysor: ~/.julia/bin/baysor # if you run baysor, put here the path to the baysor executable diff --git a/workflow/config/merscope/comseg_cellpose.yaml b/workflow/config/merscope/comseg_cellpose.yaml new file mode 100644 index 00000000..60efa9b7 --- /dev/null +++ b/workflow/config/merscope/comseg_cellpose.yaml @@ -0,0 +1,52 @@ +# For parameters details, see this commented example: https://github.com/gustaveroussy/sopa/blob/master/workflow/config/example_commented.yaml +read: + technology: merscope + +patchify: + patch_width_pixel: 6000 + patch_overlap_pixel: 150 + patch_width_microns: 8000 + patch_overlap_microns: 20 + +segmentation: + cellpose: + diameter: 60 + channels: ["DAPI"] + flow_threshold: 2 + cellprob_threshold: -6 + min_area: 2000 + + comseg: + min_area: 10 + config: + dict_scale: + x: 1 + y: 1 + z: 1 + mean_cell_diameter: 15 + max_cell_radius: 50 + alpha: 0.5 + min_rna_per_cell: 5 + gene_column: "genes", + allow_disconnected_polygon : true + + +aggregate: + average_intensities: true + min_transcripts: 10 # [optional] cells whose transcript count is below that this threshold are filtered + +# Comment this out if you want to use tangram --> + +# annotation: +# method: tangram +# args: +# sc_reference_path: "..." +# cell_type_key: ct + +explorer: + gene_column: "gene" + ram_threshold_gb: 4 + pixel_size: 0.108 + +executables: + baysor: ~/.julia/bin/baysor # if you run baysor, put here the path to the baysor executable diff --git a/workflow/config/toy/uniform_comseg.yaml b/workflow/config/toy/uniform_comseg.yaml new file mode 100644 index 00000000..e585d9ce --- /dev/null +++ b/workflow/config/toy/uniform_comseg.yaml @@ -0,0 +1,51 @@ +# For parameters details, see this commented example: https://github.com/gustaveroussy/sopa/blob/master/workflow/config/example_commented.yaml +read: + technology: uniform + +patchify: + patch_width_pixel: 1200 + patch_overlap_pixel: 50 + patch_width_microns: 3000 + patch_overlap_microns: 40 + +segmentation: + cellpose: + diameter: 35 + channels: [ "DAPI" ] + flow_threshold: 2 + cellprob_threshold: -6 + min_area: 2500 + + comseg: + min_area: 10 + config: + dict_scale: + x: 1 + y: 1 + z: 1 + mean_cell_diameter: 15 + max_cell_radius: 50 + alpha: 0.5 + min_rna_per_cell: 5 + gene_column: "genes" + + +aggregate: + average_intensities: true + gene_column: genes + +annotation: + method: fluorescence + args: + marker_cell_dict: + CK: Tumoral cell + CD3: T cell + CD20: B cell + +explorer: + gene_column: "genes" + ram_threshold_gb: 4 + pixel_size: 1 + +executables: + baysor: ~/.julia/bin/baysor diff --git a/workflow/utils.py b/workflow/utils.py index 2a860d3b..6e375443 100644 --- a/workflow/utils.py +++ b/workflow/utils.py @@ -60,10 +60,13 @@ def __init__(self, config: dict) -> None: self.smk_patches = self.sopa_cache / "patches" self.smk_patches_file_image = self.sopa_cache / "patches_file_image" self.smk_patches_file_baysor = self.sopa_cache / "patches_file_baysor" + self.smk_patches_file_comseg = self.sopa_cache / "patches_file_comseg" self.smk_cellpose_temp_dir = self.sopa_cache / "cellpose_boundaries" self.smk_baysor_temp_dir = self.sopa_cache / "baysor_boundaries" + self.smk_comseg_temp_dir = self.sopa_cache / "comseg_boundaries" self.smk_cellpose_boundaries = self.sopa_cache / "cellpose_boundaries_done" self.smk_baysor_boundaries = self.sopa_cache / "baysor_boundaries_done" + self.smk_comseg_boundaries = self.sopa_cache / "comseg_boundaries_done" self.smk_aggregation = self.sopa_cache / "aggregation" # annotation files @@ -105,6 +108,19 @@ def cells_paths(self, file_content: str, name, dirs: bool = False): for i in indices for file in BAYSOR_FILES ] + if name == "comseg": + indices = map(int, file_content.split()) + COMSEG_FILES = ["segmentation_polygons.json", "segmentation_counts.h5ad"] + + if dirs: + return [str(self.smk_comseg_temp_dir / str(i)) for i in indices] + return [ + str(self.smk_comseg_temp_dir / str(i) / file) + for i in indices + for file in COMSEG_FILES + ] + + class Args: @@ -122,6 +138,7 @@ def __init__(self, paths: WorkflowPaths, config: dict): # which segmentation method(s) is/are used self.cellpose = self.segmentation and "cellpose" in self.config["segmentation"] self.baysor = self.segmentation and "baysor" in self.config["segmentation"] + self.comseg = self.segmentation and "comseg" in self.config["segmentation"] and "cellpose" in self.config["segmentation"] # whether to run annotation self.annotate = "annotation" in self.config and "method" in self.config["annotation"] @@ -196,7 +213,17 @@ def baysor_prior_seg(self): @property def gene_column(self): - return self.config["segmentation"]["baysor"]["config"]["data"]["gene"] + if "baysor" in self.config["segmentation"]: + return self.config["segmentation"]["baysor"]["config"]["data"]["gene"] + elif "comseg" in self.config["segmentation"]: + return self.config["segmentation"]["comseg"]["config"]["gene_column"] + else: + raise ValueError("No gene column found in the config") + + ### comseg related methods + def dump_comseg_patchify(self): + return f'--comseg-temp-dir {self.paths.smk_comseg_temp_dir} {self["segmentation"]["comseg"].where(keys=["cell_key", "unassigned_value", "config"])}' + def stringify_for_cli(value) -> str: From d7c7e60ebef854f3be1634becd4603f6d2115037 Mon Sep 17 00:00:00 2001 From: tdefa Date: Tue, 11 Jun 2024 15:22:08 +0200 Subject: [PATCH 17/27] fix comma --- workflow/config/cosmx/comseg_cellpose.yaml | 2 +- workflow/config/merscope/comseg_cellpose.yaml | 4 ++-- workflow/config/toy/uniform_baysor.yaml | 10 +++++++++- workflow/config/toy/uniform_comseg.yaml | 4 ++-- workflow/utils.py | 9 +++++---- 5 files changed, 19 insertions(+), 10 deletions(-) diff --git a/workflow/config/cosmx/comseg_cellpose.yaml b/workflow/config/cosmx/comseg_cellpose.yaml index bd1ad1a5..7d2914f2 100644 --- a/workflow/config/cosmx/comseg_cellpose.yaml +++ b/workflow/config/cosmx/comseg_cellpose.yaml @@ -27,7 +27,7 @@ segmentation: max_cell_radius: 15 alpha: 0.5 min_rna_per_cell: 5 - gene_column: "genes", + gene_column: "genes" allow_disconnected_polygon : true aggregate: diff --git a/workflow/config/merscope/comseg_cellpose.yaml b/workflow/config/merscope/comseg_cellpose.yaml index 60efa9b7..36db7268 100644 --- a/workflow/config/merscope/comseg_cellpose.yaml +++ b/workflow/config/merscope/comseg_cellpose.yaml @@ -5,7 +5,7 @@ read: patchify: patch_width_pixel: 6000 patch_overlap_pixel: 150 - patch_width_microns: 8000 + patch_width_microns: 1000 patch_overlap_microns: 20 segmentation: @@ -27,7 +27,7 @@ segmentation: max_cell_radius: 50 alpha: 0.5 min_rna_per_cell: 5 - gene_column: "genes", + gene_column: "genes" allow_disconnected_polygon : true diff --git a/workflow/config/toy/uniform_baysor.yaml b/workflow/config/toy/uniform_baysor.yaml index b628470d..6f78d126 100644 --- a/workflow/config/toy/uniform_baysor.yaml +++ b/workflow/config/toy/uniform_baysor.yaml @@ -9,6 +9,14 @@ patchify: patch_overlap_microns: 20 segmentation: + cellpose: + diameter: 35 + channels: [ "DAPI" ] + flow_threshold: 2 + cellprob_threshold: -6 + min_area: 2500 + + baysor: min_area: 10 @@ -55,4 +63,4 @@ explorer: pixel_size: 0.1 executables: - baysor: ~/.julia/bin/baysor + baysor: /home/tom/Bureau/phd/simulation/baysor/baysor_2023/baysor-x86_x64-linux-v0.6.2_build/bin/baysor/bin/baysor diff --git a/workflow/config/toy/uniform_comseg.yaml b/workflow/config/toy/uniform_comseg.yaml index e585d9ce..662d8f52 100644 --- a/workflow/config/toy/uniform_comseg.yaml +++ b/workflow/config/toy/uniform_comseg.yaml @@ -23,8 +23,8 @@ segmentation: x: 1 y: 1 z: 1 - mean_cell_diameter: 15 - max_cell_radius: 50 + mean_cell_diameter: 8 + max_cell_radius: 15 alpha: 0.5 min_rna_per_cell: 5 gene_column: "genes" diff --git a/workflow/utils.py b/workflow/utils.py index 6e375443..cbf5f15e 100644 --- a/workflow/utils.py +++ b/workflow/utils.py @@ -121,8 +121,6 @@ def cells_paths(self, file_content: str, name, dirs: bool = False): ] - - class Args: """ A convenient class to provide the YAML config arguments to Snakemake @@ -138,7 +136,11 @@ def __init__(self, paths: WorkflowPaths, config: dict): # which segmentation method(s) is/are used self.cellpose = self.segmentation and "cellpose" in self.config["segmentation"] self.baysor = self.segmentation and "baysor" in self.config["segmentation"] - self.comseg = self.segmentation and "comseg" in self.config["segmentation"] and "cellpose" in self.config["segmentation"] + self.comseg = ( + self.segmentation + and "comseg" in self.config["segmentation"] + and "cellpose" in self.config["segmentation"] + ) # whether to run annotation self.annotate = "annotation" in self.config and "method" in self.config["annotation"] @@ -225,7 +227,6 @@ def dump_comseg_patchify(self): return f'--comseg-temp-dir {self.paths.smk_comseg_temp_dir} {self["segmentation"]["comseg"].where(keys=["cell_key", "unassigned_value", "config"])}' - def stringify_for_cli(value) -> str: if isinstance(value, str) or isinstance(value, dict): return f'"{value}"' From 207dffc58f138a61a586331c3d985f38e1afe425 Mon Sep 17 00:00:00 2001 From: tdefa Date: Tue, 11 Jun 2024 15:23:35 +0200 Subject: [PATCH 18/27] fix comma --- sopa/cli/patchify.py | 4 +--- workflow/Snakefile | 4 ++-- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index 8be3f50b..2885672e 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -177,13 +177,11 @@ def _transcript_segmentation( unassigned_value (int): "If cell-key is provided, this is the value given to transcripts that are not inside any cell (if it's already 0, don't provide this argument)" """ - from sopa._constants import SopaFiles, SopaKeys + from sopa._constants import SopaFiles from sopa._sdata import get_key from sopa.io.standardize import read_zarr_standardized, sanity_check from sopa.patches import Patches2D - from .utils import _default_boundary_dir - sdata = read_zarr_standardized(sdata_path) sanity_check(sdata) diff --git a/workflow/Snakefile b/workflow/Snakefile index 8b42f660..4c9ce307 100644 --- a/workflow/Snakefile +++ b/workflow/Snakefile @@ -82,7 +82,7 @@ checkpoint patchify_comseg: "sopa" shell: """ - sopa patchify comseg {paths.sdata_path} {params.args_patchify} {params.args_comseg} + sopa patchify comseg {paths.sdata_path} {params.args_patchify} {params.args_comseg} """ rule patch_segmentation_cellpose: @@ -132,7 +132,7 @@ rule patch_segmentation_comseg: mem_mb=128_000, shell: """ - sopa segmentation comseg {paths.sdata_path} --patch-dir {paths.smk_comseg_temp_dir} --patch-index {wildcards.index} + sopa segmentation comseg {paths.sdata_path} --patch-dir {paths.smk_comseg_temp_dir} --patch-index {wildcards.index} """ def get_input_resolve(name, dirs=False): From 95fb271c7e27c1b1e3509a010cca38c24b3d65f0 Mon Sep 17 00:00:00 2001 From: tdefa Date: Tue, 11 Jun 2024 15:33:42 +0200 Subject: [PATCH 19/27] remove modif baysor --- workflow/config/toy/uniform_baysor.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/workflow/config/toy/uniform_baysor.yaml b/workflow/config/toy/uniform_baysor.yaml index 6f78d126..6293eb52 100644 --- a/workflow/config/toy/uniform_baysor.yaml +++ b/workflow/config/toy/uniform_baysor.yaml @@ -63,4 +63,4 @@ explorer: pixel_size: 0.1 executables: - baysor: /home/tom/Bureau/phd/simulation/baysor/baysor_2023/baysor-x86_x64-linux-v0.6.2_build/bin/baysor/bin/baysor + baysor: ~/.julia/bin/baysor From 3b0f1cba9812c135b13345e2e6bf0c6ab13a2d7a Mon Sep 17 00:00:00 2001 From: tdefa Date: Tue, 11 Jun 2024 15:35:56 +0200 Subject: [PATCH 20/27] remove modif baysor --- workflow/config/toy/uniform_baysor.yaml | 8 -------- 1 file changed, 8 deletions(-) diff --git a/workflow/config/toy/uniform_baysor.yaml b/workflow/config/toy/uniform_baysor.yaml index 6293eb52..b628470d 100644 --- a/workflow/config/toy/uniform_baysor.yaml +++ b/workflow/config/toy/uniform_baysor.yaml @@ -9,14 +9,6 @@ patchify: patch_overlap_microns: 20 segmentation: - cellpose: - diameter: 35 - channels: [ "DAPI" ] - flow_threshold: 2 - cellprob_threshold: -6 - min_area: 2500 - - baysor: min_area: 10 From e022aca97db207b6d00c775343722a164ddfccca Mon Sep 17 00:00:00 2001 From: Blampey Quentin Date: Fri, 14 Jun 2024 16:58:30 +0200 Subject: [PATCH 21/27] minor cleaning/fixes --- docs/cli.md | 32 +- ...other_segmentations.ipynb => comseg.ipynb} | 443 ++---------------- mkdocs.yml | 2 + sopa/cli/patchify.py | 38 +- sopa/cli/segmentation.py | 3 +- sopa/segmentation/methods.py | 2 +- workflow/Snakefile | 2 + workflow/utils.py | 3 +- 8 files changed, 87 insertions(+), 438 deletions(-) rename docs/tutorials/{other_segmentations.ipynb => comseg.ipynb} (91%) diff --git a/docs/cli.md b/docs/cli.md index 77f7c224..30420874 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -347,8 +347,8 @@ $ sopa patchify [OPTIONS] COMMAND [ARGS]... **Commands**: -* `baysor`: Prepare patches for transcript-based segmentation with Baysor -* `comseg`: Prepare patches for transcript-based segmentation with ComSeg +* `baysor`: Prepare patches for transcript-based... +* `comseg`: Prepare patches for transcript-based... * `image`: Prepare patches for staining-based... #### `sopa patchify baysor` @@ -371,8 +371,8 @@ $ sopa patchify baysor [OPTIONS] SDATA_PATH * `--patch-overlap-microns FLOAT`: Number of overlapping microns between the patches. We advise to choose approximately twice the diameter of a cell [required] * `--baysor-temp-dir TEXT`: Temporary directory where baysor inputs and outputs will be saved. By default, uses `.sopa_cache/baysor_boundaries` * `--config-path TEXT`: Path to the baysor config (you can also directly provide the argument via the `config` option) -* `--config TEXT`: Dictionnary of baysor parameters [default: {}] -* `--cell-key TEXT`: Optional column of the transcripts dataframe that indicates in which cell-id each transcript is, in order to use prior segmentation +* `--config TEXT`: Dictionnary of baysor parameters, overwrite the config_path argument if provided [default: {}] +* `--cell-key TEXT`: Optional column of the transcripts dataframe that indicates in which cell-id each transcript is, in order to use prior segmentation Default is 'cell' if cell_key=None * `--unassigned-value INTEGER`: If --cell-key is provided, this is the value given to transcripts that are not inside any cell (if it's already 0, don't provide this argument) * `--use-prior / --no-use-prior`: Whether to use cellpose segmentation as a prior for baysor (if True, make sure to first run Cellpose) [default: no-use-prior] * `--help`: Show this message and exit. @@ -395,10 +395,10 @@ $ sopa patchify comseg [OPTIONS] SDATA_PATH * `--patch-width-microns FLOAT`: Width (and height) of each patch in microns [required] * `--patch-overlap-microns FLOAT`: Number of overlapping microns between the patches. We advise to choose approximately twice the diameter of a cell [required] -* `--baysor-temp-dir TEXT`: Temporary directory where ComSeg inputs and outputs will be saved. By default, uses `.sopa_cache/comseg_boundaries` -* `--config-path TEXT`: Path to the baysor config (you can also directly provide the argument via the `config` option) -* `--config TEXT`: Dictionnary of baysor parameters [default: {}] -* `--cell-key TEXT`: Optional column of the transcripts dataframe that indicates in which cell-id each transcript is, in order to use prior segmentation. Default is 'cell' if cell_key=None +* `--comseg-temp-dir TEXT`: Temporary directory where baysor inputs and outputs will be saved. By default, uses `.sopa_cache/comseg_boundaries` +* `--config-path TEXT`: Path to the ComSeg json config file (you can also directly provide the argument via the `config` option) +* `--config TEXT`: Dictionnary of ComSeg parameters, overwrite the config_path argument if provided [default: {}] +* `--cell-key TEXT`: Optional column of the transcripts dataframe that indicates in which cell-id each transcript is, in order to use prior segmentation. Default is cell if cell_key=None * `--unassigned-value INTEGER`: If --cell-key is provided, this is the value given to transcripts that are not inside any cell (if it's already 0, don't provide this argument) * `--help`: Show this message and exit. @@ -483,6 +483,7 @@ $ sopa resolve [OPTIONS] COMMAND [ARGS]... * `baysor`: Resolve patches conflicts after baysor... * `cellpose`: Resolve patches conflicts after cellpose... +* `comseg`: Resolve patches conflicts after comseg... * `generic`: Resolve patches conflicts after generic... #### `sopa resolve baysor` @@ -528,7 +529,7 @@ $ sopa resolve cellpose [OPTIONS] SDATA_PATH #### `sopa resolve comseg` -Resolve patches conflicts after comseg segmentation. Provide either `--baysor-temp-dir` or `--patches-dirs` +Resolve patches conflicts after comseg segmentation. Provide either `--comseg-temp-dir` or `--patches-dirs` **Usage**: @@ -585,7 +586,7 @@ $ sopa segmentation [OPTIONS] COMMAND [ARGS]... **Commands**: * `cellpose`: Perform cellpose segmentation. -* `comseg`: Perform ComSeg segmentation. +* `comseg`: Perform ComSeg segmentation. * `generic-staining`: Perform generic staining-based segmentation. #### `sopa segmentation cellpose` @@ -628,12 +629,6 @@ $ sopa segmentation cellpose [OPTIONS] SDATA_PATH Perform ComSeg segmentation. This can be done on all patches directly, or on one individual patch. -!!! note "Usage" - - - [On one patch] Use this mode to run patches in parallel. Provide `--patch-index` to run one patch, and execute all patches in a parallel manner (you need to define your own parallelization, else, use the Snakemake pipeline). - - - [On all patches at once] For small images, you can run the segmentation method sequentially (`--patch-index` is not needed) - **Usage**: ```console @@ -646,8 +641,9 @@ $ sopa segmentation comseg [OPTIONS] SDATA_PATH **Options**: -* `--patch-dir TEXT`: Path to the temporary comseg directory inside which we will store each individual patch segmentation. By default, saves into the `.sopa_cache/comseg_boundaries` directory -* `--patch-index INTEGER`: Index of the patch on which cellpose should be run. NB: the number of patches is `len(sdata['sopa_patches'])` +* `--patch-index INTEGER`: Index of the patch on which the segmentation method should be run.` +* `--patch-dir TEXT`: Path to the temporary the segmentation method directory inside which we will store each individual patch segmentation. By default, saves into the `.sopa_cache/comseg` directory +* `--help`: Show this message and exit. #### `sopa segmentation generic-staining` diff --git a/docs/tutorials/other_segmentations.ipynb b/docs/tutorials/comseg.ipynb similarity index 91% rename from docs/tutorials/other_segmentations.ipynb rename to docs/tutorials/comseg.ipynb index 3dfbcf91..762df534 100644 --- a/docs/tutorials/other_segmentations.ipynb +++ b/docs/tutorials/comseg.ipynb @@ -1,5 +1,39 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ComSeg segmentation\n", + "\n", + "[ComSeg](https://github.com/fish-quant/ComSeg) is a transcript-based segmentation method that creates a KNN graph of RNA molecules, weighted by the co-expression of RNA species. Initially, this KNN graph is partitioned into communities of RNAs likely to belong to the same cell. ComSeg then merges these RNA communities to compute the final cell segmentation. The method uses nucleus segmentation as prior to initialize the partitioning of the KNN graph of RNA molecules. \n", + "ComSeg only segments cells with their nuclei segmented and does not take into account cells withou missing nucleus. \n", + "\n", + "If nucleus segmentation is not available, ComSeg can operate using other staining segmentation or solely nucleus centroids obtained from other sources. For more details, please refer to the [documentation](https://comseg.readthedocs.io/en/latest/).\n", + "\n", + "## Requirements\n", + "\n", + "To use ComSeg, you'll need to run `pip install comseg alphashape` in your environment.\n", + "Then, choose one the the three use cases (i.e., Snakemake or CLI or API) below.\n", + "\n", + "## Snakemake usage\n", + "\n", + "TODO\n", + "\n", + "## CLI usage\n", + "\n", + "TODO" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## API usage\n", + "\n", + "In this tutorial, we first compute the nucleus segmentation prior using Cellpose on the DAPI staining\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -31,18 +65,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# ComSeg segmentation\n", - "\n", - "[ComSeg](https://github.com/fish-quant/ComSeg) is a transcript-based segmentation method that creates a KNN graph of RNA molecules, weighted by the co-expression of RNA species. Initially, this KNN graph is partitioned into communities of RNAs likely to belong to the same cell. ComSeg then merges these RNA communities to compute the final cell segmentation. The method uses nucleus segmentation as prior to initialize the partitioning of the KNN graph of RNA molecules. \n", - "ComSeg only segments cells with their nuclei segmented and does not take into account cells withou missing nucleus. \n", - "\n", - "If nucleus segmentation is not available, ComSeg can operate using other staining segmentation or solely nucleus centroids obtained from other sources. For more details, please refer to the [documentation](https://comseg.readthedocs.io/en/latest/)\n", - "\n", - "In this tutorial, we first compute the nucleus segmentation prior using Cellpose on the DAPI staining\n", + "### 1. Running Cellpose as a prior\n", "\n", - "## 1. Running Cellpose as a prior\n", - "\n", - "First, we generate the bounding boxes of the patches on which Cellpose will be run. Here, the patches have a width and height of 1500 pixels and an overlap of 50 pixels. We advise bigger sizes for real datasets (see our default parameters in one of our config files). On the toy dataset, this will generate 4 patches.\n" + "First, we generate the bounding boxes of the patches on which Cellpose will be run. Here, the patches have a width and height of 1500 pixels and an overlap of 50 pixels. We advise bigger sizes for real datasets (see our default parameters in one of our config files). On the toy dataset, this will generate 4 patches." ] }, { @@ -100,7 +125,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 2. Generating Patches for ComSeg\n", + "### 2. Generating Patches for ComSeg\n", "\n", "Once the nuclei are segmented, we generate the bounding boxes of the patches on which ComSeg will be run. ComSeg also requires the nuclei centroids from the Cellpose segmentation, which are computed using the ```patchify_centroids()```. In this example, the patches have a width and height of 200 microns with an overlap of 50 microns. For real datasets, we recommend using larger patch sizes, up to 8000 microns, depending on cell density. On the toy dataset, this configuration will generate 4 patches.\n", "\n", @@ -149,7 +174,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 3. Running ComSeg on each patch\n", + "### 3. Running ComSeg on each patch\n", "\n", "Parameters for ComSeg can be gathered into a single configuration dictionary. Below is a simple configuration example for using ComSeg. For a more comprehensive description of the configuration dictionary, please refer to the [documentation](https://comseg.readthedocs.io/en/latest/userguide/Minimal_example.html#Comprensive-description-of-configuration-dictionnary)\n", "\n", @@ -158,345 +183,11 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\r", - " 0%| | 0/1 [00:00 Date: Tue, 2 Jul 2024 14:55:37 +0200 Subject: [PATCH 22/27] modif for xenium --- sopa/cli/patchify.py | 33 ++++++++++++++++++++++++++++----- sopa/patches/patches.py | 12 +++++++++--- sopa/segmentation/methods.py | 3 ++- 3 files changed, 39 insertions(+), 9 deletions(-) diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index 2885672e..a521c5f5 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -123,6 +123,14 @@ def comseg( None, help="If --cell-key is provided, this is the value given to transcripts that are not inside any cell (if it's already 0, don't provide this argument)", ), + min_transcripts_per_patch: int = typer.Option( + 1000, help="Minimum number of transcripts per patch" + ), + min_cells_per_patch: int = typer.Option(1, help="Minimum number of cells per patch"), + shapes_key: str = typer.Option( + SopaKeys.CELLPOSE_BOUNDARIES, + help="Name of the nuclei boundaries shape use for the prior and centroid in the sdata object", + ), ): """Prepare patches for transcript-based segmentation with ComSeg""" @@ -145,6 +153,9 @@ def comseg( cell_key=cell_key, unassigned_value=unassigned_value, use_prior=True, + min_transcripts_per_patch=min_transcripts_per_patch, + min_cells_per_patch=min_cells_per_patch, + shapes_key=shapes_key, ) @@ -160,6 +171,9 @@ def _transcript_segmentation( cell_key: str, use_prior: bool, unassigned_value: int, + min_transcripts_per_patch: int, + min_cells_per_patch: int, + shapes_key: str = SopaKeys.CELLPOSE_BOUNDARIES, ): """Prepare patches for transcript-based segmentation for the different available methods (baysor, comseg) args: @@ -191,11 +205,6 @@ def _transcript_segmentation( df_key = get_key(sdata, "points") patches = Patches2D(sdata, df_key, patch_width_microns, patch_overlap_microns) - if filename == SopaFiles.PATCHES_DIRS_COMSEG: - patches.patchify_centroids(temp_dir) - assert ( - use_prior - ), "For ComSeg, you must use the prior segmentation of nuclei or from other staining" valid_indices = patches.patchify_transcripts( temp_dir, cell_key, @@ -204,7 +213,21 @@ def _transcript_segmentation( config, config_path, config_name=config_name, + min_transcripts_per_patch=min_transcripts_per_patch, + shapes_key=shapes_key, ) + + if filename == SopaFiles.PATCHES_DIRS_COMSEG: + assert ( + use_prior + ), "For ComSeg, you must use the prior segmentation of nuclei or from other staining" + valid_indices_centoid = patches.patchify_centroids( + temp_dir, + shapes_key=shapes_key, + min_cells_per_patch=min_cells_per_patch, + ) + valid_indices = list(set(valid_indices_centoid).intersection(set(valid_indices))) + _save_cache(sdata_path, filename, "\n".join(map(str, valid_indices))) diff --git a/sopa/patches/patches.py b/sopa/patches/patches.py index 19b49bab..506bc739 100644 --- a/sopa/patches/patches.py +++ b/sopa/patches/patches.py @@ -228,6 +228,7 @@ def patchify_transcripts( config_name: str = SopaFiles.TOML_CONFIG_FILE, csv_name: str = SopaFiles.TRANSCRIPTS_FILE, min_transcripts_per_patch: int = 4000, + shapes_key: str = SopaKeys.CELLPOSE_BOUNDARIES, ) -> list[int]: """Patchification of the transcripts @@ -247,7 +248,7 @@ def patchify_transcripts( """ return TranscriptPatches( self, self.element, config_name, csv_name, min_transcripts_per_patch - ).write(temp_dir, cell_key, unassigned_value, use_prior, config, config_path) + ).write(temp_dir, cell_key, unassigned_value, use_prior, config, config_path, shapes_key) def patchify_centroids( self, @@ -265,7 +266,9 @@ def patchify_centroids( centroids["y"] = centroids.geometry.y centroids["z"] = 0 - TranscriptPatches(self, centroids, None, csv_name, min_cells_per_patch).write(temp_dir) + return TranscriptPatches(self, centroids, None, csv_name, min_cells_per_patch).write( + temp_dir, shapes_key=shapes_key + ) class TranscriptPatches: @@ -293,6 +296,7 @@ def write( use_prior: bool = False, config: dict = {}, config_path: str | None = None, + shapes_key: str = SopaKeys.CELLPOSE_BOUNDARIES, ): from sopa.segmentation.transcripts import copy_segmentation_config @@ -307,7 +311,7 @@ def write( self.df[cell_key] = self.df[cell_key].replace(unassigned_value, 0) if use_prior: - prior_boundaries = self.sdata[SopaKeys.CELLPOSE_BOUNDARIES] + prior_boundaries = self.sdata[shapes_key] _map_transcript_to_cell(self.sdata, cell_key, self.df, prior_boundaries) self._setup_patches_directory() @@ -369,6 +373,8 @@ def _write_points(self, patches_gdf: gpd.GeoDataFrame, points_gdf: gpd.GeoDataFr def _check_min_lines(path: str, n: int) -> bool: + if not Path(path).exists(): # empty file are not written at all + return False with open(path, "r") as f: for count, _ in enumerate(f): if count + 1 >= n: diff --git a/sopa/segmentation/methods.py b/sopa/segmentation/methods.py index ceb5b4e4..bfbf11fb 100644 --- a/sopa/segmentation/methods.py +++ b/sopa/segmentation/methods.py @@ -101,6 +101,7 @@ def comseg_patch(temp_dir: str, patch_index: int, config: dict): image_csv_files=["transcripts.csv"], centroid_csv_files=["centroids.csv"], path_cell_centroid=path_dataset_folder, + min_nb_rna_patch=config.get("min_nb_rna_patch", 0), ) dataset.compute_edge_weight(config=config) @@ -108,7 +109,7 @@ def comseg_patch(temp_dir: str, patch_index: int, config: dict): Comsegdict = dictionary.ComSegDict( dataset=dataset, mean_cell_diameter=config["mean_cell_diameter"], - prior_name=SopaKeys.DEFAULT_CELL_KEY, + prior_name=config.get("prior_name", SopaKeys.DEFAULT_CELL_KEY), ) Comsegdict.run_all(config=config) From 116b6d16a6798afb0f8bea1a2b2f26146f8d4606 Mon Sep 17 00:00:00 2001 From: tdefa Date: Wed, 3 Jul 2024 20:26:26 +0200 Subject: [PATCH 23/27] tuto --- docs/tutorials/comseg.ipynb | 158 +++++++++++++++++------------------- 1 file changed, 74 insertions(+), 84 deletions(-) diff --git a/docs/tutorials/comseg.ipynb b/docs/tutorials/comseg.ipynb index 1c80ba18..08ffb1d0 100644 --- a/docs/tutorials/comseg.ipynb +++ b/docs/tutorials/comseg.ipynb @@ -13,18 +13,23 @@ "\n", "## Requirements\n", "\n", - "To use ComSeg, you'll need to run `pip install comseg ` in your environment.\n", + "To use ComSeg, run pip install comseg in your environment. ComSeg optionally uses sctransform normalization. If you want to use sctransform, execute the following commands in your R console:\n", + "```\n", + "install.packages(\"sctransform\")\n", + "install.packages(\"feather\")\n", + "install.packages(\"arrow\")\n", + "```\n", "Then, choose one the the three use cases (i.e., Snakemake or CLI or API) below.\n", "\n", "## Snakemake usage\n", - "Runing ComSeg with snakemake is similar way than for other methods. Example of configuration can be found in the config folder.\n", + "You can run ComSeg with snakemake in a similar way than other methods. Example of configuration can be found in the config folder.\n", "\n", "```snakemake --config data_path=/path/to/directory --configfile=config/xenium/comseg.yaml --cores 1 --use-conda```\n" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -54,23 +59,25 @@ "\n", "\n", "#### 1) Save a ComSeg config file as config.jsons\n", - "More information on the parameters can be found in the [ComSeg documentation](https://comseg.readthedocs.io/en/latest/userguide/Minimal_example.html).\n", - "Below we display a minimal example of a ComSeg config file.\n", + "\n", + "Below we display a minimal example of a ComSeg config.jsons\n", "\n", "```json\n", "{\"dict_scale\": {\"x\": 1, \"y\": 1, \"z\": 1},\n", "\"mean_cell_diameter\": 15,\n", - "\"max_cell_radius\": 50,\n", + "\"max_cell_radius\": 20,\n", "\"alpha\": 0.5,\n", "\"min_rna_per_cell\": 5,\n", + "\"norm_vector\": true,\n", "\"gene_column\": \"genes\"}\n", "```\n", "\n", + "\n", + "If you did not install the needed external R packages, set ```\"norm_vector\": false```. More information on the parameters can be found in the [ComSeg documentation](https://comseg.readthedocs.io/en/latest/userguide/Minimal_example.html).\n", "#### 2) create the ComSeg patches\n", "On the toy dataset, we will generate 4 patches.\n", "```\n", - "sopa patchify comseg tuto.zarr --config-path config.json --patch-width-microns 200 --patch-overlap-microns 50 \\\n", - "--min-transcripts-per-patch 100 --min-cells-per-patch 1 --shapes-key cellpose_boundaries\n", + "sopa patchify comseg tuto.zarr --config-path config.json --patch-width-microns 200 --patch-overlap-microns 50 --min-transcripts-per-patch 100 --min-cells-per-patch 1 --shapes-key cellpose_boundaries\n", "```\n", "The shapes-key argument is the name of the nuclei boundaries shape in the sdata object that will be used for the prior and centroid. In this example, it is set to cellpose_boundaries, which assumes that the Cellpose segmentation has already been run.\n", "\n", @@ -107,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -131,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -141,16 +148,14 @@ "\u001b[36;20m[INFO] (sopa.utils.data)\u001b[0m Image of size ((4, 2048, 2048)) with 400 cells and 100 transcripts per cell\n", "\u001b[36;20m[INFO] (sopa.patches.patches)\u001b[0m 4 patches were saved in sdata['sopa_patches']\n", "\u001b[33;20m[WARNING] (sopa.segmentation.stainings)\u001b[0m Running segmentation in a sequential manner. This is not recommended on large images because it can be extremely slow (see https://github.com/gustaveroussy/sopa/discussions/36 for more details)\n", - "Run all patches: 0%| | 0/4 [00:00 Date: Wed, 3 Jul 2024 20:31:36 +0200 Subject: [PATCH 24/27] tuto2 --- docs/tutorials/comseg.ipynb | 41 +++++++++++++++---------------------- 1 file changed, 16 insertions(+), 25 deletions(-) diff --git a/docs/tutorials/comseg.ipynb b/docs/tutorials/comseg.ipynb index 08ffb1d0..fd61719c 100644 --- a/docs/tutorials/comseg.ipynb +++ b/docs/tutorials/comseg.ipynb @@ -619,7 +619,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -627,8 +627,8 @@ "output_type": "stream", "text": [ "\u001b[36;20m[INFO] (sopa.segmentation.transcripts)\u001b[0m Cells whose area is less than 10 microns^2 will be removed\n", - "Reading transcript-segmentation outputs: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 20.98it/s]\n", - "Resolving conflicts: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 532/532 [00:00<00:00, 3425.63it/s]\n", + "Reading transcript-segmentation outputs: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 6.98it/s]\n", + "Resolving conflicts: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 528/528 [00:00<00:00, 3359.08it/s]\n", "\u001b[36;20m[INFO] (sopa.segmentation.transcripts)\u001b[0m Aggregating transcripts on merged cells\n", "\u001b[36;20m[INFO] (sopa.segmentation.aggregate)\u001b[0m Aggregating transcripts over 155 cells\n" ] @@ -637,7 +637,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[########################################] | 100% Completed | 473.62 ms\n" + "[########################################] | 100% Completed | 104.93 ms\n" ] }, { @@ -654,17 +654,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[########################################] | 100% Completed | 101.27 ms\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/tom/anaconda3/envs/sopa/lib/python3.10/site-packages/spatialdata/_core/_elements.py:92: UserWarning: Key `comseg_boundaries` already exists. Overwriting it.\n", - " self._check_key(key, self.keys(), self._shared_keys)\n", - "/home/tom/anaconda3/envs/sopa/lib/python3.10/site-packages/spatialdata/_core/_elements.py:112: UserWarning: Key `table` already exists. Overwriting it.\n", - " self._check_key(key, self.keys(), self._shared_keys)\n" + "[########################################] | 100% Completed | 101.75 ms\n" ] } ], @@ -686,7 +676,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -695,7 +685,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -709,18 +699,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/tom/anaconda3/envs/sopa/lib/python3.10/site-packages/anndata/_core/aligned_df.py:67: ImplicitModificationWarning: Transforming to str index.\n", - " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n", - "/home/tom/anaconda3/envs/sopa/lib/python3.10/site-packages/spatialdata/_core/_elements.py:102: UserWarning: Key `transcripts` already exists. Overwriting it.\n", - " self._check_key(key, self.keys(), self._shared_keys)\n", - "/home/tom/anaconda3/envs/sopa/lib/python3.10/site-packages/spatialdata_plot/pl/render.py:327: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'norm' will be ignored\n", - " _cax = ax.scatter(\n", "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -746,7 +730,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -775,6 +759,13 @@ "source": [ "sopa.io.write(\"tuto.explorer\", sdata, image_key, points_key=\"transcripts\", gene_column=gene_column, shapes_key=\"comseg_boundaries\")" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From e50714eb73a595e5b57728747599ae8e4cc7ef70 Mon Sep 17 00:00:00 2001 From: tdefa Date: Wed, 3 Jul 2024 20:44:37 +0200 Subject: [PATCH 25/27] config --- workflow/config/xenium/comseg.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/workflow/config/xenium/comseg.yaml b/workflow/config/xenium/comseg.yaml index 967ba514..579e4ff0 100644 --- a/workflow/config/xenium/comseg.yaml +++ b/workflow/config/xenium/comseg.yaml @@ -26,6 +26,7 @@ segmentation: min_rna_per_cell: 10 gene_column: "feature_name" allow_disconnected_polygon : true + norm_vector: true # [optional] requires exeternal R package '"sctransform"' "feather" and "arrow" to be installed, otherwise set to false aggregate: From c973a916e78ff272478fc7395a8ce0eeeda4ffc9 Mon Sep 17 00:00:00 2001 From: tdefa Date: Wed, 3 Jul 2024 20:45:44 +0200 Subject: [PATCH 26/27] tuto_typo --- docs/tutorials/comseg.ipynb | 26 +------------------------- 1 file changed, 1 insertion(+), 25 deletions(-) diff --git a/docs/tutorials/comseg.ipynb b/docs/tutorials/comseg.ipynb index fd61719c..ee095519 100644 --- a/docs/tutorials/comseg.ipynb +++ b/docs/tutorials/comseg.ipynb @@ -27,30 +27,6 @@ "```snakemake --config data_path=/path/to/directory --configfile=config/xenium/comseg.yaml --cores 1 --use-conda```\n" ] }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "sys.path = ['/home/tom/.local/share/JetBrains/Toolbox/apps/pycharm-professional/plugins/python/helpers/pydev',\n", - " '/home/tom/.local/share/JetBrains/Toolbox/apps/pycharm-professional/plugins/python/helpers/third_party/thriftpy',\n", - " '/home/tom/.local/share/JetBrains/Toolbox/apps/pycharm-professional/plugins/python/helpers/pydev',\n", - " '/home/tom/.local/share/JetBrains/Toolbox/apps/pycharm-professional/plugins/python/helpers/pycharm_display',\n", - " '/home/tom/anaconda3/envs/sopa/lib/python310.zip',\n", - " '/home/tom/anaconda3/envs/sopa/lib/python3.10',\n", - " '/home/tom/anaconda3/envs/sopa/lib/python3.10/lib-dynload',\n", - " '',\n", - " '/home/tom/anaconda3/envs/sopa/lib/python3.10/site-packages',\n", - " '/home/tom/Bureau/phd/test_sopa/sopa',\n", - " '/home/tom/Bureau/phd/st_seg/CNN_gene',\n", - " '/home/tom/Bureau/phd/simulation/ComSeg_pkg/src',\n", - " '/home/tom/.local/share/JetBrains/Toolbox/apps/pycharm-professional/plugins/python/helpers/pycharm_matplotlib_backend',\n", - " '/home/tom/Bureau/phd/test_sopa',\n", - " '/home/tom/Bureau/phd/test_sopa/sopa']" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -596,7 +572,7 @@ " \"dict_scale\" : {\"x\": 1, 'y': 1, \"z\": 1}, # spot coordinates already in µm\n", " \"mean_cell_diameter\" : 15,\n", " \"max_cell_radius\": 25,\n", - " \"norm_vector\": False,\n", + " \"norm_vector\": True,\n", " \"alpha\" : 0.5, ## alpha value to compute the polygon https://pypi.org/project/alphashape/\n", " \"allow_disconnected_polygon\" : False,\n", " \"min_rna_per_cell\" : 5, ## minimal number of RNAs for a cell to be taken into account \n", From de96d004a374ae14bb513801554922545b337c04 Mon Sep 17 00:00:00 2001 From: tdefa Date: Thu, 4 Jul 2024 13:00:13 +0200 Subject: [PATCH 27/27] norm vector false --- docs/tutorials/comseg.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/tutorials/comseg.ipynb b/docs/tutorials/comseg.ipynb index ee095519..c6da6514 100644 --- a/docs/tutorials/comseg.ipynb +++ b/docs/tutorials/comseg.ipynb @@ -44,7 +44,7 @@ "\"max_cell_radius\": 20,\n", "\"alpha\": 0.5,\n", "\"min_rna_per_cell\": 5,\n", - "\"norm_vector\": true,\n", + "\"norm_vector\": false,\n", "\"gene_column\": \"genes\"}\n", "```\n", "\n", @@ -572,7 +572,7 @@ " \"dict_scale\" : {\"x\": 1, 'y': 1, \"z\": 1}, # spot coordinates already in µm\n", " \"mean_cell_diameter\" : 15,\n", " \"max_cell_radius\": 25,\n", - " \"norm_vector\": True,\n", + " \"norm_vector\": False,\n", " \"alpha\" : 0.5, ## alpha value to compute the polygon https://pypi.org/project/alphashape/\n", " \"allow_disconnected_polygon\" : False,\n", " \"min_rna_per_cell\" : 5, ## minimal number of RNAs for a cell to be taken into account \n",