dummy-spatialdata 0.1.0__tar.gz

dummy_spatialdata-0.1.0/.gitignore

@@ -0,0 +1,2 @@
+*.tar.gz
+*.whl

dummy_spatialdata-0.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: dummy-spatialdata
+Version: 0.1.0
+Summary: A package for creating arbitrary spatialdata for testing purposes.
+Project-URL: Documentation, https://dummy-spatialdata.readthedocs.io/
+Project-URL: Homepage, https://github.com/Artur-man/dummy-spatialdata
+Project-URL: Source, https://github.com/Artur-man/dummy-spatialdata
+Author-email: Artür Manukyan <amanukyan.umms@gmail.com>
+License: MIT
+Requires-Python: >=3.13
+Requires-Dist: dummy-anndata>=0.0.3
+Requires-Dist: geopandas>=0.14
+Requires-Dist: pillow>=12.1.1
+Requires-Dist: requests>=2.31
+Requires-Dist: shapely>=2.0.1
+Requires-Dist: spatialdata-plot>=0.3.2
+Requires-Dist: spatialdata>=0.7.2
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# dummy-spatialdata
+
+Allows generating dummy spatialdata objects, which can be useful for testing purposes.
+
+## Installation
+
+```bash
+pip install dummy-spatialdata
+```
+
+## Example usage
+```{python}
+from dummy_spatialdata import generate_dataset
+import dummy_anndata
+import spatialdata_plot as sdp 
+import spatialdata as sd
+import matplotlib.pyplot as plt
+import anndata as ad
+
+# generate dummy anndata
+adata = dummy_anndata.generate_dataset(n_obs=12, n_vars=20)
+
+# generate dummy spatialdata
+sdata = generate_dataset(
+    images = [
+        {"type": "rgb", "n_layers": 4, "shape": {"x": 1000, "y": 1000}, "transformations": {"trans_0": ["affine"]}},
+        {"type": "grayscale", "n_layers": 1, "shape": {"x": 1000, "y": 1000}, "transformations": {"trans_0": ["affine"]}},
+    ],
+    labels = [
+        {"n_labels": 12, "n_layers": 4, "shape": {"x": 1000, "y": 1000}},
+        {"n_labels": 12, "n_layers": 0, "shape": {"x": 100, "y": 100}},
+    ], 
+    shapes = [
+        {"n_shapes": 12, "shape": {"x": 1000, "y": 1000}},
+        {"n_shapes": 20, "shape": {"x": 1000, "y": 1000}},
+    ],
+    tables = [
+        {"table": adata, "element": "shape", "element_index": 0}
+    ],
+    SEED=13
+)
+sdata
+```
+
+```
+SpatialData object
+├── Images
+│     ├── 'image_0': DataTree[cyx] (3, 1000, 1000), (3, 500, 500), (3, 250, 250), (3, 125, 125)
+│     └── 'image_1': DataTree[cyx] (1, 1000, 1000)
+├── Labels
+│     ├── 'label_0': DataTree[yx] (1000, 1000), (500, 500), (250, 250), (125, 125)
+│     └── 'label_1': DataTree[yx] (100, 100)
+├── Shapes
+│     ├── 'shape_0': GeoDataFrame shape: (12, 1) (2D shapes)
+│     └── 'shape_1': GeoDataFrame shape: (20, 1) (2D shapes)
+└── Tables
+      └── 'table_0': AnnData (12, 20)
+with coordinate systems:
+    ▸ 'global', with elements:
+        image_0 (Images), image_1 (Images), label_0 (Labels), label_1 (Labels), shape_0 (Shapes), shape_1 (Shapes)
+    ▸ 'trans_0', with elements:
+        image_0 (Images), image_1 (Images)
+```
+
+You can plot the demo data now!
+
+```{python}
+sdata.pl.render_images("image_0", ).pl.render_shapes("shape_0", color="Gene001", table_name = "table_0", table_layer = "float_matrix").pl.show(coordinate_systems = "global")
+```

dummy_spatialdata-0.1.0/README.md

