diff --git a/conf.py b/conf.py index c0e43e9..0cd1f1e 100644 --- a/conf.py +++ b/conf.py @@ -107,6 +107,8 @@ "notebooks/paper_reproducibility", "notebooks/examples/*.zarr" "references.md", "Readme.md", # hack cause git his acting up + "notebooks/developers_resources/storage_format/*.ipynb", + "notebooks/developers_resources/storage_format/Readme.md", ] # Ignore warnings. nitpicky = False # TODO: solve upstream. diff --git a/datasets/README.md b/datasets/README.md index 369cdc7..141cf6b 100644 --- a/datasets/README.md +++ b/datasets/README.md @@ -4,20 +4,21 @@ The example notebooks operate on a set of spatial omics datasets that can be dow Here you can find the dataset hosted in S3 object storage. -| Dataset | .zarr.zip | S3 (see note below!) | -| :-------------------------: | :----------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------: | -| cosmx_io | | | -| mcmicro_io | | | -| merfish | | | -| mibitof | | | -| steinbock_io | | | -| toy | | | -| visium | | | -| visium_io | | | -| visium_associated_xenium_io | | | -| xenium_rep1_io | | | -| xenium_rep2_io | | | +| Dataset | .zarr.zip | S3 (see note below!) | +| :----------------------------------------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------: | +| cosmx_io | | | +| mcmicro_io | | | +| merfish | | | +| mibitof | | | +| steinbock_io | | | +| toy | | | +| visium | | | +| visium_io | | | +| visium_associated_xenium_io | | | +| xenium_rep1_io | | | +| xenium_rep2_io | | | +| [additional resources for methods developers](https://github.com/scverse/spatialdata-notebooks/blob/main/notebooks/notebooks/developers_resources/storage_format/) | - | - | ## Note -Opening the above URLs in a web browser would not work, you need to treat the URLs as Zarr stores. For example if you append `.zgroup` to any of the URLs above you will be able to see that file. +Opening the above URLs in a web browser would not work, you need to treat the URLs as Zarr stores. For example if you append `/.zgroup` to any of the `.zarr` URLs above you will be able to see that file. diff --git a/notebooks/developers_resources/.gitignore b/notebooks/developers_resources/.gitignore new file mode 100644 index 0000000..d0e8fdb --- /dev/null +++ b/notebooks/developers_resources/.gitignore @@ -0,0 +1 @@ +!data/ diff --git a/notebooks/developers_resources/storage_format/.gitignore b/notebooks/developers_resources/storage_format/.gitignore new file mode 100644 index 0000000..647bfc7 --- /dev/null +++ b/notebooks/developers_resources/storage_format/.gitignore @@ -0,0 +1 @@ +!*.zarr diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md new file mode 100644 index 0000000..2db0581 --- /dev/null +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -0,0 +1,37 @@ +# Examples covering the whole storage specification + +This directory offers comprehensive resources for developers that want to interface their methods with the SpatialData format in a robust way. + +## Why this repository + +The file storage format adopted by SpatialData is built on top of the latest version of the well-documented [OME-NGFF specification](https://ngff.openmicroscopy.org/latest/index.html), but it also uses _some_ less-documented features of the OME-NGFF specification that are still [under review](https://github.com/ome/ngff/pulls?q=is%3Apr+is%3Aopen+sort%3Aupdated-desc), or experimental storage strategies that will be eventually discussed with the NGFF community. +This repository addresses the need for communicating the storage specification to other developers in a complete and robust way. + +## What this repository contains + +This directory contains notebooks that operate on lightweight datasets. + +- Each notebook covers a particular aspect of the storage specification and ~~all the~~ _the main (work in progress)_ edge cases of the specification are covered in at least one of the notebooks. +- All the notebooks are run every 24h (work in progress, automatic run temporarily disabled) against the `main` branch of the `spatialdata` repository. Each notebook creates a dataset, writes it to disk, reloads it in memory, rewrites it to disk to check for consistency, reloads it again in memory and plots it. +- The disk storage is committed to GitHub so that the output of each daily run is associated to a commit, the commit message is "autorun: storage format; spatialdata from ". Examples of commit messages are: + - `autorun: storage format; spatialdata from al29fak` + - `autorun: storage format; spatialdata from fa096da (v0.0.12)` +- The `.zarr` data produced by every run is available in the current directory, in the commit corresponding to the run. +- The data is also [uploaded to S3](https://refined-github-html-preview.kidonng.workers.dev/scverse/spatialdata-notebooks/raw/dev_notebooks/notebooks/developers_resources/storage_format/index.html), both as Zarr directories and as zipped files. + +## How to use this repository + +Practically, a third party tool (e.g. R reader, format converter, JavaScript data visualizer, etc.) that runs correctly on the lightweight datasets from this repository, should be guaranteed to run correctly on any SpatialData dataset. + +We recommend the following. + +- Implement your readers on the data from the latest run available (look for the latest commit with message `autorun: storage format; ...`). +- Set up an automated test (e.g. daily) that gets the latest converted data (you can use a `git pull` or download the data from S3) and runs your code on it. +- If your reader fails, you can inspect the corresponding commit in this repository to see what has changed in the storage specification; in particular, you may find useful to compare different commits using the GitHub compare function, accessible with the following syntax: https://github.com/scverse/spatialdata-notebooks/compare/267adb1..5847084 + +## Important technical notes + +- The most crucial part of the metadata is stored, for each spatial element, in the `.zattr` file. [Example](transformation_identity.zarr/images/blobs_image/.zattrs). +- The `zmetadata` in the root folder stores redundant information and is used for storage systems that do not support `ls` operations (e.g. S3). [Example](transformation_identity.zarr/zmetadata). +- Please keep in mind that the data that we generate daily are produced against the latest `main` and not the latest release. This means that in the event of a format change (which should anyway happen less and less frequently as the frameworks become more mature), this does not immediately translate into a bug for the user. In fact, the user will still be using the latest release version for a while, giving time to developers to update the tools before the users are affected. +- When the format will become more mature we will provide converters between previous versions of the format. Luckily, heavy data like images and labels are stable from NGFF v0.4, therefore the converters will mostly perform lightweight conversions of the metadata and relatively small conversions of the geometries. diff --git a/notebooks/developers_resources/storage_format/__template__.ipynb b/notebooks/developers_resources/storage_format/__template__.ipynb new file mode 100644 index 0000000..44bd797 --- /dev/null +++ b/notebooks/developers_resources/storage_format/__template__.ipynb @@ -0,0 +1,121 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7bf33a06-009a-487a-991b-715a28b1069b", + "metadata": {}, + "source": [ + "# Scope and description" + ] + }, + { + "cell_type": "markdown", + "id": "d96031b8-ee40-43ca-9001-011f4751d4c1", + "metadata": {}, + "source": [ + "\n", + "\n", + "Elements contained:\n", + "- \n", + "- \n", + "\n", + "Annotations contained:\n", + "- \n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "id": "5a4c6566-882a-48d4-a4cd-0777332a5a99", + "metadata": {}, + "source": [ + "# Prepare the data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "094509a1-86fb-4aa6-b920-11e34ed43e1c", + "metadata": {}, + "outputs": [], + "source": [ + "NAME = \"name_of_the_notebook\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "332c9c62-7451-4d8e-ba9e-13c12131c312", + "metadata": {}, + "outputs": [], + "source": [ + "import spatialdata as sd\n", + "import spatialdata_plot\n", + "from spatialdata.datasets import blobs\n", + "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "\n", + "delete_old_data(name=NAME)\n", + "sdata = \n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "800a540b-2906-46c9-8245-99def219692f", + "metadata": {}, + "source": [ + "# Read-write and IO validation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b6c01345-27de-42f3-af07-75a43e84808a", + "metadata": {}, + "outputs": [], + "source": [ + "write_sdata_and_check_consistency(sdata=sdata, name=NAME)" + ] + }, + { + "cell_type": "markdown", + "id": "06806f13-f346-410f-ab04-fdd61fd77a10", + "metadata": {}, + "source": [ + "# Plot the data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "af8d7108-8b7c-461e-871e-77d82de82af6", + "metadata": {}, + "outputs": [], + "source": [ + "" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/developers_resources/storage_format/index.html b/notebooks/developers_resources/storage_format/index.html new file mode 100644 index 0000000..1d4f176 --- /dev/null +++ b/notebooks/developers_resources/storage_format/index.html @@ -0,0 +1,108 @@ + + + Index + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ElementLinkZip
transformation_scale + transformation_scale.zarr + + transformation_scale.zarr.zip +
transformation_identity + transformation_identity.zarr + + transformation_identity.zarr.zip +
multiple_elements + multiple_elements.zarr + + multiple_elements.zarr.zip +
transformation_translation + transformation_translation.zarr + + transformation_translation.zarr.zip +
transformation_sequence + transformation_sequence.zarr + + transformation_sequence.zarr.zip +
transformation_affine + transformation_affine.zarr + + transformation_affine.zarr.zip +
+ Note: opening the above .zarr URLs in a web browser would not work, you + need to treat the URLs as Zarr stores. For example if you append + `/.zgroup` to any of the .zarr URLs above you will be able to see that + file. + + diff --git a/notebooks/developers_resources/storage_format/io_utils.py b/notebooks/developers_resources/storage_format/io_utils.py new file mode 100644 index 0000000..377e807 --- /dev/null +++ b/notebooks/developers_resources/storage_format/io_utils.py @@ -0,0 +1,112 @@ +import os +import shutil +import tempfile + +import spatialdata as sd +import zarr +from ome_zarr.io import parse_url +from spatialdata._io._utils import _are_directories_identical + + +def delete_old_data(name: str) -> None: + """ + Safely delete an old Zarr store, it if exists. + + Parameters + ---------- + name + The name of the file (without extension) to write to and read from. + """ + f1 = f"{name}.zarr" + if os.path.isdir(f1): + store = parse_url(f1, mode="w").store + _ = zarr.group(store=store, overwrite=True) + store.close() + os.remove(os.path.join(f1, ".zgroup")) + os.rmdir(f1) + + +def write_sdata_and_check_consistency(sdata: sd.SpatialData, name: str) -> None: + """ + Write SpatialData instance to file, reload it, and check for consistency. + + This function writes the input `sdata` to a file using the specified `name`.zarr. + The data is then reloaded from the file and written again, and the two outputs + folders are compared recursively and binary wise, to check for the consistency + of the read-write operations. + + Parameters + ---------- + sdata + The SpatialData instance to be written to a file. + name + The name of the file to write to and read from. + + Returns + ------- + None + + Examples + -------- + >>> sdata = sd.SpatialData() # assume SpatialData instance is created + >>> write_sdata_and_check_consistency(sdata, 'testfile') # will create testfile.zarr + """ + f1 = f"{name}.zarr" + assert not os.path.exists(f1) + sdata.write(f1) + + with tempfile.TemporaryDirectory() as tmpdir: + sdata2 = sd.read_zarr(f1) + f2 = os.path.join(tmpdir, f"{name}2.zarr") + sdata2.write(f2) + assert _are_directories_identical(f1, f2) + + shutil.make_archive(f1, "zip", f1) + + +def make_index_html(elements: list[str]) -> None: + """ + Make an index.html file which links to the data produced by the notebook and uploaded to S3. + + Parameters + ---------- + elements + name of the data from the notebooks, to be included in the index.html file + """ + # Define the beginning of the HTML string + html = """ + + + Index + + + + + + + + + """ + + BASE_URL = "https://s3.embl.de/spatialdata/developers_resources/storage_format/" + + # Populate the HTML string with table data + for element in elements: + html += f"\n" + + # Close the HTML string + html += """ +
ElementLinkZip
{element}{element}.zarr{element}.zarr.zip
+Note: opening the above .zarr URLs in a web browser would not work, you need to treat the URLs as Zarr stores. For example if you append `/.zgroup` to any of the .zarr URLs above you will be able to see that file. + + + """ + + # Write the HTML string to a file + with open("index.html", "w") as file: + file.write(html) + + +if __name__ == "__main__": + notebooks = [f.replace(".ipynb", "") for f in os.listdir() if f.endswith(".ipynb") and f != "__template__.ipynb"] + make_index_html(notebooks) diff --git a/notebooks/developers_resources/storage_format/multiple_elements.ipynb b/notebooks/developers_resources/storage_format/multiple_elements.ipynb new file mode 100644 index 0000000..d052fe5 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.ipynb @@ -0,0 +1,462 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7bf33a06-009a-487a-991b-715a28b1069b", + "metadata": {}, + "source": [ + "# Scope and description" + ] + }, + { + "cell_type": "markdown", + "id": "d96031b8-ee40-43ca-9001-011f4751d4c1", + "metadata": {}, + "source": [ + "The data created by this notebook is for testing an object containing multiple diverse spatial elements.\n", + "\n", + "Elements contained:\n", + "- 2D single-scale image (cyx);\n", + "- 2D multi-scale image (cyx);\n", + "- 2D single-scale labels (yx);\n", + "- 2D multi-scale labels (yx);\n", + "- 2D points;\n", + "- circles;\n", + "- polygons;\n", + "- multipolygons.\n", + "\n", + "Annotations contained:\n", + "- table annotating the 2D labels.\n", + "\n", + "Note, this object is not meant to contain everything, example of features that are not covered by this notebook are:\n", + "- multiple transformations (transformation here are all `Identity()`);\n", + "- 3D images, labels, points\n", + "- channel names for images\n", + "- table annotating multiple elements\n", + "- elements containing annotation columns" + ] + }, + { + "cell_type": "markdown", + "id": "5a4c6566-882a-48d4-a4cd-0777332a5a99", + "metadata": {}, + "source": [ + "# Prepare the data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6c3ef5f8-a334-4bb4-906c-db3d8e50e571", + "metadata": {}, + "outputs": [], + "source": [ + "NAME = \"multiple_elements\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b7f6b9fe-c7dd-4177-a533-941a42984ff4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/__init__.py:9: UserWarning: Geopandas was set to use PyGEOS, changing to shapely 2.0 with:\n", + "\n", + "\tgeopandas.options.use_pygeos = True\n", + "\n", + "If you intended to use PyGEOS, set the option to False.\n", + " _check_geopandas_using_shapely()\n", + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/_core/operations/aggregate.py:244: UserWarning: Converting `region_key: region` to categorical dtype.\n", + " table = TableModel.parse(table, region=shapes_name, region_key=region_key, instance_key=instance_key)\n" + ] + }, + { + "data": { + "text/plain": [ + "SpatialData object with:\n", + "├── Images\n", + "│ ├── 'blobs_image': SpatialImage[cyx] (3, 64, 64)\n", + "│ └── 'blobs_multiscale_image': MultiscaleSpatialImage[cyx] (3, 64, 64), (3, 32, 32), (3, 16, 16)\n", + "├── Labels\n", + "│ ├── 'blobs_labels': SpatialImage[yx] (64, 64)\n", + "│ └── 'blobs_multiscale_labels': MultiscaleSpatialImage[yx] (64, 64), (32, 32), (16, 16)\n", + "├── Points\n", + "│ └── 'blobs_points': DataFrame with shape: (, 4) (2D points)\n", + "├── Shapes\n", + "│ ├── 'blobs_circles': GeoDataFrame shape: (5, 2) (2D shapes)\n", + "│ ├── 'blobs_multipolygons': GeoDataFrame shape: (5, 1) (2D shapes)\n", + "│ └── 'blobs_polygons': GeoDataFrame shape: (5, 1) (2D shapes)\n", + "└── Table\n", + " └── AnnData object with n_obs × n_vars = 10 × 3\n", + " obs: 'instance_id', 'region'\n", + " uns: 'spatialdata_attrs': AnnData (10, 3)\n", + "with coordinate systems:\n", + "▸ 'global', with elements:\n", + " blobs_image (Images), blobs_multiscale_image (Images), blobs_labels (Labels), blobs_multiscale_labels (Labels), blobs_points (Points), blobs_circles (Shapes), blobs_multipolygons (Shapes), blobs_polygons (Shapes)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import spatialdata as sd\n", + "import spatialdata_plot\n", + "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "from spatialdata.datasets import blobs\n", + "\n", + "delete_old_data(name=NAME)\n", + "sdata = blobs(length=64)\n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "800a540b-2906-46c9-8245-99def219692f", + "metadata": {}, + "source": [ + "# Read-write and IO validation" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b2952c64-5502-4462-9be0-a32fdb61158c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "no parent found for : None\n", + "no parent found for : None\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from multiple_elements.zarr to \n", + " \u001b[35m/tmp/tmpbxulxg2m/\u001b[0m\u001b[95mmultiple_elements2.zarr\u001b[0m \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "no parent found for : None\n", + "no parent found for : None\n" + ] + } + ], + "source": [ + "write_sdata_and_check_consistency(sdata=sdata, name=NAME)" + ] + }, + { + "cell_type": "markdown", + "id": "06806f13-f346-410f-ab04-fdd61fd77a10", + "metadata": {}, + "source": [ + "# Plot the data" + ] + }, + { + "cell_type": "markdown", + "id": "176f3917-21c2-421c-bf16-3455fafd7500", + "metadata": {}, + "source": [ + "## Single scale images, single scale labels, points" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "621f1331-c83e-4635-b8a1-9a0f6011ba83", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/miniconda3/envs/ome/lib/python3.10/site-packages/anndata/_core/anndata.py:117: ImplicitModificationWarning: Transforming to str index.\n", + " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n", + "/Users/macbook/embl/projects/basel/spatialdata-plot/src/spatialdata_plot/pl/render.py:335: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'norm' will be ignored\n", + " _cax = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_images(\"blobs_image\").pl.render_labels(\"blobs_labels\").pl.render_points(\n", + " \"blobs_points\", na_color=\"w\"\n", + ").pl.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f5be69e1-94fb-43b3-9709-ab90f0d2629c", + "metadata": {}, + "source": [ + "## Lables annoted by the table (var)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a0afa793-0cca-42a3-9f0e-dabd8775a147", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
instance_idregion
33blobs_labels
44blobs_labels
55blobs_labels
88blobs_labels
1010blobs_labels
1111blobs_labels
1212blobs_labels
1313blobs_labels
1515blobs_labels
1616blobs_labels
\n", + "
" + ], + "text/plain": [ + " instance_id region\n", + "3 3 blobs_labels\n", + "4 4 blobs_labels\n", + "5 5 blobs_labels\n", + "8 8 blobs_labels\n", + "10 10 blobs_labels\n", + "11 11 blobs_labels\n", + "12 12 blobs_labels\n", + "13 13 blobs_labels\n", + "15 15 blobs_labels\n", + "16 16 blobs_labels" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sdata.table.obs" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0256ddc3-edb0-4293-b478-2bd16d20d6d6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['channel_0_sum', 'channel_1_sum', 'channel_2_sum'], dtype='object')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sdata.table.var_names" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a37e947b-f9b9-462a-af04-a8c23a3293d5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_labels(\"blobs_labels\", color=\"channel_0_sum\").pl.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0b3ff656-7198-43c2-a501-fc4dd6c6cdb8", + "metadata": {}, + "source": [ + "## Shapes: circles, polygons, multipolygons" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "75166a2b-00f5-4cca-9d63-108f93036dff", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_shapes(\"blobs_circles\", fill_alpha=0.5).pl.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2a14b388-ca41-4d98-8199-f18cec3473b9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_shapes(\"blobs_polygons\").pl.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a91e99b8-30e7-4b14-a010-b2e8ef8c255f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_shapes(\"blobs_multipolygons\").pl.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs new file mode 100644 index 0000000..dbec22e --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs @@ -0,0 +1,93 @@ +{ + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "identity" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray new file mode 100644 index 0000000..08f0a41 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray @@ -0,0 +1,25 @@ +{ + "chunks": [ + 3, + 64, + 64 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": ", 4) (2D points)\n", + "with coordinate systems:\n", + "▸ 'global', with elements:\n", + " blobs_image (Images), blobs_points (Points)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix = np.array([[1, 2, 3], [4, 5, 6], [0, 0, 1]])\n", + "affine = sd.transformations.Affine(matrix=matrix, input_axes=(\"x\", \"y\"), output_axes=(\"x\", \"y\"))\n", + "sd.transformations.set_transformation(\n", + " element=sdata[\"blobs_image\"], transformation=affine, to_coordinate_system=\"global\"\n", + ")\n", + "sd.transformations.set_transformation(\n", + " element=sdata[\"blobs_points\"], transformation=affine, to_coordinate_system=\"global\"\n", + ")\n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "800a540b-2906-46c9-8245-99def219692f", + "metadata": {}, + "source": [ + "# Read-write and IO validation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b6c01345-27de-42f3-af07-75a43e84808a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_affine.zarr to \n", + " \u001b[35m/tmp/tmpeizpy3sr/\u001b[0m\u001b[95mtransformation_affine2.zarr\u001b[0m \n" + ] + } + ], + "source": [ + "write_sdata_and_check_consistency(sdata=sdata, name=NAME)" + ] + }, + { + "cell_type": "markdown", + "id": "06806f13-f346-410f-ab04-fdd61fd77a10", + "metadata": {}, + "source": [ + "# Plot the data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "af8d7108-8b7c-461e-871e-77d82de82af6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/miniconda3/envs/ome/lib/python3.10/site-packages/anndata/_core/anndata.py:117: ImplicitModificationWarning: Transforming to str index.\n", + " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n", + "/Users/macbook/embl/projects/basel/spatialdata-plot/src/spatialdata_plot/pl/render.py:335: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'norm' will be ignored\n", + " _cax = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_images().pl.render_points(na_color=\"w\").pl.show()" + ] + }, + { + "attachments": { + "cf537745-91e4-4390-8c4b-30a9b5be17fc.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "b762fac6-00c0-4e19-86dd-b6dee89eea3e", + "metadata": {}, + "source": [ + "Note: the above plot is wrong ([issue](https://github.com/scverse/spatialdata-plot/issues/103)). The correct plot should be the following one, made with `napari_spatialdata`.\n", + "\n", + "![image.png](attachment:cf537745-91e4-4390-8c4b-30a9b5be17fc.png)" + ] + }, + { + "cell_type": "raw", + "id": "9c7e086c-dc08-454e-8a49-811dcedcfafe", + "metadata": {}, + "source": [ + "from napari_spatialdata import Interactive\n", + "\n", + "Interactive(sdata)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs new file mode 100644 index 0000000..e36d6d4 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs @@ -0,0 +1,113 @@ +{ + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "affine": [ + [ + 1.0, + 0.0, + 0.0, + 0.0 + ], + [ + 0.0, + 2.0, + 1.0, + 3.0 + ], + [ + 0.0, + 5.0, + 4.0, + 6.0 + ] + ], + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "affine" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray new file mode 100644 index 0000000..8e38e52 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray @@ -0,0 +1,25 @@ +{ + "chunks": [ + 3, + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": ", 4) (2D points)\n", + "with coordinate systems:\n", + "▸ 'global', with elements:\n", + " blobs_image (Images), blobs_points (Points)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import spatialdata as sd\n", + "import spatialdata_plot\n", + "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "from spatialdata.datasets import blobs\n", + "\n", + "delete_old_data(name=NAME)\n", + "sdata = blobs(length=32)\n", + "sdata = sd.SpatialData(images={\"blobs_image\": sdata[\"blobs_image\"]}, points={\"blobs_points\": sdata[\"blobs_points\"]})\n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "800a540b-2906-46c9-8245-99def219692f", + "metadata": {}, + "source": [ + "# Read-write and IO validation" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b6c01345-27de-42f3-af07-75a43e84808a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_identity.zarr to \n", + " \u001b[35m/tmp/tmp24405axm/\u001b[0m\u001b[95mtransformation_identity2.zarr\u001b[0m \n" + ] + } + ], + "source": [ + "write_sdata_and_check_consistency(sdata=sdata, name=NAME)" + ] + }, + { + "cell_type": "markdown", + "id": "06806f13-f346-410f-ab04-fdd61fd77a10", + "metadata": {}, + "source": [ + "# Plot the data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "af8d7108-8b7c-461e-871e-77d82de82af6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/miniconda3/envs/ome/lib/python3.10/site-packages/anndata/_core/anndata.py:117: ImplicitModificationWarning: Transforming to str index.\n", + " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n", + "/Users/macbook/embl/projects/basel/spatialdata-plot/src/spatialdata_plot/pl/render.py:335: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'norm' will be ignored\n", + " _cax = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_images().pl.render_points(na_color=\"w\").pl.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs new file mode 100644 index 0000000..dbec22e --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs @@ -0,0 +1,93 @@ +{ + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "identity" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray new file mode 100644 index 0000000..8e38e52 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray @@ -0,0 +1,25 @@ +{ + "chunks": [ + 3, + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "\n", + " (function() {\n", + " if (window.IPython === undefined) {\n", + " return\n", + " }\n", + " var msg = \"WARNING: it looks like you might have loaded \" +\n", + " \"jupyter_black in a non-lab notebook with \" +\n", + " \"`is_lab=True`. Please double check, and if \" +\n", + " \"loading with `%load_ext` please review the README!\"\n", + " console.log(msg)\n", + " alert(msg)\n", + " })()\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%load_ext jupyter_black" + ] + }, + { + "cell_type": "markdown", + "id": "7bf33a06-009a-487a-991b-715a28b1069b", + "metadata": {}, + "source": [ + "# Scope and description" + ] + }, + { + "cell_type": "markdown", + "id": "d96031b8-ee40-43ca-9001-011f4751d4c1", + "metadata": {}, + "source": [ + "A raster and a vector elements with a scale transformation (only translating the x) to a single coordinate system ('global').\n", + "\n", + "Elements contained:\n", + "- 2D image (cyx)\n", + "- 2D points" + ] + }, + { + "cell_type": "markdown", + "id": "5a4c6566-882a-48d4-a4cd-0777332a5a99", + "metadata": {}, + "source": [ + "# Prepare the data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "094509a1-86fb-4aa6-b920-11e34ed43e1c", + "metadata": {}, + "outputs": [], + "source": [ + "NAME = \"transformation_scale\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d5fa9f79-145c-47fe-943f-6c6b56ad4e1d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/__init__.py:9: UserWarning: Geopandas was set to use PyGEOS, changing to shapely 2.0 with:\n", + "\n", + "\tgeopandas.options.use_pygeos = True\n", + "\n", + "If you intended to use PyGEOS, set the option to False.\n", + " _check_geopandas_using_shapely()\n", + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/_core/operations/aggregate.py:244: UserWarning: Converting `region_key: region` to categorical dtype.\n", + " table = TableModel.parse(table, region=shapes_name, region_key=region_key, instance_key=instance_key)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import spatialdata as sd\n", + "import spatialdata_plot\n", + "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "from spatialdata.datasets import blobs\n", + "\n", + "delete_old_data(name=NAME)\n", + "sdata = blobs(length=32)\n", + "sdata = sd.SpatialData(images={\"blobs_image\": sdata[\"blobs_image\"]}, points={\"blobs_points\": sdata[\"blobs_points\"]})" + ] + }, + { + "cell_type": "markdown", + "id": "b8d31311-aaa2-4ea4-bdfa-7519f6bb1d1d", + "metadata": {}, + "source": [ + "Set the affine transformation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3d4f59a6-48b9-4444-8f7d-490237b9e469", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SpatialData object with:\n", + "├── Images\n", + "│ └── 'blobs_image': SpatialImage[cyx] (3, 32, 32)\n", + "└── Points\n", + " └── 'blobs_points': DataFrame with shape: (, 4) (2D points)\n", + "with coordinate systems:\n", + "▸ 'global', with elements:\n", + " blobs_image (Images), blobs_points (Points)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scale = sd.transformations.Scale(scale=[2.0], axes=(\"x\",))\n", + "sd.transformations.set_transformation(element=sdata[\"blobs_image\"], transformation=scale, to_coordinate_system=\"global\")\n", + "sd.transformations.set_transformation(\n", + " element=sdata[\"blobs_points\"], transformation=scale, to_coordinate_system=\"global\"\n", + ")\n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "800a540b-2906-46c9-8245-99def219692f", + "metadata": {}, + "source": [ + "# Read-write and IO validation" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b6c01345-27de-42f3-af07-75a43e84808a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_scale.zarr to \n", + " \u001b[35m/tmp/tmpg8fqz4nx/\u001b[0m\u001b[95mtransformation_scale2.zarr\u001b[0m \n" + ] + } + ], + "source": [ + "write_sdata_and_check_consistency(sdata=sdata, name=NAME)" + ] + }, + { + "cell_type": "markdown", + "id": "06806f13-f346-410f-ab04-fdd61fd77a10", + "metadata": {}, + "source": [ + "# Plot the data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3583c7fd-a779-4353-aade-834b0b6f62d2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/miniconda3/envs/ome/lib/python3.10/site-packages/anndata/_core/anndata.py:117: ImplicitModificationWarning: Transforming to str index.\n", + " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n", + "/Users/macbook/embl/projects/basel/spatialdata-plot/src/spatialdata_plot/pl/render.py:335: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'norm' will be ignored\n", + " _cax = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_images().pl.render_points(na_color=\"w\").pl.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs new file mode 100644 index 0000000..a7d80df --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs @@ -0,0 +1,98 @@ +{ + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "scale": [ + 1.0, + 1.0, + 2.0 + ], + "type": "scale" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray new file mode 100644 index 0000000..8e38e52 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray @@ -0,0 +1,25 @@ +{ + "chunks": [ + 3, + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "\n", + " (function() {\n", + " if (window.IPython === undefined) {\n", + " return\n", + " }\n", + " var msg = \"WARNING: it looks like you might have loaded \" +\n", + " \"jupyter_black in a non-lab notebook with \" +\n", + " \"`is_lab=True`. Please double check, and if \" +\n", + " \"loading with `%load_ext` please review the README!\"\n", + " console.log(msg)\n", + " alert(msg)\n", + " })()\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%load_ext jupyter_black" + ] + }, + { + "cell_type": "markdown", + "id": "7bf33a06-009a-487a-991b-715a28b1069b", + "metadata": {}, + "source": [ + "# Scope and description" + ] + }, + { + "cell_type": "markdown", + "id": "d96031b8-ee40-43ca-9001-011f4751d4c1", + "metadata": {}, + "source": [ + "A raster and a vector elements with a sequence transformation, combining a scale and a translation, and a single coordinate system ('global').\n", + "\n", + "Elements contained:\n", + "- 2D image (cyx)\n", + "- 2D points" + ] + }, + { + "cell_type": "markdown", + "id": "5a4c6566-882a-48d4-a4cd-0777332a5a99", + "metadata": {}, + "source": [ + "# Prepare the data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "094509a1-86fb-4aa6-b920-11e34ed43e1c", + "metadata": {}, + "outputs": [], + "source": [ + "NAME = \"transformation_sequence\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d5fa9f79-145c-47fe-943f-6c6b56ad4e1d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/__init__.py:9: UserWarning: Geopandas was set to use PyGEOS, changing to shapely 2.0 with:\n", + "\n", + "\tgeopandas.options.use_pygeos = True\n", + "\n", + "If you intended to use PyGEOS, set the option to False.\n", + " _check_geopandas_using_shapely()\n", + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/_core/operations/aggregate.py:244: UserWarning: Converting `region_key: region` to categorical dtype.\n", + " table = TableModel.parse(table, region=shapes_name, region_key=region_key, instance_key=instance_key)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import spatialdata as sd\n", + "import spatialdata_plot\n", + "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "from spatialdata.datasets import blobs\n", + "\n", + "delete_old_data(name=NAME)\n", + "sdata = blobs(length=32)\n", + "sdata = sd.SpatialData(images={\"blobs_image\": sdata[\"blobs_image\"]}, points={\"blobs_points\": sdata[\"blobs_points\"]})" + ] + }, + { + "cell_type": "markdown", + "id": "b8d31311-aaa2-4ea4-bdfa-7519f6bb1d1d", + "metadata": {}, + "source": [ + "Set the affine transformation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3d4f59a6-48b9-4444-8f7d-490237b9e469", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SpatialData object with:\n", + "├── Images\n", + "│ └── 'blobs_image': SpatialImage[cyx] (3, 32, 32)\n", + "└── Points\n", + " └── 'blobs_points': DataFrame with shape: (, 4) (2D points)\n", + "with coordinate systems:\n", + "▸ 'global', with elements:\n", + " blobs_image (Images), blobs_points (Points)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scale = sd.transformations.Scale(scale=[2.0, 0.5], axes=(\"x\", \"y\"))\n", + "translation = sd.transformations.Translation(translation=[10.0, 30.0], axes=(\"x\", \"y\"))\n", + "# translation is applied before scale\n", + "sequence = sd.transformations.Sequence([translation, scale])\n", + "sd.transformations.set_transformation(\n", + " element=sdata[\"blobs_image\"], transformation=sequence, to_coordinate_system=\"global\"\n", + ")\n", + "sd.transformations.set_transformation(\n", + " element=sdata[\"blobs_points\"], transformation=sequence, to_coordinate_system=\"global\"\n", + ")\n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "800a540b-2906-46c9-8245-99def219692f", + "metadata": {}, + "source": [ + "# Read-write and IO validation" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b6c01345-27de-42f3-af07-75a43e84808a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_sequence.zarr to \n", + " \u001b[35m/tmp/tmpcxxeb0fw/\u001b[0m\u001b[95mtransformation_sequence2.zarr\u001b[0m \n" + ] + } + ], + "source": [ + "write_sdata_and_check_consistency(sdata=sdata, name=NAME)" + ] + }, + { + "cell_type": "markdown", + "id": "06806f13-f346-410f-ab04-fdd61fd77a10", + "metadata": {}, + "source": [ + "# Plot the data" + ] + }, + { + "cell_type": "markdown", + "id": "27f9aa03-58a5-4ed6-ba16-8a352bc90125", + "metadata": {}, + "source": [ + "Doesn't work, tracked here: https://github.com/scverse/spatialdata-plot/issues/146.\n", + "\n", + "```python\n", + "sdata.pl.render_images().pl.render_points(na_color='w').pl.show()\n", + "```" + ] + }, + { + "cell_type": "raw", + "id": "e16b06da-714d-4a1d-b36b-275b1a15a475", + "metadata": {}, + "source": [ + "from napari_spatialdata import Interactive\n", + "\n", + "Interactive(sdata)" + ] + }, + { + "cell_type": "markdown", + "id": "f22ac27f-b649-4ab2-83c3-cdaeb168d10f", + "metadata": {}, + "source": [ + "Screenshot from napari, notice the padding due to the translation." + ] + }, + { + "attachments": { + "280fc662-7567-445a-8ecb-e3b652681e31.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "532c0fc5-39e3-48f7-9bd3-9e845020b246", + "metadata": {}, + "source": [ + "![image.png](attachment:280fc662-7567-445a-8ecb-e3b652681e31.png)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs new file mode 100644 index 0000000..ce42fb6 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs @@ -0,0 +1,187 @@ +{ + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "transformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "translation": [ + 0.0, + 30.0, + 10.0 + ], + "type": "translation" + }, + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "scale": [ + 1.0, + 0.5, + 2.0 + ], + "type": "scale" + } + ], + "type": "sequence" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray new file mode 100644 index 0000000..8e38e52 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray @@ -0,0 +1,25 @@ +{ + "chunks": [ + 3, + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "\n", + " (function() {\n", + " if (window.IPython === undefined) {\n", + " return\n", + " }\n", + " var msg = \"WARNING: it looks like you might have loaded \" +\n", + " \"jupyter_black in a non-lab notebook with \" +\n", + " \"`is_lab=True`. Please double check, and if \" +\n", + " \"loading with `%load_ext` please review the README!\"\n", + " console.log(msg)\n", + " alert(msg)\n", + " })()\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%load_ext jupyter_black" + ] + }, + { + "cell_type": "markdown", + "id": "7bf33a06-009a-487a-991b-715a28b1069b", + "metadata": {}, + "source": [ + "# Scope and description" + ] + }, + { + "cell_type": "markdown", + "id": "d96031b8-ee40-43ca-9001-011f4751d4c1", + "metadata": {}, + "source": [ + "A raster and a vector elements with a translation transformation (only translating the x) to a single coordinate system ('global').\n", + "\n", + "Elements contained:\n", + "- 2D image (cyx)\n", + "- 2D points" + ] + }, + { + "cell_type": "markdown", + "id": "5a4c6566-882a-48d4-a4cd-0777332a5a99", + "metadata": {}, + "source": [ + "# Prepare the data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "094509a1-86fb-4aa6-b920-11e34ed43e1c", + "metadata": {}, + "outputs": [], + "source": [ + "NAME = \"transformation_translation\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d5fa9f79-145c-47fe-943f-6c6b56ad4e1d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/__init__.py:9: UserWarning: Geopandas was set to use PyGEOS, changing to shapely 2.0 with:\n", + "\n", + "\tgeopandas.options.use_pygeos = True\n", + "\n", + "If you intended to use PyGEOS, set the option to False.\n", + " _check_geopandas_using_shapely()\n", + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/_core/operations/aggregate.py:244: UserWarning: Converting `region_key: region` to categorical dtype.\n", + " table = TableModel.parse(table, region=shapes_name, region_key=region_key, instance_key=instance_key)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import spatialdata as sd\n", + "import spatialdata_plot\n", + "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "from spatialdata.datasets import blobs\n", + "\n", + "delete_old_data(name=NAME)\n", + "sdata = blobs(length=32)\n", + "sdata = sd.SpatialData(images={\"blobs_image\": sdata[\"blobs_image\"]}, points={\"blobs_points\": sdata[\"blobs_points\"]})" + ] + }, + { + "cell_type": "markdown", + "id": "b8d31311-aaa2-4ea4-bdfa-7519f6bb1d1d", + "metadata": {}, + "source": [ + "Set the affine transformation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3d4f59a6-48b9-4444-8f7d-490237b9e469", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SpatialData object with:\n", + "├── Images\n", + "│ └── 'blobs_image': SpatialImage[cyx] (3, 32, 32)\n", + "└── Points\n", + " └── 'blobs_points': DataFrame with shape: (, 4) (2D points)\n", + "with coordinate systems:\n", + "▸ 'global', with elements:\n", + " blobs_image (Images), blobs_points (Points)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "translation = sd.transformations.Translation(translation=[100.0], axes=(\"x\",))\n", + "sd.transformations.set_transformation(\n", + " element=sdata[\"blobs_image\"], transformation=translation, to_coordinate_system=\"global\"\n", + ")\n", + "sd.transformations.set_transformation(\n", + " element=sdata[\"blobs_points\"], transformation=translation, to_coordinate_system=\"global\"\n", + ")\n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "800a540b-2906-46c9-8245-99def219692f", + "metadata": {}, + "source": [ + "# Read-write and IO validation" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b6c01345-27de-42f3-af07-75a43e84808a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_translation.zarr to \n", + " \u001b[35m/tmp/tmpg98e91v1/\u001b[0m\u001b[95mtransformation_translation2.zarr\u001b[0m \n" + ] + } + ], + "source": [ + "write_sdata_and_check_consistency(sdata=sdata, name=NAME)" + ] + }, + { + "cell_type": "markdown", + "id": "06806f13-f346-410f-ab04-fdd61fd77a10", + "metadata": {}, + "source": [ + "# Plot the data" + ] + }, + { + "cell_type": "markdown", + "id": "8b10912d-06de-4808-aa7c-970e2456bd22", + "metadata": {}, + "source": [ + "Doesn't work, tracked here: https://github.com/scverse/spatialdata-plot/issues/146.\n", + "\n", + "```python\n", + "sdata.pl.render_images().pl.render_points(na_color='w').pl.show()\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "b762fac6-00c0-4e19-86dd-b6dee89eea3e", + "metadata": {}, + "source": [ + "Screenshot from `napari_spatialdata`, notice the padding on the left, due to the translation." + ] + }, + { + "cell_type": "raw", + "id": "a9aa76ac-91f2-46fb-be8d-648deb9b455c", + "metadata": {}, + "source": [ + "from napari_spatialdata import Interactive\n", + "\n", + "Interactive(sdata)" + ] + }, + { + "attachments": { + "bc71728c-cc98-4d24-88fd-cdbcf95d7553.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "c4f67c64-1923-4f1e-9b46-bf5cafd5355d", + "metadata": {}, + "source": [ + "![image.png](attachment:bc71728c-cc98-4d24-88fd-cdbcf95d7553.png)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zattrs new file mode 100644 index 0000000..ff754fc --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zattrs @@ -0,0 +1,98 @@ +{ + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "translation": [ + 0.0, + 0.0, + 100.0 + ], + "type": "translation" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zgroup new file mode 100644 index 0000000..3f3fad2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/0/.zarray new file mode 100644 index 0000000..8e38e52 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/0/.zarray @@ -0,0 +1,25 @@ +{ + "chunks": [ + 3, + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "