spatialdata-io 0.5.0__tar.gz → 0.6.0__tar.gz

{spatialdata_io-0.5.0 → spatialdata_io-0.6.0}/.github/workflows/prepare_test_data.yaml

@@ -4,7 +4,8 @@ on:
     schedule:
         - cron: "0 0 1 * *" # run once a month to prevent artifact expiration
     workflow_dispatch:
-# uncomment and adjust the branch name if you need to add new datasets to the artifact
+    # Uncomment and adjust the branch name if you need to add new datasets to the artifact.
+    # It needs to be a branch in the spatialdata-io origin repository, not from a fork.
 #    push:
 #        branches:
 #            - main
@@ -57,6 +58,14 @@ jobs:
                   # Spatial Genomics seqFISH v2
                   curl -O https://s3.embl.de/spatialdata/raw_data/seqfish-2-test-dataset.zip
 
+                  # -------
+                  # MACSima OMAP datasets are licensed as CC BY 4.0
+                  # OMAP23 for format v1.x.x
+                  curl -o OMAP23_small.zip "https://zenodo.org/api/records/18196452/files-archive"
+
+                  # OMAP10 for format v0.x.x
+                  curl -o OMAP10_small.zip "https://zenodo.org/api/records/18196366/files-archive"
+
             - name: Unzip files
               run: |
                   cd ./data

{spatialdata_io-0.5.0 → spatialdata_io-0.6.0}/.gitignore

@@ -6,6 +6,7 @@ temp/
 
 # Compiled files
 __pycache__/
+.ipynb_checkpoints/
 
 # Distribution / packaging
 /build/
@@ -41,3 +42,5 @@ data
 # data folder
 data/
 tests/data
+uv.lock
+.asv/

{spatialdata_io-0.5.0 → spatialdata_io-0.6.0}/.pre-commit-config.yaml

@@ -7,17 +7,17 @@ default_stages:
 minimum_pre_commit_version: 2.16.0
 repos:
     - repo: https://github.com/rbubley/mirrors-prettier
-      rev: v3.6.2
+      rev: v3.7.4
       hooks:
           - id: prettier
     - repo: https://github.com/astral-sh/ruff-pre-commit
-      rev: v0.14.1
+      rev: v0.14.11
       hooks:
           - id: ruff
             args: [--fix, --exit-non-zero-on-fix, --unsafe-fixes]
           - id: ruff-format
     - repo: https://github.com/pre-commit/mirrors-mypy
-      rev: v1.18.2
+      rev: v1.19.1
       hooks:
           - id: mypy
             additional_dependencies: [numpy, types-PyYAML]