@@ -0,0 +1,69 @@
+# dummy-spatialdata
+
+Allows generating dummy spatialdata objects, which can be useful for testing purposes.
+
+## Installation
+
+```bash
+pip install dummy-spatialdata
+```
+
+## Example usage
+```{python}
+from dummy_spatialdata import generate_dataset
+import dummy_anndata
+import spatialdata_plot as sdp 
+import spatialdata as sd
+import matplotlib.pyplot as plt
+import anndata as ad
+
+# generate dummy anndata
+adata = dummy_anndata.generate_dataset(n_obs=12, n_vars=20)
+
+# generate dummy spatialdata
+sdata = generate_dataset(
+    images = [
+        {"type": "rgb", "n_layers": 4, "shape": {"x": 1000, "y": 1000}, "transformations": {"trans_0": ["affine"]}},
+        {"type": "grayscale", "n_layers": 1, "shape": {"x": 1000, "y": 1000}, "transformations": {"trans_0": ["affine"]}},
+    ],
+    labels = [
+        {"n_labels": 12, "n_layers": 4, "shape": {"x": 1000, "y": 1000}},
+        {"n_labels": 12, "n_layers": 0, "shape": {"x": 100, "y": 100}},
+    ], 
+    shapes = [
+        {"n_shapes": 12, "shape": {"x": 1000, "y": 1000}},
+        {"n_shapes": 20, "shape": {"x": 1000, "y": 1000}},
+    ],
+    tables = [
+        {"table": adata, "element": "shape", "element_index": 0}
+    ],
+    SEED=13
+)
+sdata
+```
+
+```
+SpatialData object
+├── Images
+│     ├── 'image_0': DataTree[cyx] (3, 1000, 1000), (3, 500, 500), (3, 250, 250), (3, 125, 125)
+│     └── 'image_1': DataTree[cyx] (1, 1000, 1000)
+├── Labels
+│     ├── 'label_0': DataTree[yx] (1000, 1000), (500, 500), (250, 250), (125, 125)
+│     └── 'label_1': DataTree[yx] (100, 100)
+├── Shapes
+│     ├── 'shape_0': GeoDataFrame shape: (12, 1) (2D shapes)
+│     └── 'shape_1': GeoDataFrame shape: (20, 1) (2D shapes)
+└── Tables
+      └── 'table_0': AnnData (12, 20)
+with coordinate systems:
+    ▸ 'global', with elements:
+        image_0 (Images), image_1 (Images), label_0 (Labels), label_1 (Labels), shape_0 (Shapes), shape_1 (Shapes)
+    ▸ 'trans_0', with elements:
+        image_0 (Images), image_1 (Images)
+```
+
+You can plot the demo data now!
+
+```{python}
+sdata.pl.render_images("image_0", ).pl.render_shapes("shape_0", color="Gene001", table_name = "table_0", table_layer = "float_matrix").pl.show(coordinate_systems = "global")
+```

dummy_spatialdata-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling>=1.24"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dummy-spatialdata"
+version = "0.1.0"
+description = "A package for creating arbitrary spatialdata for testing purposes."
+readme = "README.md"
+requires-python = ">=3.13"
+license = { text = "MIT" }
+authors = [
+  { name = "Artür Manukyan", email = "amanukyan.umms@gmail.com" }
+]
+dependencies = [
+  "requests>=2.31",
+  "pillow>=12.1.1",
+  "spatialdata>=0.7.2",
+  "spatialdata-plot>=0.3.2",
+  "dummy-anndata>=0.0.3",
+  "geopandas>=0.14",
+  "shapely>=2.0.1"
+]
+urls.Documentation = "https://dummy-spatialdata.readthedocs.io/"
+urls.Homepage = "https://github.com/Artur-man/dummy-spatialdata"
+urls.Source = "https://github.com/Artur-man/dummy-spatialdata"
+
+[project.optional-dependencies]
+dev = [
+]
+
+[tool.hatch.build.targets.wheel]
+only-include = ["src/dummy_spatialdata", "examples"]
+
+[tool.hatch.build.targets.wheel.sources]
+"src" = ""
+"examples" = "dummy_spatialdata/examples"
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "/src",
+  "/README.md",
+  "/LICENSE",
+  "/examples/*"
+]
+
+[tool.hatch.metadata]
+allow-direct-references = true

dummy_spatialdata-0.1.0/src/dummy_spatialdata/__init__.py

