imaging-server-kit 0.1.3__tar.gz → 0.3.0__tar.gz

imaging_server_kit-0.3.0/.github/workflows/deploy.yml

@@ -0,0 +1,53 @@
+name: Docs
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: docs-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python 3.11
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+        cache: pip
+        cache-dependency-path: pyproject.toml
+
+    - name: Install dependencies
+      run: pip install ".[docs]"
+
+    - name: Build the docs
+      run: mkdocs build --strict
+
+    - name: Upload artifact
+      if: github.event_name == 'push'
+      uses: actions/upload-pages-artifact@v3
+      with:
+        path: site
+
+  deploy:
+    if: github.event_name == 'push'
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+    - name: Deploy to GitHub Pages
+      id: deployment
+      uses: actions/deploy-pages@v4

{imaging_server_kit-0.1.3 → imaging_server_kit-0.3.0}/.github/workflows/publish.yml

@@ -1,17 +1,16 @@
-# Build the package and publish it to PyPI on tag push.
 name: Publish to PyPI
 on:
   push:
     tags:
       - "v*"
 
-permissions:
-  contents: write
-
 jobs:
   publish:
     name: publish
     runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
     steps:
       - name: Checkout source
         uses: actions/checkout@v4
@@ -24,10 +23,7 @@ jobs:
           python -m pip install -U pip build
           python -m build
       - name: Publish
-        uses: pypa/gh-action-pypi-publish@v1.5.0
-        with:
-          user: __token__
-          password: ${{ secrets.TWINE_API_KEY }}
+        uses: pypa/gh-action-pypi-publish@v1.13.0
       - name: Create Release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

{imaging_server_kit-0.1.3 → imaging_server_kit-0.3.0}/.gitignore

@@ -2,6 +2,7 @@ __pycache__/
 *.py[cod]
 *$py.class
 old/
+tmp/
 data/
 env/
 build/
@@ -16,7 +17,7 @@ eggs/
 .coverage
 .coverage.*
 .cache
-docs/_build/
+site/
 .idea/
 venv/
 .vscode/
@@ -26,4 +27,11 @@ venv/
 **/_version.py
 
 push.sh
-todo.txt
+todo.txt
+release.md
+TODO.md
+AGENTS.md
+CLAUDE.md
+.claude/
+summary.md
+docs_missing.md

{imaging_server_kit-0.1.3 → imaging_server_kit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: imaging-server-kit
-Version: 0.1.3
+Version: 0.3.0
 Summary: Convert image processing functions to GUIs, FastAPI servers, and more.
 Author-email: Mallory Wittwer <mallory.wittwer@epfl.ch>
 License: Copyright (c) 2024, EPFL
@@ -33,67 +33,78 @@ License: Copyright (c) 2024, EPFL
         
 Project-URL: repository, https://github.com/Imaging-Server-Kit/imaging-server-kit
 Project-URL: documentation, https://imaging-server-kit.github.io/imaging-server-kit
-Classifier: Development Status :: 2 - Pre-Alpha
-Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Image Processing
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
+Requires-Dist: pandas
 Requires-Dist: tifffile
-Requires-Dist: tqdm
+Requires-Dist: rich
 Requires-Dist: pydantic>=2.0
 Requires-Dist: scikit-image[optional]
 Requires-Dist: jinja2
 Requires-Dist: PyYAML
-Requires-Dist: cookiecutter
-Requires-Dist: opencv-contrib-python-headless
-Requires-Dist: imantics
+Requires-Dist: rasterio
+Requires-Dist: shapely>=2.0
 Requires-Dist: geojson
 Requires-Dist: fastapi
 Requires-Dist: uvicorn[standard]
 Requires-Dist: python-multipart
 Requires-Dist: msgpack
-Requires-Dist: httpx
+Requires-Dist: networkx
+Provides-Extra: napari
+Requires-Dist: qtpy; extra == "napari"
+Requires-Dist: napari[all]>=0.4.16; extra == "napari"
+Requires-Dist: napari-toolkit; extra == "napari"
+Requires-Dist: opencv-contrib-python-headless; extra == "napari"
+Provides-Extra: qupath
+Requires-Dist: imaging-server-kit[napari]; extra == "qupath"
+Requires-Dist: qubalab>=0.2.0; python_version >= "3.11" and extra == "qupath"
 Provides-Extra: docs
-Requires-Dist: jupyter-book<2.0; extra == "docs"
-Requires-Dist: jupytext; extra == "docs"
+Requires-Dist: mkdocs<2,>=1.6; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.26; extra == "docs"
+Requires-Dist: ruff; extra == "docs"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: httpx2; extra == "test"
 Provides-Extra: all
-Requires-Dist: imaging-server-kit[docs,test]; extra == "all"
+Requires-Dist: imaging-server-kit[docs,napari,qupath,test]; extra == "all"
 Dynamic: license-file
 
-![EPFL Center for Imaging logo](https://imaging.epfl.ch/resources/logo-for-gitlab.svg)
 # 🪐 Imaging Server Kit
 
 Turn Python-based image processing workflows into **algorithms** that gain extra functionalities.
 
-- [**Turn your algorithms into web servers**](https://imaging-server-kit.github.io/imaging-server-kit/sections/07_server.html) and run computations from [QuPath](https://github.com/Imaging-Server-Kit/qupath-extension-serverkit), [Napari](https://github.com/Imaging-Server-Kit/napari-serverkit), or [Python](./sections/08_python) via HTTP requests.
+- [**Turn your algorithms into web servers**](https://imaging-server-kit.github.io/imaging-server-kit/tutorial/serve.html) and run computations from [Napari](https://napari.org/stable/), [QuPath](https://qupath.github.io/), or [Python](https://imaging-server-kit.github.io/imaging-server-kit/tutorial/python.html) via HTTP requests.
 
-https://github.com/user-attachments/assets/36bda69d-996e-4240-9a53-7e76d9ea3894
+https://github.com/user-attachments/assets/0be819ea-fcc1-48ee-8fae-7265e63a00d4
 
-- [**Generate dock widgets**](https://imaging-server-kit.github.io/imaging-server-kit/sections/01_algorithm.html) to run your algorithms interactively in Napari.
+- [**Generate dock widgets**](https://imaging-server-kit.github.io/imaging-server-kit/how-to/napari.html) to run your algorithms interactively in Napari or QuPath.
 
 https://github.com/user-attachments/assets/1ff572f7-f159-4f5a-afd4-7a157de3d9f8
 
-- Run your algorithms [**tile-by-tile**](https://imaging-server-kit.github.io/imaging-server-kit/sections/06_tiled.html) on the input data.
+- Run your algorithms [**tile-by-tile**](https://imaging-server-kit.github.io/imaging-server-kit/how-to/tiling.html) on the input data.
 
 https://github.com/user-attachments/assets/47c2f734-5683-49d9-8aea-388c3a2bc16d
 
-- [**Stream results**](https://imaging-server-kit.github.io/imaging-server-kit/sections/05_streams.html) to inspect them in real-time.
+- [**Stream results**](https://imaging-server-kit.github.io/imaging-server-kit/how-to/live-updates.html) to inspect them in real-time.
 
 https://github.com/user-attachments/assets/a3f69a9f-fb68-4580-a804-6c57d5807b9a
 
+## Development status
+
+The Imaging Server Kit is being actively developed and is iterating rapidly. It is likely that there will be **compatibility-breaking changes** in future versions.
+
 ## Installation
 
 Install the `imaging-server-kit` package with `pip`:
@@ -110,6 +121,18 @@ cd imaging-server-kit
 pip install -e .
 ```
 
+To use the **Napari-related functionalities**, you additionally have to install [`napari`](https://github.com/napari/napari) and [`napari-toolkit`](https://github.com/MIC-DKFZ/napari_toolkit) which are not included by default. Install the package with:
+
+```sh
+pip install "imaging-server-kit[napari]"
+```
+
+To use the **QuPath-related functionalities**, you additionally have to install [`qubalab>=0.2.0`](https://pypi.org/project/qubalab/#history), which is not included by default. Install the package with:
+
+```sh
+pip install "imaging-server-kit[qupath]"
+```
+
 ## Getting started
 
 The documentation is available on [this page](https://imaging-server-kit.github.io/imaging-server-kit).
@@ -128,22 +151,9 @@ If you encounter any problems, please file an issue along with a detailed descri
 
 ## Citing
 
-[![DOI](https://zenodo.org/badge/912741131.svg)](https://doi.org/10.5281/zenodo.15673151)
-
-If you use the Imaging Server Kit in the context of scientific publication, you can cite it as below.
-
-BibTeX:
+If you use *Imaging Server Kit* in the context of scientific publication, you can cite it from the Zenodo repository:
 
-```
-@software{mallory_wittwer_2025_15673152,
-  author       = {Mallory Wittwer and Edward Andò and Maud Barthélemy and Florian Aymanns},
-  title        = {Imaging-Server-Kit/imaging-server-kit: v0.0.14},
-  url          = {https://doi.org/10.5281/zenodo.15673152},
-  doi          = {10.5281/zenodo.15673152},
-  version      = {v0.0.14},
-  year         = 2025,
-}
-```
+[![DOI](https://zenodo.org/badge/912741131.svg)](https://doi.org/10.5281/zenodo.15673151)
 
 ## Acknowledgements
 

{imaging_server_kit-0.1.3 → imaging_server_kit-0.3.0}/README.md

@@ -1,24 +1,27 @@
-![EPFL Center for Imaging logo](https://imaging.epfl.ch/resources/logo-for-gitlab.svg)
 # 🪐 Imaging Server Kit
 
 Turn Python-based image processing workflows into **algorithms** that gain extra functionalities.
 
-- [**Turn your algorithms into web servers**](https://imaging-server-kit.github.io/imaging-server-kit/sections/07_server.html) and run computations from [QuPath](https://github.com/Imaging-Server-Kit/qupath-extension-serverkit), [Napari](https://github.com/Imaging-Server-Kit/napari-serverkit), or [Python](./sections/08_python) via HTTP requests.
+- [**Turn your algorithms into web servers**](https://imaging-server-kit.github.io/imaging-server-kit/tutorial/serve.html) and run computations from [Napari](https://napari.org/stable/), [QuPath](https://qupath.github.io/), or [Python](https://imaging-server-kit.github.io/imaging-server-kit/tutorial/python.html) via HTTP requests.
 
-https://github.com/user-attachments/assets/36bda69d-996e-4240-9a53-7e76d9ea3894
+https://github.com/user-attachments/assets/0be819ea-fcc1-48ee-8fae-7265e63a00d4
 
-- [**Generate dock widgets**](https://imaging-server-kit.github.io/imaging-server-kit/sections/01_algorithm.html) to run your algorithms interactively in Napari.
+- [**Generate dock widgets**](https://imaging-server-kit.github.io/imaging-server-kit/how-to/napari.html) to run your algorithms interactively in Napari or QuPath.
 
 https://github.com/user-attachments/assets/1ff572f7-f159-4f5a-afd4-7a157de3d9f8
 
-- Run your algorithms [**tile-by-tile**](https://imaging-server-kit.github.io/imaging-server-kit/sections/06_tiled.html) on the input data.
+- Run your algorithms [**tile-by-tile**](https://imaging-server-kit.github.io/imaging-server-kit/how-to/tiling.html) on the input data.
 
 https://github.com/user-attachments/assets/47c2f734-5683-49d9-8aea-388c3a2bc16d
 
-- [**Stream results**](https://imaging-server-kit.github.io/imaging-server-kit/sections/05_streams.html) to inspect them in real-time.
+- [**Stream results**](https://imaging-server-kit.github.io/imaging-server-kit/how-to/live-updates.html) to inspect them in real-time.
 
 https://github.com/user-attachments/assets/a3f69a9f-fb68-4580-a804-6c57d5807b9a
 
+## Development status
+
+The Imaging Server Kit is being actively developed and is iterating rapidly. It is likely that there will be **compatibility-breaking changes** in future versions.
+
 ## Installation
 
 Install the `imaging-server-kit` package with `pip`:
@@ -35,6 +38,18 @@ cd imaging-server-kit
 pip install -e .
 ```
 
+To use the **Napari-related functionalities**, you additionally have to install [`napari`](https://github.com/napari/napari) and [`napari-toolkit`](https://github.com/MIC-DKFZ/napari_toolkit) which are not included by default. Install the package with:
+
+```sh
+pip install "imaging-server-kit[napari]"
+```
+
+To use the **QuPath-related functionalities**, you additionally have to install [`qubalab>=0.2.0`](https://pypi.org/project/qubalab/#history), which is not included by default. Install the package with:
+
+```sh
+pip install "imaging-server-kit[qupath]"
+```
+
 ## Getting started
 
 The documentation is available on [this page](https://imaging-server-kit.github.io/imaging-server-kit).
@@ -53,22 +68,9 @@ If you encounter any problems, please file an issue along with a detailed descri
 
 ## Citing
 
-[![DOI](https://zenodo.org/badge/912741131.svg)](https://doi.org/10.5281/zenodo.15673151)
-
-If you use the Imaging Server Kit in the context of scientific publication, you can cite it as below.
-
-BibTeX:
+If you use *Imaging Server Kit* in the context of scientific publication, you can cite it from the Zenodo repository:
 
-```
-@software{mallory_wittwer_2025_15673152,
-  author       = {Mallory Wittwer and Edward Andò and Maud Barthélemy and Florian Aymanns},
-  title        = {Imaging-Server-Kit/imaging-server-kit: v0.0.14},
-  url          = {https://doi.org/10.5281/zenodo.15673152},
-  doi          = {10.5281/zenodo.15673152},
-  version      = {v0.0.14},
-  year         = 2025,
-}
-```
+[![DOI](https://zenodo.org/badge/912741131.svg)](https://doi.org/10.5281/zenodo.15673151)
 
 ## Acknowledgements
 

imaging_server_kit-0.3.0/docs/assets/extra.css

@@ -0,0 +1,11 @@
+/* Videos scale with their container (content area or grid card). */
+.md-typeset video {
+  display: block;
+  max-width: 100%;
+  height: auto;
+  border-radius: 0.2rem;
+}
+
+.md-typeset .grid.cards video {
+  margin-top: 0.6rem;
+}

imaging_server_kit-0.3.0/docs/citing.md

@@ -0,0 +1,22 @@
+# Citing
+
+If you use *Imaging Server Kit* in a scientific publication, please cite it using its Zenodo record:
+
+[![DOI](https://zenodo.org/badge/912741131.svg)](https://doi.org/10.5281/zenodo.15673151)
+
+The DOI [10.5281/zenodo.15673151](https://doi.org/10.5281/zenodo.15673151) always resolves to the latest version. Zenodo also provides citations for specific versions, in several formats including BibTeX.
+
+For example, for version 0.0.14:
+
+```bibtex
+@software{mallory_wittwer_2025_15673152,
+  author       = {Mallory Wittwer and Edward Andò and Maud Barthélemy and Florian Aymanns},
+  title        = {Imaging-Server-Kit/imaging-server-kit: v0.0.14},
+  url          = {https://doi.org/10.5281/zenodo.15673152},
+  doi          = {10.5281/zenodo.15673152},
+  version      = {v0.0.14},
+  year         = 2025,
+}
+```
+
+The repository also contains a [`CITATION.cff`](https://github.com/Imaging-Server-Kit/imaging-server-kit/blob/main/CITATION.cff) file.

imaging_server_kit-0.3.0/docs/concepts/algorithms.md

@@ -0,0 +1,65 @@
+# Algorithms
+
+## Algorithms
+
+An **algorithm** (`sk.Algorithm`) wraps a Python function together with a description of its inputs and outputs. It is usually created with the `@sk.algorithm` decorator.
+
+From the function signature and the annotations, the algorithm knows:
+
+- Which [data layer](layers-and-stacks.md) corresponds to each parameter the function takes.
+- How to interpret the **outputs** of the function as data layers.
+- Extra information (samples, name, description, compatibility with tiling, etc.).
+
+This representation is what allows the package to generate user interfaces, documentation pages, and web APIs for the algorithm without extra code.
+
+### Matching parameters with data layers
+
+Each parameter of the function is matched with a data layer. The layer is chosen from the first of these sources that applies:
+
+1. **Explicit annotations** in `parameters={}`, for example `parameters={"sigma": sk.Float(min=0)}`.
+2. **Type hints**: `int`, `float`, `bool`, `str`, data layer classes such as `sk.Image`, or `np.ndarray` (interpreted as an image).
+3. **Default values**: a data layer instance (for example `sigma=sk.Float(default=1.0)`), or a value whose type is used as in type hints (for example `sigma=1.0` gives an `sk.Float`).
+4. **Variable names**, for parameters without a type hint or default value: `image`, `mask`, `points`, `vectors`, `boxes`, `paths`, and `tracks` are matched with the corresponding data layer.
+
+Parameters that cannot be resolved, for example custom classes, lists, or dictionaries, become `sk.Any` layers. They are not shown in user interfaces, and they may not work with servers if they cannot be serialized.
+
+### Matching outputs with data layers
+
+The values returned (or [yielded](../how-to/live-updates.md)) by the function are converted to data layers:
+
+- Data layers, such as `sk.Mask(mask)`, are used as they are.
+- Values of simple types (`int`, `float`, `bool`, `str`, `np.ndarray`, and `None`) are converted to the matching layer. A NumPy array becomes an `sk.Image`.
+- A tuple or a list is treated as several outputs, each converted separately.
+- Any other value becomes an `sk.Any` layer.
+
+Wrapping outputs in data layers explicitly is recommended for arrays, since only the data layer tells whether an array is an image, a mask, or a set of points.
+
+## Algorithm collections
+
+An **algorithm collection** (`sk.MultiAlgorithm`) groups several algorithms under one name. It is created with [`sk.combine`](../how-to/combine.md). In user interfaces, the algorithms of a collection appear in a single dropdown. In Python, methods take an extra `algorithm` argument to select an algorithm by name.
+
+## Clients
+
+A **client** (`sk.Client`) is connected to an [algorithm server](../tutorial/serve.md). It gives access to the algorithms of the server, and sends the computations to the server when it runs them.
+
+## Shared interface
+
+Algorithms, collections, and clients share the same interface, defined by the `AlgorithmRunner` base class:
+
+| Method | Description |
+|---|---|
+| `run()` | Run an algorithm and return a [`Stack`](layers-and-stacks.md) of results. Supports [tiling](../how-to/tiling.md) and [regions](../how-to/regions.md). |
+| `get_sample()` | Get a sample as a `Stack` of parameters. |
+| `get_n_samples()` | Get the number of samples. |
+| `info()` | Open the documentation page in a web browser. |
+| `get_parameters()` | Get the parameters schema. |
+| `algorithms` | The list of available algorithm names. |
+
+As a result, the same code works on a local algorithm, an algorithm collection, or a remote server, and the same Napari widget works for all three via `sk.to_napari`.
+
+```python
+# All three work the same way:
+results = threshold_algo.run(image, threshold=100)
+results = multi_algo.run(image, algorithm="threshold", threshold=100)
+results = sk.Client("http://localhost:8000").run(image, threshold=100)
+```

imaging_server_kit-0.3.0/docs/concepts/coordinates.md

@@ -0,0 +1,96 @@
+# Pixel space
+
+## Coordinates
+
+Spatial layers (images, masks, points, etc.) have a `position`, which places them in **global pixel coordinates**. A layer's data is expressed in *local* coordinates, and `position` is the offset that translates them to global coordinates.
+
+For example, an image cropped from a larger image keeps track of where the crop came from: its data starts at index `(0, 0)`, while its `position` records where that pixel is in the original image.
+
+You can set the position when creating a layer:
+
+```python
+import imaging_server_kit as sk
+import numpy as np
+
+img = sk.Image(np.zeros((100, 200)), position=(50, 20))
+
+print(img)             # <Image 'Image' float64 (100, 200), at (50, 20)>
+print(img.position)    # (50, 20)
+print(img.extent)      # Domain(position=(50, 20), size=(100, 200))
+print(img.coords_min)  # (50.0, 20.0)
+print(img.coords_max)  # (150.0, 220.0)
+```
+
+For object layers such as points, the extent is the bounding box of the objects:
+
+```python
+pts = sk.Points(np.array([[30, 10], [60, 90]]))
+
+print(pts.position)    # (0, 0)
+print(pts.coords_min)  # (30.0, 10.0)
+print(pts.coords_max)  # (61.0, 91.0)
+```
+
+Stacks have a position and an extent too. Setting the position of a stack moves all of its layers:
+
+```python
+stack = sk.Stack([img, pts])
+
+print(stack.extent)  # Domain(position=(30, 10), size=(120, 210))
+
+stack.position = (10, 10)
+
+print(img.position)  # (60, 30)
+print(pts.position)  # (10, 10)
+```
+
+Layers and stacks share the following properties:
+
+| Property | Type | Description |
+|---|---|---|
+| `position` | `tuple` | Offset of the local coordinates in global pixel coordinates. |
+| `extent` | `sk.Domain` | Region covered by the data, in global coordinates. |
+| `coords_min` | `tuple` | Lower corner of the extent (top-left in 2D). |
+| `coords_max` | `tuple` | Upper corner of the extent (bottom-right in 2D). |
+| `size` | `tuple` | Size of the extent along each axis. |
+| `ndim` | `int` | Number of spatial dimensions. |
+
+## Domains
+
+Extents are `sk.Domain` objects. A domain is a box defined by a `size` and a `position` (its lower corner, which defaults to the origin):
+
+```python
+roi = sk.Domain(position=(20, 30), size=(60, 80))
+
+print(roi.coords_min)  # (20.0, 30.0)
+print(roi.coords_max)  # (80.0, 110.0)
+```
+
+Domains are used to describe regions of interest and to [restrict computations](../how-to/regions.md), for example.
+
+## Merging data
+
+### Merging tiles
+
+When an algorithm runs [tile-by-tile](../how-to/tiling.md), the input layers are split into tiles, the algorithm runs on each tile, and the results are merged into a single stack. How results are merged depends on the layer type:
+
+| Layer | Merging |
+|---|---|
+| `sk.Image` | Intensities are **averaged** in overlapping regions. |
+| `sk.Mask` | By default, the **last tile overwrites** overlapping regions. With `merger="instances"` and a non-zero overlap between tiles, labels are made unique across tiles and objects crossing tiles are stitched together (experimental). |
+| `sk.Points`, `sk.Vectors`, `sk.Boxes` | Each object belongs to the tile that contains it (vectors are placed based on their origin, boxes based on their center). When tiles overlap, objects in overlapping regions are returned once per tile. |
+| Other layers (`sk.Paths`, `sk.Tracks`, values, etc.) | Each tile **replaces** the previous value. |
+
+### Merging layers
+
+You can use `sk.merge_layers()` to merge a list of layers of the same kind into a new layer, using the rules above. For example, to assemble two images:
+
+```python
+left = sk.Image(np.ones((100, 100)))
+right = sk.Image(np.full((100, 100), 2.0), position=(0, 100))
+
+merged = sk.merge_layers([left, right])
+
+print(merged)           # <Image 'Image' float32 (100, 200)>
+print(merged.position)  # (0.0, 0.0)
+```

imaging_server_kit-0.3.0/docs/concepts/layers-and-stacks.md

@@ -0,0 +1,44 @@
+# Data layers
+
+## Data layers
+
+A **data layer** holds a single piece of data, such as an image, a segmentation mask, a set of points, or a numeric value, together with information about what that data means. All data layers derive from `sk.Layer`, and the available types are listed in [Data layers](../reference/api/layers.md).
+
+Data layers play two roles:
+
+- **Describing parameters.** Layers passed in `parameters={}` describe the algorithm's inputs: their type, constraints such as `min` and `max`, a default value, a name, and a description. User interfaces and documentation pages are generated from these descriptions, and parameter values are validated against them.
+- **Holding results.** Layers returned by an algorithm wrap its outputs, so that each output is displayed and handled correctly. For example, an array wrapped in `sk.Mask` is shown as a `Labels` layer in Napari.
+
+Every layer has the following attributes:
+
+| Attribute | Description |
+|---|---|
+| `data` | The data itself, for example a NumPy array or a number. |
+| `name` | The name of the layer. Defaults to the name of the layer type, such as `"Mask"`. |
+| `meta` | A dictionary of metadata: the description, the merging strategy, and any extra keyword arguments passed to the layer (for example `colormap="viridis"`). |
+| `kind` | A short string identifying the layer type, such as `"mask"`. |
+
+Spatial layers also have a position and an extent in global pixel coordinates (see [Coordinates, domains and tile merging](coordinates.md)).
+
+## Stacks
+
+A **stack** (`sk.Stack`) is an ordered collection of data layers. `.run()` returns the results of an algorithm as a stack, and `.get_sample()` returns samples as a stack of parameter layers.
+
+```python
+import imaging_server_kit as sk
+import numpy as np
+
+stack = sk.Stack([sk.Image(np.zeros((10, 10))), sk.Mask(np.ones((10, 10), dtype=int))])
+
+image_layer = stack[0]           # By index
+mask_layer = stack.read("Mask")  # By name
+```
+
+Within a stack, layer names are unique. When a layer is added with `stack.add()` under a name that is already taken, a suffix is appended to its name, for example `Image-01`.
+
+When results are merged into a stack, layers are matched by name:
+
+- A layer with a *new name* is **added** to the stack.
+- A layer with the *same name* as an existing layer **updates** that layer's data and metadata.
+
+This concept is the basis of [live updates](../how-to/live-updates.md) and [tiled inference](../how-to/tiling.md); each yielded output, or processed tile, is merged into a single result stack according to the rule above, based on layer name.

imaging_server_kit-0.3.0/docs/developers/ai_policy.md

@@ -0,0 +1,21 @@
+# AI policy
+
+*Imaging Server Kit* is being developed with passion and intent by humans, with the occasional help of AI to **improve the overall quality of the project**. The table below summarizes the respective contributions of humans and AI agents within the project.
+
+| Human contributions |
+| ----- |
+| Conceptualization of the project |
+| Implementing core functionalities (public API) |
+| Deciding which features to prioritize |
+| Writing the initial documentation site |
+| Reviewing and validating AI-generated outputs |
+| Reviewing tests and testing the package on real scientific data |
+
+| AI contributions |
+| -- |
+| Catching and fixing bugs |
+| Identifying series of actions that lead to unexpected results |
+| Targeted refactoring to improve code clarity or maintainability |
+| Enhancing the documentation site |
+| Writing or fixing public docstrings |
+| Writing tests and testing the package on toy scientific data |

imaging_server_kit-0.3.0/docs/examples.md

@@ -0,0 +1,3 @@
+# Examples
+
+The [extra-examples](https://github.com/Imaging-Server-Kit/extra-examples) repository contains a gallery of Imaging Server Kit algorithms implemented for a selection of open-source projects.