{spatialdata_io-0.5.0 → spatialdata_io-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spatialdata-io
-Version: 0.5.0
+Version: 0.6.0
 Summary: SpatialData IO for common techs
 Project-URL: Documentation, https://spatialdata-io.readthedocs.io/
 Project-URL: Source, https://github.com/scverse/spatialdata-io
@@ -52,6 +52,7 @@ Requires-Dist: scanpy
 Requires-Dist: scikit-image
 Requires-Dist: spatialdata>=0.2.6
 Requires-Dist: tifffile>=2023.8.12
+Requires-Dist: xmltodict
 Provides-Extra: dev
 Requires-Dist: bump2version; extra == 'dev'
 Requires-Dist: pre-commit; extra == 'dev'
@@ -68,6 +69,7 @@ Requires-Dist: sphinxcontrib-bibtex>=1.0.0; extra == 'doc'
 Provides-Extra: pre
 Requires-Dist: spatialdata>=0.4.0rc0; extra == 'pre'
 Provides-Extra: test
+Requires-Dist: pyarrow!=22; extra == 'test'
 Requires-Dist: pytest; extra == 'test'
 Requires-Dist: pytest-cov; extra == 'test'
 Description-Content-Type: text/markdown

{spatialdata_io-0.5.0 → spatialdata_io-0.6.0}/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.5.0'
-__version_tuple__ = version_tuple = (0, 5, 0)
+__version__ = version = '0.6.0'
+__version_tuple__ = version_tuple = (0, 6, 0)
 
 __commit_id__ = commit_id = None

spatialdata_io-0.6.0/asv.conf.json

@@ -0,0 +1,23 @@
+{
+    "version": 1,
+    "project": "spatialdata-io",
+    "project_url": "https://github.com/scverse/spatialdata-io",
+    "repo": ".",
+    "branches": ["image-reader-chunkwise"],
+    "dvcs": "git",
+    "environment_type": "virtualenv",
+    "pythons": ["3.12"],
+    "build_command": [],
+    "install_command": ["python -m pip install {build_dir}[test]"],
+    "uninstall_command": ["python -m pip uninstall -y {project}"],
+    "env_dir": ".asv/env",
+    "results_dir": ".asv/results",
+    "html_dir": ".asv/html",
+    "benchmark_dir": "benchmarks",
+    "hash_length": 8,
+    "build_cache_size": 2,
+    "install_timeout": 600,
+    "repeat": 3,
+    "processes": 1,
+    "attribute_selection": ["time_*", "peakmem_*"]
+}

spatialdata_io-0.6.0/benchmarks/__init__.py

@@ -0,0 +1 @@
+# ASV benchmarks for spatialdata-io

spatialdata_io-0.6.0/benchmarks/benchmark_image.py

@@ -0,0 +1,180 @@
+"""Benchmarks for SpatialData IO operations for large images.
+
+Instructions:
+    See benchmark_xenium.py for instructions.
+"""
+
+import logging
+import logging.handlers
+import tempfile
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import tifffile
+from spatialdata import SpatialData
+from spatialdata._logging import logger
+from xarray import DataArray
+
+from spatialdata_io import image  # type: ignore[attr-defined]
+
+# =============================================================================
+# CONFIGURATION - Edit these values to match your setup
+# =============================================================================
+# Image dimensions: (channels, height, width)
+IMAGE_SHAPE = (3, 30000, 30000)
+# =============================================================================
+
+
+class IOBenchmarkImage:
+    """Benchmark IO read operations with different parameter combinations."""
+
+    timeout = 3600
+    repeat = 3
+    number = 1
+    warmup_time = 0
+    processes = 1
+
+    # Parameter combinations: scale_factors, (use_tiff_memmap, compressed), chunks
+    # Combinations: (memmap=False, compressed=True), (memmap=False, compressed=False), (memmap=True, compressed=False)
+    params = [
+        [None, [2, 2]],  # scale_factors
+        [(False, True), (False, False), (True, False)],  # (use_tiff_memmap, compressed)
+        [(1, 250, 250), (3, 250, 250)],  # chunks
+    ]
+    param_names = ["scale_factors", "memmap_compressed", "chunks"]
+
+    # Class-level temp directory for image files (persists across all benchmarks)
+    _images_temp_dir: tempfile.TemporaryDirectory[str] | None = None
+    _path_read_uncompressed: Path | None = None
+    _path_read_compressed: Path | None = None
+
+    @classmethod
+    def _setup_images(cls) -> None:
+        """Create fake image data once for all benchmarks."""
+        if cls._images_temp_dir is not None:
+            return
+
+        cls._images_temp_dir = tempfile.TemporaryDirectory()
+        images_dir = Path(cls._images_temp_dir.name)
+        cls._path_read_uncompressed = images_dir / "image_uncompressed.tif"
+        cls._path_read_compressed = images_dir / "image_compressed.tif"
+
+        # Generate fake image data
+        rng = np.random.default_rng(42)
+        data = rng.integers(0, 255, size=IMAGE_SHAPE, dtype=np.uint8)
+
+        # Write uncompressed TIFF (memmappable)
+        tifffile.imwrite(cls._path_read_uncompressed, data, compression=None)
+        # Write compressed TIFF (not memmappable)
+        tifffile.imwrite(cls._path_read_compressed, data, compression="zlib")
+
+    def setup(self, *_: Any) -> None:
+        """Set up paths for benchmarking."""
+        # Create images once (shared across all benchmark runs)
+        self._setup_images()
+        self.path_read_uncompressed = self._path_read_uncompressed
+        self.path_read_compressed = self._path_read_compressed
+
+        # Create a separate temp directory for output (cleaned up after each run)
+        self._output_temp_dir = tempfile.TemporaryDirectory()
+        self.path_write = Path(self._output_temp_dir.name) / "data_benchmark.zarr"
+
+    def teardown(self, *_: Any) -> None:
+        """Clean up output directory after each benchmark run."""
+        if hasattr(self, "_output_temp_dir"):
+            self._output_temp_dir.cleanup()
+
+    def _convert_image(
+        self, scale_factors: list[int] | None, memmap_compressed: tuple[bool, bool], chunks: tuple[int, ...]
+    ) -> SpatialData:
+        """Read image data with specified parameters."""
+        use_tiff_memmap, compressed = memmap_compressed
+        # Select file based on compression setting
+        path_read = self.path_read_compressed if compressed else self.path_read_uncompressed
+        assert path_read is not None
+
+        # Capture log messages to verify memmappable warning behavior
+        log_capture = logging.handlers.MemoryHandler(capacity=100)
+        log_capture.setLevel(logging.WARNING)
+        logger.addHandler(log_capture)
+        original_propagate = logger.propagate
+        logger.propagate = True
+
+        try:
+            im = image(
+                input=path_read,
+                data_axes=("c", "y", "x"),
+                coordinate_system="global",
+                use_tiff_memmap=use_tiff_memmap,
+                chunks=chunks,
+                scale_factors=scale_factors,
+            )
+        finally:
+            logger.removeHandler(log_capture)
+            logger.propagate = original_propagate
+
+        # Check warning behavior: when use_tiff_memmap=True with uncompressed file, no warning should be raised
+        log_messages = [record.getMessage() for record in log_capture.buffer]
+        has_memmap_warning = any("image data is not memory-mappable" in msg for msg in log_messages)
+        if use_tiff_memmap and not compressed:
+            assert not has_memmap_warning, (
+                "Uncompressed TIFF with memmap=True should not trigger memory-mappable warning"
+            )
+
+        sdata = SpatialData.init_from_elements({"image": im})
+        # sanity check: chunks is (c, y, x)
+        if scale_factors is None:
+            assert isinstance(sdata["image"], DataArray)
+            if chunks is not None:
+                assert (
+                    sdata["image"].chunksizes["x"][0] == chunks[2]
+                    or sdata["image"].chunksizes["x"][0] == sdata["image"].shape[2]
+                )
+                assert (
+                    sdata["image"].chunksizes["y"][0] == chunks[1]
+                    or sdata["image"].chunksizes["y"][0] == sdata["image"].shape[1]
+                )
+        else:
+            assert len(sdata["image"].keys()) == len(scale_factors) + 1
+            if chunks is not None:
+                assert (
+                    sdata["image"]["scale0"]["image"].chunksizes["x"][0] == chunks[2]
+                    or sdata["image"]["scale0"]["image"].chunksizes["x"][0]
+                    == sdata["image"]["scale0"]["image"].shape[2]
+                )
+                assert (
+                    sdata["image"]["scale0"]["image"].chunksizes["y"][0] == chunks[1]
+                    or sdata["image"]["scale0"]["image"].chunksizes["y"][0]
+                    == sdata["image"]["scale0"]["image"].shape[1]
+                )
+
+        return sdata
+
+    def time_io(
+        self, scale_factors: list[int] | None, memmap_compressed: tuple[bool, bool], chunks: tuple[int, ...]
+    ) -> None:
+        """Walltime for data parsing."""
+        sdata = self._convert_image(scale_factors, memmap_compressed, chunks)
+        sdata.write(self.path_write)
+
+    def peakmem_io(
+        self, scale_factors: list[int] | None, memmap_compressed: tuple[bool, bool], chunks: tuple[int, ...]
+    ) -> None:
+        """Peak memory for data parsing."""
+        sdata = self._convert_image(scale_factors, memmap_compressed, chunks)
+        sdata.write(self.path_write)
+
+
+# if __name__ == "__main__":
+#     # Run a single test case for quick verification
+#     bench = IOBenchmarkImage()
+#
+#     bench.setup()
+#     bench.time_io(None, (True, False), (1, 5000, 5000))
+#     bench.teardown()
+#
+#     # Clean up the shared images temp directory at the end
+#     if IOBenchmarkImage._images_temp_dir is not None:
+#         IOBenchmarkImage._images_temp_dir.cleanup()
+#         IOBenchmarkImage._images_temp_dir = None

spatialdata_io-0.6.0/benchmarks/benchmark_xenium.py

@@ -0,0 +1,108 @@
+"""Benchmarks for SpatialData IO operations.
+
+Configuration:
+    Edit SANDBOX_DIR and DATASET below to point to your data.
+
+Setup:
+    cd <SANDBOX_DIR>/<DATASET>
+    python download.py  # use the same env where spatialdata is installed
+
+Running:
+    cd /path/to/spatialdata-io
+
+    # Quick benchmark (single run, for testing):
+    asv run --python=same -b IOBenchmarkXenium --quick --show-stderr -v
+
+    # Full benchmark (multiple runs, for accurate results):
+    asv run --python=same -b IOBenchmarkXenium --show-stderr -v
+
+Comparing branches:
+    # Run on specific commits:
+    asv run main^! -b IOBenchmarkXenium --show-stderr -v
+    asv run xenium-labels-dask^! -b IOBenchmarkXenium --show-stderr -v
+
+    # Or compare two branches directly:
+    asv continuous main xenium-labels-dask -b IOBenchmarkXenium --show-stderr -v
+
+    # View comparison:
+    asv compare main xenium-labels-dask
+
+Results:
+    - Console output shows timing and memory after each run
+    - JSON results saved to: .asv/results/
+    - Generate HTML report: asv publish && asv preview
+"""
+
+import inspect
+import shutil
+from pathlib import Path
+
+from spatialdata import SpatialData
+
+from spatialdata_io import xenium  # type: ignore[attr-defined]
+
+# =============================================================================
+# CONFIGURATION - Edit these paths to match your setup
+# =============================================================================
+SANDBOX_DIR = Path(__file__).parent.parent.parent / "spatialdata-sandbox"
+DATASET = "xenium_2.0.0_io"
+# =============================================================================
+
+
+def get_paths() -> tuple[Path, Path]:
+    """Get paths for benchmark data."""
+    path = SANDBOX_DIR / DATASET
+    path_read = path / "data"
+    path_write = path / "data_benchmark.zarr"
+
+    if not path_read.exists():
+        raise ValueError(f"Data directory not found: {path_read}")
+
+    return path_read, path_write
+
+
+class IOBenchmarkXenium:
+    timeout = 3600
+    repeat = 3
+    number = 1
+    warmup_time = 0
+    processes = 1
+
+    def setup(self) -> None:
+        """Set up paths for benchmarking."""
+        self.path_read, self.path_write = get_paths()
+        if self.path_write.exists():
+            shutil.rmtree(self.path_write)
+
+    def _read_xenium(self) -> SpatialData:
+        """Read xenium data with version-compatible kwargs."""
+        signature = inspect.signature(xenium)
+        kwargs = {}
+        if "cleanup_labels_zarr_tmpdir" in signature.parameters:
+            kwargs["cleanup_labels_zarr_tmpdir"] = False
+
+        return xenium(
+            path=str(self.path_read),
+            n_jobs=8,
+            cell_boundaries=True,
+            nucleus_boundaries=True,
+            morphology_focus=True,
+            cells_as_circles=True,
+            **kwargs,
+        )
+
+    def time_io(self) -> None:
+        """Walltime for data parsing."""
+        sdata = self._read_xenium()
+        sdata.write(self.path_write)
+
+    def peakmem_io(self) -> None:
+        """Peak memory for data parsing."""
+        sdata = self._read_xenium()
+        sdata.write(self.path_write)
+
+
+if __name__ == "__main__":
+    benchmark = IOBenchmarkXenium()
+    benchmark.setup()
+    benchmark.time_io()

{spatialdata_io-0.5.0 → spatialdata_io-0.6.0}/pyproject.toml

@@ -36,6 +36,7 @@ dependencies = [
     "readfcs",
     "tifffile>=2023.8.12",
     "ome-types",
+    "xmltodict",
 ]
 
 [project.optional-dependencies]
@@ -59,6 +60,8 @@ doc = [
 test = [
     "pytest",
     "pytest-cov",
+    # https://github.com/scverse/spatialdata-io/issues/334
+    "pyarrow!=22"
 ]
 # this will be used by readthedocs and will make pip also look for pre-releases, generally installing the latest available version
 # update: readthedocs doens't seem to try to install pre-releases even if when trying to install the pre optional-dependency. For

{spatialdata_io-0.5.0 → spatialdata_io-0.6.0}/src/spatialdata_io/_constants/_constants.py

@@ -68,7 +68,6 @@ class SeqfishKeys(ModeEnum):
     TIFF_FILE = ".tiff"
     GEOJSON_FILE = ".geojson"
     # file identifiers
-    ROI = "Roi"
     TRANSCRIPT_COORDINATES = "TranscriptList"
     DAPI = "DAPI"
     COUNTS_FILE = "CellxGene"
@@ -78,6 +77,7 @@ class SeqfishKeys(ModeEnum):
     # transcripts
     TRANSCRIPTS_X = "x"
     TRANSCRIPTS_Y = "y"
+    TRANSCRIPTS_Z = "z"
     FEATURE_KEY = "name"
     INSTANCE_KEY_POINTS = "cell"
     # cells
@@ -88,8 +88,6 @@ class SeqfishKeys(ModeEnum):
     SPATIAL_KEY = "spatial"
     REGION_KEY = "region"
     INSTANCE_KEY_TABLE = "instance_id"
-    SCALEFEFACTOR_X = "PhysicalSizeX"
-    SCALEFEFACTOR_Y = "PhysicalSizeY"
 
 
 @unique

{spatialdata_io-0.5.0 → spatialdata_io-0.6.0}/src/spatialdata_io/converters/legacy_anndata.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import warnings
+from collections.abc import Mapping
 from typing import TYPE_CHECKING
 
 import numpy as np
@@ -12,6 +12,7 @@ from spatialdata import (
     to_circles,
 )
 from spatialdata._core.operations._utils import transform_to_data_extent
+from spatialdata._logging import logger
 from spatialdata.models import Image2DModel, ShapesModel, TableModel, get_table_keys
 from spatialdata.transformations import Identity, Scale
 
@@ -220,7 +221,7 @@ def to_legacy_anndata(
     return adata
 
 
-def from_legacy_anndata(adata: AnnData) -> SpatialData:
+def from_legacy_anndata(adata: AnnData, rgb: bool | None = None) -> SpatialData:
     """Convert (legacy) spatial AnnData object to SpatialData object.
 
     This is useful for parsing a (legacy) spatial AnnData object, for example the ones produced by Scanpy and older
@@ -230,6 +231,9 @@ def from_legacy_anndata(adata: AnnData) -> SpatialData:
     ----------
     adata
         (legacy) spatial AnnData object
+    rgb
+        Argument passed to `spatialdata.models.Image2DModel.parse()`. If `None`,
+        3-(4) channels images will be interpreted as RGB(A).
 
     Returns
     -------
@@ -250,6 +254,7 @@ def from_legacy_anndata(adata: AnnData) -> SpatialData:
     IMAGES = "images"
     HIRES = "hires"
     LOWRES = "lowres"
+    DEFAULT_SCALE_FACTOR = 1.0
 
     # SpatialData keys
     REGION = "locations"
@@ -265,72 +270,80 @@ def from_legacy_anndata(adata: AnnData) -> SpatialData:
     if SPATIAL in adata.uns:
         dataset_ids = list(adata.uns[SPATIAL].keys())
         for dataset_id in dataset_ids:
-            # read the image data and the scale factors for the shapes
-            keys = set(adata.uns[SPATIAL][dataset_id].keys())
-            tissue_hires_scalef = None
-            tissue_lowres_scalef = None
-            hires = None
-            lowres = None
-            if SCALEFACTORS in keys:
-                scalefactors = adata.uns[SPATIAL][dataset_id][SCALEFACTORS]
-                if TISSUE_HIRES_SCALEF in scalefactors:
-                    tissue_hires_scalef = scalefactors[TISSUE_HIRES_SCALEF]
-                if TISSUE_LOWRES_SCALEF in scalefactors:
-                    tissue_lowres_scalef = scalefactors[TISSUE_LOWRES_SCALEF]
-                if SPOT_DIAMETER_FULLRES in scalefactors:
-                    spot_diameter_fullres_list.append(scalefactors[SPOT_DIAMETER_FULLRES])
-            if IMAGES in keys:
-                image_data = adata.uns[SPATIAL][dataset_id][IMAGES]
-                if HIRES in image_data:
-                    hires = image_data[HIRES]
-                if LOWRES in image_data:
-                    lowres = image_data[LOWRES]
-
-            # construct the spatialdata elements
-            if hires is not None:
-                # prepare the hires image
-                assert tissue_hires_scalef is not None, (
-                    "tissue_hires_scalef is required when an the hires image is present"
+            dataset_data = adata.uns[SPATIAL][dataset_id]
+            keys = set(dataset_data.keys())
+            scalefactors_raw = dataset_data.get(SCALEFACTORS, {}) if isinstance(dataset_data, Mapping) else {}
+            scalefactors = scalefactors_raw if isinstance(scalefactors_raw, Mapping) else {}
+
+            if SPOT_DIAMETER_FULLRES in scalefactors:
+                spot_diameter_fullres_list.append(scalefactors[SPOT_DIAMETER_FULLRES])
+
+            image_data = dataset_data.get(IMAGES, {}) if IMAGES in keys and isinstance(dataset_data, Mapping) else {}
+            if not isinstance(image_data, Mapping):
+                image_data = {}
+            for image_key, image_value in image_data.items():
+                if image_key not in (HIRES, LOWRES):
+                    logger.warning(
+                        "Found non-standard image key '%s' in dataset '%s' - attempting to parse.",
+                        image_key,
+                        dataset_id,
+                    )
+                # prefer scalefactors keyed by the image name, fall back to tissue_<image_key>_scalef
+                # then to legacy hires/lowres names, finally default to 1.0.
+                scalefactor = None
+                scalefactor_source = None
+                if image_key in scalefactors:
+                    scalefactor = scalefactors[image_key]
+                    scalefactor_source = image_key
+                elif f"tissue_{image_key}_scalef" in scalefactors:
+                    scalefactor = scalefactors[f"tissue_{image_key}_scalef"]
+                    scalefactor_source = f"tissue_{image_key}_scalef"
+                elif image_key == HIRES and TISSUE_HIRES_SCALEF in scalefactors:
+                    scalefactor = scalefactors[TISSUE_HIRES_SCALEF]
+                    scalefactor_source = TISSUE_HIRES_SCALEF
+                elif image_key == LOWRES and TISSUE_LOWRES_SCALEF in scalefactors:
+                    scalefactor = scalefactors[TISSUE_LOWRES_SCALEF]
+                    scalefactor_source = TISSUE_LOWRES_SCALEF
+
+                if scalefactor is None:
+                    scalefactor = DEFAULT_SCALE_FACTOR
+                    logger.warning(
+                        "Scale factor missing for image '%s' in dataset '%s'; defaulting to %s",
+                        image_key,
+                        dataset_id,
+                        DEFAULT_SCALE_FACTOR,
+                    )
+                else:
+                    logger.debug(
+                        "Using scalefactor '%s' for image '%s' in dataset '%s'",
+                        scalefactor_source,
+                        image_key,
+                        dataset_id,
+                    )
+
+                transform_name = f"{dataset_id}_{image_key}"
+                image_name = f"{dataset_id}_{image_key}"
+                images[image_name] = Image2DModel.parse(
+                    image_value,
+                    dims=("y", "x", "c"),
+                    transformations={transform_name: Identity()},
+                    rgb=rgb,
                 )
-                hires_image = Image2DModel.parse(
-                    hires, dims=("y", "x", "c"), transformations={f"{dataset_id}_downscaled_hires": Identity()}
-                )
-                images[f"{dataset_id}_hires_image"] = hires_image
-
-                # prepare the transformation to the hires image for the shapes
-                scale_hires = Scale([tissue_hires_scalef, tissue_hires_scalef], axes=("x", "y"))
-                shapes_transformations[f"{dataset_id}_downscaled_hires"] = scale_hires
-            if lowres is not None:
-                # prepare the lowres image
-                assert tissue_lowres_scalef is not None, (
-                    "tissue_lowres_scalef is required when an the lowres image is present"
-                )
-                lowres_image = Image2DModel.parse(
-                    lowres, dims=("y", "x", "c"), transformations={f"{dataset_id}_downscaled_lowres": Identity()}
-                )
-                images[f"{dataset_id}_lowres_image"] = lowres_image
-
-                # prepare the transformation to the lowres image for the shapes
-                scale_lowres = Scale([tissue_lowres_scalef, tissue_lowres_scalef], axes=("x", "y"))
-                shapes_transformations[f"{dataset_id}_downscaled_lowres"] = scale_lowres
+                shapes_transformations[transform_name] = Scale([scalefactor, scalefactor], axes=("x", "y"))
 
     # validate the spot_diameter_fullres value
     if len(spot_diameter_fullres_list) > 0:
         d = np.array(spot_diameter_fullres_list)
         if not np.allclose(d, d[0]):
-            warnings.warn(
+            logger.warning(
                 "spot_diameter_fullres is not constant across datasets. Using the average value.",
-                UserWarning,
-                stacklevel=2,
             )
             spot_diameter_fullres = d.mean()
         else:
             spot_diameter_fullres = d[0]
     else:
-        warnings.warn(
+        logger.warning(
             f"spot_diameter_fullres is not present. Using {SPOT_DIAMETER_FULLRES_DEFAULT} as default value.",
-            UserWarning,
-            stacklevel=2,
         )
         spot_diameter_fullres = SPOT_DIAMETER_FULLRES_DEFAULT