@@ -0,0 +1,19 @@
+from importlib.metadata import version
+
+from .generate_dataset import generate_dataset
+from .generate_imagemodel import generate_imagemodel
+from .generate_labelmodel import generate_labelmodel
+from .generate_shapemodel import generate_shapemodel
+from .generate_tablemodel import generate_tablemodel
+from .generate_transformations import generate_transformations
+
+__all__ = [
+    "generate_dataset",
+    "generate_imagemodel",
+    "generate_labelmodel",
+    "generate_shapemodel",
+    "generate_tablemodel",
+    "generate_transformations"
+]
+
+__version__ = version("dummy-spatialdata")

dummy_spatialdata-0.1.0/src/dummy_spatialdata/generate_dataset.py

@@ -0,0 +1,88 @@
+import os
+import sys
+import numpy as np
+import spatialdata as sd
+
+from pathlib import Path
+from importlib.resources import files, as_file
+from PIL import Image
+from typing import Optional
+from .generate_imagemodel import generate_imagemodel
+from .generate_labelmodel import generate_labelmodel
+from .generate_shapemodel import generate_shapemodel
+from .generate_tablemodel import generate_tablemodel    
+from .generate_transformations import generate_transformations
+from spatialdata.models import TableModel
+
+def generate_dataset(
+    images: Optional[list] = None,
+    labels: Optional[list] = None,
+    shapes: Optional[list] = None,
+    tables: Optional[list] = None,
+    SEED: Optional[int] = 42
+) -> sd.SpatialData:
+    """Generate a dummy SpatialData object with specified elements.
+
+    Parameters
+    ----------
+    images: dict, optional
+        A dictionary specifying the type and number of layers for the image data.
+        Example: {"type": "rgb", "n_layers": 4} or {"type": "grayscale", "n_layers": 4}
+
+    Returns
+    -------
+    sd.SpatialData
+        A SpatialData object populated with random data according to the specified parameters.
+    """
+    
+    # image model
+    if images is None:
+        images = {}
+    else: 
+        images = [generate_imagemodel(img) for img in images]
+        keys = [f"image_{i}" for i in range(len(images))]
+        images = {key: img for key, img in zip(keys, images)}
+
+    # label model
+    if labels is None:
+        labels = {}
+    else: 
+        labels = [generate_labelmodel(lbl) for lbl in labels]
+        keys = [f"label_{i}" for i in range(len(labels))]
+        labels = {key: lbl for key, lbl in zip(keys, labels)}
+
+    # shape model
+    if shapes is None:
+        shapes = {}
+    else: 
+        shapes = [generate_shapemodel(shp, SEED) for shp in shapes]
+        keys = [f"shape_{i}" for i in range(len(shapes))]
+        shapes = {key: shp for key, shp in zip(keys, shapes)}
+
+    # tables
+    if tables is None:
+        tables = {}
+    else: 
+        tables = [generate_tablemodel(tbl) for tbl in tables]
+        keys = [f"table_{i}" for i in range(len(tables))]
+        tables = {key: tbl for key, tbl in zip(keys, tables)}
+
+    # create a SpatialData object and add the image data
+    sdata = sd.SpatialData(
+        images=images,
+        labels=labels,
+        shapes=shapes,
+        tables=tables,
+    )
+
+    # map shapes to tables
+    if tables is not {}:
+        for tbl in tables.values():
+            region = tbl.uns["spatialdata_attrs"]["region"]
+            element_type = region.split("_")[0]
+            instance_key = tbl.uns["spatialdata_attrs"]["instance_key"]
+            if region in sdata._shared_keys:
+                element = getattr(sdata, element_type + "s")[region]
+                tbl.obs['instance_id'] = element.index    
+
+    return sdata

dummy_spatialdata-0.1.0/src/dummy_spatialdata/generate_imagemodel.py

@@ -0,0 +1,68 @@
+import os
+import sys
+import numpy as np
+
+from pathlib import Path
+from importlib.resources import files, as_file
+from PIL import Image
+from typing import Optional
+from spatialdata.models import Image2DModel
+from .generate_transformations import generate_transformations
+
+def generate_imagemodel(
+    input: Optional[dict] = None,
+) -> Image2DModel:
+    """Generate a dummy Image2DModel object with specified elements.
+
+    Parameters
+    ----------
+    n_obs : int, optional
+        Number of observations (rows), by default 10.
+
+    Returns
+    -------
+    Image2DModel
+        An Image2DModel object populated with random data according to the specified parameters.
+    """
+
+    # check input
+    if input is None:
+        return None
+
+    # check transformations
+    if "transformations" not in input:
+        input["transformations"] = None
+
+    # get source 
+    resource = files("dummy_spatialdata")
+
+    # get image type
+    if input["type"] == "rgb":
+        with as_file(resource.joinpath("examples", "bird-color.png")) as path:
+            img = Image.open(path)
+            img = resize_image(img, input)
+            img = np.array(img).astype(np.uint8)
+        img = img.transpose((2, 0, 1))
+    elif input["type"] == "grayscale":
+        with as_file(resource.joinpath("examples", "nuclei.tif")) as path:
+            img = Image.open(path)
+            img = resize_image(img, input)
+            img = np.array(img).astype(np.uint8)
+        img = img.reshape(1, *img.shape)
+    else:
+        raise ValueError("Please type either 'rgb' or 'grayscale' for the image type.")   
+
+    # image model
+    imagemodel = Image2DModel.parse(data=img, 
+                                    scale_factors=(2,) * (input["n_layers"]-1), 
+                                    transformations=generate_transformations(input["transformations"]))
+
+    return imagemodel
+
+def resize_image(image: Image, input: dict) -> Image:
+    if "shape" not in input:
+        return image
+    new_width = input["shape"]['x']
+    new_height = input["shape"]['y']
+    resized = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+    return resized

dummy_spatialdata-0.1.0/src/dummy_spatialdata/generate_labelmodel.py

@@ -0,0 +1,39 @@
+import os
+import sys
+import numpy as np
+
+from importlib.resources import files, as_file
+from typing import Optional
+from spatialdata.models import Labels2DModel
+from .generate_transformations import generate_transformations
+
+def generate_labelmodel(
+    input: Optional[dict] = None,
+) -> Labels2DModel:
+    
+    # return None if no input is provided
+    if input is None:
+        return None
+    
+    # check transformations
+    if "transformations" not in input:
+        input["transformations"] = None
+    
+    # generate labels
+    # mask for where values should be non-zero
+    rows, cols = input["shape"]["x"], input["shape"]["y"],
+    prob_nonzero = 0.1  # 5% non-zero values
+
+    arr = np.zeros((rows, cols), dtype=int)
+    mask = np.random.rand(rows, cols) < prob_nonzero
+    arr[mask] = np.random.randint(1, input["n_labels"], size=mask.sum())
+
+    # image model
+    labelmodel = Labels2DModel.parse(data=arr, 
+                                     scale_factors=(2,) * (input["n_layers"]-1),
+                                     transformations = generate_transformations(input["transformations"]))
+
+    return labelmodel
+    
+
+    

dummy_spatialdata-0.1.0/src/dummy_spatialdata/generate_shapemodel.py

@@ -0,0 +1,75 @@
+import os
+import sys
+import numpy as np
+
+from importlib.resources import files, as_file
+from typing import Optional
+from spatialdata.models import ShapesModel
+import geopandas as gpd
+from shapely.geometry import Polygon, Point
+from .generate_transformations import generate_transformations
+
+def generate_shapemodel(
+    input: Optional[dict] = None,
+    SEED: Optional[int] = 42
+) -> ShapesModel:
+
+    if input is None:
+        return None
+
+    # check transformations
+    if "transformations" not in input:
+        input["transformations"] = None
+
+    # generate polygons
+    RADIUS = 0.08 * min(input["shape"]["x"], input["shape"]["y"])
+    MIN_GAP = 0.01 * min(input["shape"]["x"], input["shape"]["y"])
+
+    centers = generate_non_overlapping_centers(input["shape"]["x"], input["shape"]["y"], RADIUS, input["n_shapes"], MIN_GAP, SEED)
+    polygon_seeds = [SEED + i for i in range(input["n_shapes"])]
+    polygons = [Polygon(border_polygon_points(c, RADIUS, 10, SEED = seed)) for c, seed in zip(centers, polygon_seeds)]
+    gdf = gpd.GeoDataFrame(geometry=polygons)
+
+    # shape model
+    shapemodel = ShapesModel.parse(gdf, 
+                                   transformations=generate_transformations(input["transformations"]))
+
+    # return shapemodel
+    return gdf
+
+def circles_overlap(c1, c2, radius, min_gap=0.0):
+    x1, y1 = c1
+    x2, y2 = c2
+    return np.hypot(x2 - x1, y2 - y1) < (2 * radius + min_gap)
+
+def generate_non_overlapping_centers(width, height, radius, n_circles, min_gap=0.15, SEED=1, max_tries=10000):
+    centers = []
+    tries = 0
+    rng = np.random.default_rng(SEED)
+
+    while len(centers) < n_circles and tries < max_tries:
+        tries += 1
+        x = rng.uniform(radius, width - radius)
+        y = rng.uniform(radius, height - radius)
+        candidate = (x, y)
+
+        if all(not circles_overlap(candidate, c, radius, min_gap=min_gap) for c in centers):
+            centers.append(candidate)
+
+    if len(centers) < n_circles:
+        raise RuntimeError(f"Could only place {len(centers)} circles after {max_tries} attempts.")
+
+    return np.array(centers)
+
+def border_polygon_points(center, radius, n_points, SEED=1):
+    cx, cy = center
+    rng = np.random.default_rng(SEED)
+
+    # Random angles around the border
+    angles = np.sort(rng.uniform(0, 2 * np.pi, n_points))
+
+    # Points exactly on the circle border
+    xs = cx + radius * np.cos(angles)
+    ys = cy + radius * np.sin(angles)
+
+    return np.column_stack([xs, ys])

dummy_spatialdata-0.1.0/src/dummy_spatialdata/generate_tablemodel.py

@@ -0,0 +1,30 @@
+import os
+import sys
+import numpy as np
+
+from pathlib import Path
+from importlib.resources import files, as_file
+from PIL import Image
+from typing import Optional
+from spatialdata.models import TableModel
+import spatialdata as sd
+
+def generate_tablemodel(
+    input: Optional[dict] = None,
+    sdata: sd.SpatialData = None
+) -> TableModel:
+
+    if input is None:
+        return None
+
+    # add metadata to table
+    region = input["element"] + "_" + str(input["element_index"])
+    input["table"].obs['instance_id'] = input["table"].obs.index
+    input["table"].obs['region'] = region
+    input["table"].uns["spatialdata_attrs"] = {
+        "region": region,
+        "region_key": "region",
+        "instance_key": "instance_id",
+    }
+
+    return TableModel.parse(input["table"])

dummy_spatialdata-0.1.0/src/dummy_spatialdata/generate_transformations.py

@@ -0,0 +1,48 @@
+from spatialdata.transformations import (
+    Affine,
+    Scale,
+    Sequence,
+    Translation,
+    BaseTransformation, 
+    Identity
+)
+
+def generate_transformations(
+    trans: Optional[dict] = None
+) -> list[BaseTransformation]:
+    
+    if trans is None:
+        return None
+
+    coord_system = list(trans.keys())[0]
+    trans = list(trans.items())[0][1]
+
+    alltrans = []
+    for tr in trans:
+        if tr == "translation":
+            tr = Translation([10, 20], axes = ("x", "y"))
+        elif tr == "scale":
+            tr = Scale([0.5, 0.5], axes = ("x", "y"))
+        elif tr == "affine":
+            tr = Affine(matrix = [
+                    [0.5, 0.2, 0],
+                    [0.1, 0.5, 0],
+                    [0, 0, 1],
+                ], 
+                input_axes=("x", "y"), output_axes=("x", "y"))
+        else:
+            raise ValueError(f"Transformation type '{tr}' not recognized. Please choose from 'translation', 'scale', or 'affine'.")
+        alltrans.append(tr)
+    
+    if(len(alltrans) > 1):
+        alltrans = Sequence(alltrans)
+    else:
+        alltrans = alltrans[0]
+
+    finaltrans = {"global": Identity()}
+    finaltrans.update({coord_system: alltrans})
+
+    return finaltrans
+    
+
+