imaging-server-kit 0.0.6__tar.gz → 0.0.7__tar.gz

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

@@ -0,0 +1,39 @@
+name: Deploy docs
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  deploy-book:
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      id-token: write
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python 3.11
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+        cache: pip # Implicitly uses requirements.txt for cache key
+        
+    - name: Install dependencies
+      run: pip install jupyter-book
+
+    - name: Build the book
+      run: |
+        jupyter-book build docs
+
+    # Upload the book's HTML as an artifact
+    - name: Upload artifact
+      uses: actions/upload-pages-artifact@v3
+      with:
+        path: "docs/_build/html"
+
+    # Deploy the book's HTML to GitHub Pages
+    - name: Deploy to GitHub Pages
+      id: deployment
+      uses: actions/deploy-pages@v4

{imaging_server_kit-0.0.6 → imaging_server_kit-0.0.7}/.gitignore

@@ -25,4 +25,5 @@ venv/
 .DS_Store
 **/_version.py
 
-push.sh
+push.sh
+todo.txt

imaging_server_kit-0.0.7/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: imaging-server-kit
+Version: 0.0.7
+Summary: Deploy image processing algorithms in FastAPI servers. 
+Author-email: Mallory Wittwer <mallory.wittwer@epfl.ch>
+License: Copyright (c) 2024, EPFL
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        * Redistributions of source code must retain the above copyright notice, this
+          list of conditions and the following disclaimer.
+        
+        * Redistributions in binary form must reproduce the above copyright notice,
+          this list of conditions and the following disclaimer in the documentation
+          and/or other materials provided with the distribution.
+        
+        * Neither the name of copyright holder nor the names of its
+          contributors may be used to endorse or promote products derived from
+          this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: homepage, https://imaging-server-kit.github.io/imaging-server-kit
+Project-URL: repository, https://github.com/Imaging-Server-Kit/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: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi
+Requires-Dist: uvicorn[standard]
+Requires-Dist: python-multipart
+Requires-Dist: httpx
+Requires-Dist: tifffile
+Requires-Dist: numpy
+Requires-Dist: scikit-image
+Requires-Dist: imantics
+Requires-Dist: geojson
+Requires-Dist: jinja2
+Requires-Dist: PyYAML
+Requires-Dist: pydantic>=2.0
+Requires-Dist: cookiecutter
+Provides-Extra: docs
+Requires-Dist: jupyter-book; extra == "docs"
+Requires-Dist: jupytext; extra == "docs"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: users
+Requires-Dist: fastapi-users[sqlalchemy]; extra == "users"
+Requires-Dist: aiosqlite; extra == "users"
+Provides-Extra: all
+Requires-Dist: imaging-server-kit[docs,test,users]; extra == "all"
+Dynamic: license-file
+
+![EPFL Center for Imaging logo](https://imaging.epfl.ch/resources/logo-for-gitlab.svg)
+# 🪐 Imaging Server Kit
+
+Deploy image processing algorithms in FastAPI servers and easily run them from Napari, QuPath, and more.
+
+## Installation
+
+Install the `imaging-server-kit` package with `pip`:
+
+```
+pip install imaging-server-kit
+```
+
+or clone the project and install the development version:
+
+```
+git clone https://github.com/Imaging-Server-Kit/imaging-server-kit.git
+cd imaging-server-kit
+pip install -e .
+```
+
+## Getting started
+
+The documentation is available on [this page](https://imaging-server-kit.github.io/imaging-server-kit).
+
+## Contributing
+
+Contributions are very welcome.
+
+## License
+
+This software is distributed under the terms of the [BSD-3](http://opensource.org/licenses/BSD-3-Clause) license.
+
+## Issues
+
+If you encounter any problems, please file an issue along with a detailed description.

imaging_server_kit-0.0.7/README.md

@@ -0,0 +1,36 @@
+![EPFL Center for Imaging logo](https://imaging.epfl.ch/resources/logo-for-gitlab.svg)
+# 🪐 Imaging Server Kit
+
+Deploy image processing algorithms in FastAPI servers and easily run them from Napari, QuPath, and more.
+
+## Installation
+
+Install the `imaging-server-kit` package with `pip`:
+
+```
+pip install imaging-server-kit
+```
+
+or clone the project and install the development version:
+
+```
+git clone https://github.com/Imaging-Server-Kit/imaging-server-kit.git
+cd imaging-server-kit
+pip install -e .
+```
+
+## Getting started
+
+The documentation is available on [this page](https://imaging-server-kit.github.io/imaging-server-kit).
+
+## Contributing
+
+Contributions are very welcome.
+
+## License
+
+This software is distributed under the terms of the [BSD-3](http://opensource.org/licenses/BSD-3-Clause) license.
+
+## Issues
+
+If you encounter any problems, please file an issue along with a detailed description.

imaging_server_kit-0.0.7/docs/_config.yml

@@ -0,0 +1,23 @@
+title: Imaging Server Kit
+author: EPFL Center for Imaging
+# logo: "logo.ico"
+copyright: "2025"
+
+only_build_toc_files: true
+
+repository:
+  url: https://github.com/Imaging-Server-Kit/imaging-server-kit
+  branch: main
+  path_to_book: "docs"
+
+html:
+  favicon: "logo.ico"
+  use_issues_button: true
+  use_repository_button: true
+  toc: true
+  toc_depth: 2
+
+parse:
+  myst_enable_extensions:
+    - linkify
+    - html_admonition

imaging_server_kit-0.0.7/docs/_toc.yml

@@ -0,0 +1,11 @@
+format: jb-book
+root: index
+chapters:
+- file: sections/getting_started
+- file: sections/algorithm_server
+- file: sections/multi_algo_server
+# - file: sections/client_apps
+# - file: sections/authentication
+- file: sections/docker
+- file: sections/examples
+- file: sections/api_endpoints

imaging_server_kit-0.0.7/docs/index.md

@@ -0,0 +1,54 @@
+# Welcome to the Imaging Server Kit's documentation!
+
+The **Imaging Server Kit** is an open-source Python package for deploying image analysis algorithms as web services.
+
+- Run computations remotely, while client applications remain focused on visualization.
+- Connect to an algorithm server and run algorithms from [QuPath](https://github.com/Imaging-Server-Kit/qupath-extension-serverkit), [Napari](https://github.com/Imaging-Server-Kit/napari-serverkit), and Python.
+
+## Key Features
+
+- Turn standard Python functions into fully-featured image processing web servers with minimal effort.
+
+```python
+@algorithm_server({"image": ImageUI()})
+def segmentation_server(image):
+    segmentation = # your code here
+    return [(segmentation, {}, "mask")]
+```
+
+<!-- - Automatically generate UIs in Napari and QuPath to test your tools. -->
+
+## Supported image analysis tasks
+
+| Task              | Examples                        | Napari | QuPath |
+|-------------------|---------------------------------| ------ | ------ |
+| Segmentation     | [StarDist](https://github.com/Imaging-Server-Kit/serverkit-stardist), [CellPose](https://github.com/Imaging-Server-Kit/serverkit-cellpose), [Rembg](https://github.com/Imaging-Server-Kit/serverkit-rembg), [SAM-2](https://github.com/Imaging-Server-Kit/serverkit-sam2), [InstanSeg](https://github.com/Imaging-Server-Kit/serverkit-instanseg)               | ✅ | ✅ |
+| Object detection | [Spotiflow](https://github.com/Imaging-Server-Kit/serverkit-spotiflow), [LoG detector](https://github.com/Imaging-Server-Kit/serverkit-skimage-LoG)    | ✅ | ✅ |
+| Vector fields   | [Orientationpy](https://github.com/Imaging-Server-Kit/serverkit-orientationpy)                   | ✅ | ✅ |
+| Object tracking  | [Trackastra](https://github.com/Imaging-Server-Kit/serverkit-trackastra), [Trackpy](https://github.com/Imaging-Server-Kit/serverkit-trackpy)         | ✅ |  |
+| Image-to-Image  | [SPAM](https://github.com/Imaging-Server-Kit/serverkit-spam), [Noise2Void](https://github.com/Imaging-Server-Kit/serverkit-n2v)         | ✅ |  |
+| Text-to-Image   | [Stable Diffusion](https://github.com/Imaging-Server-Kit/serverkit-stable-diffusion)         | ✅ |  |
+| Image-to-Text   | [Image captioning](https://github.com/Imaging-Server-Kit/serverkit-blip-captioning)         | ✅ |  |
+| Classification   | [ResNet50](https://github.com/Imaging-Server-Kit/serverkit-resnet50)         | ✅ |  |
+
+A gallery of example implementations for commonly used algorithms is available in the [repository](https://github.com/Imaging-Server-Kit/imaging-server-kit/tree/main/examples).
+
+## Installation
+
+Install the `imaging-server-kit` package with `pip`:
+
+```
+pip install imaging-server-kit
+```
+
+or clone the project and install the development version:
+
+```
+git clone https://github.com/Imaging-Server-Kit/imaging-server-kit.git
+cd imaging-server-kit
+pip install -e .
+```
+
+## License
+
+This software is distributed under the terms of the [BSD-3](http://opensource.org/licenses/BSD-3-Clause) license.

imaging_server_kit-0.0.7/docs/sections/algorithm_server.md

@@ -0,0 +1,170 @@
+# Creating an algorithm server
+
+In this tutorial, we'll re-implement the `serverkit demo` example of an intensity threshold algorithm step-by-step. The working principles and concepts extend to any other algorithm.
+
+## Overview
+
+Implementing an algorithm server with the `imaging-server-kit` involves two main steps:
+
+- Wrapping the image processing logic as a Python function that returns a **list of data tuples**
+- Decorating the function with `@algorithm_server`
+
+Let's consider this Python function as an example:
+
+```python
+def threshold_algo_server(image: np.ndarray, threshold: float):
+    binary_mask = image > threshold
+    return binary_mask
+```
+
+This function applies an intensity threshold to an image represented as a Numpy array and returns it as a segmentation mask (also a Numpy array).
+
+To turn this function into to an algorithm server, we first need to modify the function to **make it return a list of data tuples**.
+
+## Make the function return a list of data tuples
+
+The function should return a list of tuples ("data tuples"). Each tuple represents one distinct output of the algorithm.
+
+Our threshold algorithm only has one output: the segmentation mask resulting from thresholding.
+
+```python
+def threshold_algo_server(image: np.ndarray, threshold: float):
+    binary_mask = image > threshold
+    return [(binary_mask, {}, "mask")]  # List of data tuples
+```
+
+The data tuples are inspired from Napari's [LayerDataTuple](https://napari.org/0.4.15/guides/magicgui.html?highlight=layerdatatuple) model. They include three elements:
+
+- The *first element* is the **data**, usually in the form of a Numpy array. The shape and interpretation of the axes depends on what the output represents (cf. table below).
+- The *second element* is optional **metadata** associated with the output, represented as a Python dictionary. It can be empty (`{}`). These metadata are used to affect how the output is displayed in client apps.
+- The *third element* is the output type: a string identifying what the output represents.
+
+| Output type       | Description                                                                                           |
+| ----------------- | ----------------------------------------------------------------------------------------------------- |
+| `"image"`         | An image or image-like data (incl. 3D and RGB) as a nD array.                                         |
+| `"mask"`          | A segmentation mask (2D, 3D) as integer nD array. Integers represent the **object class**.            |
+| `"instance_mask"` | A segmentation mask (2D, 3D) as integer nD array. Integers represent **object instances**.            |
+| `"points"`        | A collection of point coordinates (array of shape (N, 2) or (N, 3)).                                  |
+| `"boxes"`         | A collection of boxes (array of shape (N, 4) representing the top-left and bottom-right box corners). |
+| `"vectors"`       | Array of vectors in the Napari [Vectors](https://napari.org/stable/howtos/layers/vectors.html) format.|
+| `"tracks"`        | Array of tracks in the Napari [Tracks](https://napari.org/stable/howtos/layers/tracks.html) format.   |
+| `"class"`         | A class label (for image classification).                                                             |
+| `"text"`          | A string of text (for example, for image captioning).                                                 |
+
+The function can return an arbitrary number of outputs, following the pattern:
+
+```
+# Body of the function
+return [
+    (data1, {metadata1}, "type1"),  # First output
+    (data2, {metadata2}, "type2"),  # Second output
+    (...)
+]
+```
+
+```{admonition} Are there any other constraints on the Python function?
+The function parameters can only be **numpy arrays**, **numeric values** (`int`, `float`), **booleans** or **strings**.
+```
+
+## Decorate the function with `@algorithm_server`
+
+This serves several purposes:
+
+- It converts the python function to a FastAPI server with predefined routes (cf. [API Endpoints](api_endpoints)).
+- It enables the server to validate algorithm parameters when receiving requests.
+- Optional info about the algorithm server can be added to populate its `info` page.
+
+Below is our decorated threshold algorithm function:
+
+```python
+from imaging_server_kit import algorithm_server, ImageUI, FloatSpinBoxUI
+
+@algorithm_server(
+    algorithm_name="threshold",
+    parameters={
+        "image": ImageUI(),
+        "threshold": FloatSpinBoxUI(
+            default=0.5,
+            min=0.0,
+            max=1.0,
+            step=0.1,
+            title="Threshold",
+            description="Intensity threshold.",
+        ),
+    },
+)
+def threshold_algo_server(image: np.ndarray, threshold: float):
+    binary_mask = image > threshold
+    return [(binary_mask, {}, "mask")]
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(threshold_algo_server.app, host="0.0.0.0", port=8000)
+```
+
+You can check that running this file as a script will spin up a threshold algorithm server that you can connect to from Napari, QuPath, or Python, just like in the [Getting started](getting_started) guide.
+
+Most importantly, we have specified the `parameters` field of `@algorithm_server`. This enables parameters to be validated by the server before processing. Upon receiving requests with invalid algorithm parameters, the server will reply with a `403` error and an informative message is displayed to the user.
+
+The keys of the `parameters` dictionary should match the parameters of the Python function (in our example: `image` and `threshold`). The values are *parameter UI* elements. There is a UI element for each kind of parameters:
+
+| UI element           | Use case                                                                                                                         |
+| -------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `ImageUI`            | Input image. Validates array dimensionality (by default, accepts `2D` and `3D` arrays).                                          |
+| `MaskUI`             | Segmentation mask. Validates array dimensionality (by default, accepts `2D` and `3D` arrays).                                    |
+| `DropDownUI`         | A dropdown selector. `items` is used to specify a list of available choices.                                                     |
+| `FloatSpinBoxUI`     | Numeric parameter (floating point). Validates `min` and `max` values. `step` can be used to specify a suitable incremental step. |
+| `IntSpinBoxUI`       | Numeric parameter (integer). Validates `min` and `max` values. `step` can be used to specify a suitable incremental step.        |
+| `BoolUI`             | Boolean parameter, represented as a checkbox.                                                                                    |
+| `StringUI`           | String parameter.                                                                                                                |
+| `PointsUI`           | Points parameter.                                                                                                                |
+| `VectorsUI`          | Vectors parameter.                                                                                                               |
+| `ShapesUI`           | Shapes parameter.                                                                                                                |
+| `TracksUI`           | Tracks parameter.                                                                                                                |
+
+In our example, the input image array is well-represented by the `ImageUI` element, and the threshold parameter as a `FloatSpinBoxUI`. The parameter defaults and limits (min, max, step) are specified, as well as a title and description of the parameter, which will appear on the algorithm's `info` page.
+
+Moreover, the `@algorithm_server` decorator accepts a variety of optional parameters to enable downloading a sample image, linking to a project page, and providing information on the intended usage of the algorithm server. For details, take a look at the complete [demo example](https://github.com/Imaging-Server-Kit/imaging-server-kit/blob/main/src/imaging_server_kit/demo/threshold.py). The available fields include:
+
+| Key              | Description                                                                                                                      |
+| ---------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `algorithm_name` | A short name for the algorithm server, in URL-friendly format (no spaces or special characters)                                  |
+| `title`          | A name or complete title for the algorithm server.                                                                               |
+| `description`    | A brief description of the algorithm server.                                                                                     |
+| `used_for`       | A list of tags from: `Segmentation`, `Registration`, `Filtering`, `Tracking`, `Restoration`, `Points detection`, `Box detection` |
+| `tags`           | Tags used to categorize the algorithm server, for example `Deep learning`, `EPFL`, `Cell biology`, `Digital pathology`.          |
+| `project_url`    | A URL string to the project's homepage.                                                                                          |
+| `sample_images`  | A list of paths to sample images (`.tif`, `.png`, `.jpg`).                                                                       |
+
+If you provide sample images, the license terms under which the images are distributed should be respected. For example, for images under [CC-BY](https://creativecommons.org/licenses/by/2.0/deed.en) license, proper attribution should be included.
+
+## Starting from a template
+
+It is also possible to create a new algorithm server from a template. Specify an output directory and run the command:
+
+```
+serverkit new <output_directory>
+```
+
+Running this command will generate the following file structure in the selected output directory:
+
+```
+serverkit-project-slug
+├── sample_images               # Sample images
+│   ├──blobs.tif
+└── .gitignore
+└── docker-compose.yml          # For deployment with `docker compose up`
+└── Dockerfile
+└── main.py                     # Implementation of the algorithm server
+└── README.md
+└── requirements.txt
+```
+
+You'll be asked to provide:
+
+- **project_name**: The name of the algorithm or project (e.g. StarDist)
+- **project_slug**: A lowercase, URL-friendly name for your project (e.g. stardist)
+- **project_url**: A URL to the original project homepage
+- **python_version**: The Python version to use (default: `3.9`)
+
+After generating the project structure, you should edit the files to implement the functionality of your algorithm server. You'll have to edit the `main.py` file which implements the algorithm server, as well as the `requirements.txt`. If needed, consider editing the `Dockerfile` and `README.md` to match your use case.

imaging_server_kit-0.0.7/docs/sections/api_endpoints.md

@@ -0,0 +1,14 @@
+# API Endpoints
+
+When the server is running, an OpenAPI documentation of the endpoints is automatically generated on the `/docs` route (e.g. http://localhost:8000/docs).
+
+The algorithm servers implement a REST API with a common set of endpoints for processing and retreiving data. The main endpoints are listed in the table below.
+
+| Type | Endpoint                     | Description                                 |
+| ---- | ---------------------------- | ------------------------------------------- |
+| GET  | `/`                          | Algorithm index or info page                |
+| GET  | `/services`                  | List available algorithms                   |
+| GET  | `/<algorithm>/info`          | Algorithm info page                         |
+| POST | `/<algorithm>/process`       | Run the algorithm                           |
+| GET  | `/<algorithm>/parameters`    | Get algorithm parameters                    |
+| GET  | `/<algorithm>/sample_images` | Get samples images                          |

imaging_server_kit-0.0.7/docs/sections/authentication.md

@@ -0,0 +1,11 @@
+# Authentication
+
+We provide an `AuthenticatedAlgorithmServer` which is a drop-in replacement for `AlgorithmServer`. It extends the functionality of the base class by implementing a simple user model and token-based authentication for a server, based on [fastapi-users](https://github.com/fastapi-users/fastapi-users). Only authenticated users can access the `/process` route.
+
+```python
+from imaging_server_kit import AuthenticatedAlgorithmServer
+```
+
+```{note}
+This feature is still experimental.
+```

imaging_server_kit-0.0.7/docs/sections/client_apps.md

@@ -0,0 +1,30 @@
+# Client apps
+
+Once an algorithm server is running, you can connect to it and run algorithms from Python, Napari, and QuPath.
+
+## Python client
+
+Use a `Client` instance. For example:
+
+```python
+from imaging_server_kit import Client
+
+client = Client("http://localhost:8000")
+
+print(client.algorithms)
+# [`rembg`, `stardist`, `cellpose`]
+
+algo_output = client.run_algorithm(
+    algorithm="rembg",
+    image=(...),
+    rembg_model_name="silueta",
+)
+```
+
+# Napari plugin
+
+Install and use the [Napari Server Kit](https://github.com/Imaging-Server-Kit/napari-serverkit) plugin to connect to algorithm servers and run algorithms in Napari.
+
+# QuPath extension
+
+Install and use the [QuPath Extension Server Kit](https://github.com/Imaging-Server-Kit/qupath-extension-serverkit) to connect to algorithm servers and run algorithms from within QuPath.

imaging_server_kit-0.0.7/docs/sections/docker.md

@@ -0,0 +1,38 @@
+## Using Docker
+
+The Imaging Server Kit provides an **algorithm hub** to serve multiple algorithms in separate docker containers.
+
+To set up an algorithm hub, the easiest is to use a `docker-compose.yml` file.
+
+Here is the [example from the respository](https://github.com/Imaging-Server-Kit/imaging-server-kit/blob/main/examples/servers/docker-compose.yml):
+
+```
+services:
+  algorithm_hub:
+    build: ../..
+    ports:
+      - "8000:8000"
+    command: python3 start_algorithm_hub.py
+  cellpose:
+    build: ./serverkit-cellpose
+    depends_on:
+      - algorithm_hub
+  stardist:
+    build: ./serverkit-stardist
+    depends_on:
+      - algorithm_hub
+```
+
+Build the algorithm hub server with
+
+```sh
+docker compose build
+```
+
+Start the algorithm hub server with
+
+```sh
+docker compose up
+```
+
+The server will be listening on http://localhost:8000. It behaves exactly like a [Multi-algorithm server](multi_algo_server), however each algorithm runs in a separate docker container.

imaging_server_kit-0.0.7/docs/sections/examples.md

@@ -0,0 +1,12 @@
+## Examples
+
+Take a look at the algorithm server examples from the repository, which include
+
+  - [StarDist](https://github.com/Imaging-Server-Kit/imaging-server-kit/tree/main/examples/servers/serverkit-stardist): Object detection with star-convex shapes.
+  - [CellPose](https://github.com/Imaging-Server-Kit/imaging-server-kit/tree/main/examples/servers/serverkit-cellpose): A generalist algorithm for cellular segmentation.
+  - [Rembg](https://github.com/Imaging-Server-Kit/imaging-server-kit/tree/main/examples/servers/serverkit-rembg): A tool to remove images background.
+  - [Orientationpy](https://github.com/Imaging-Server-Kit/imaging-server-kit/tree/main/examples/servers/serverkit-orientationpy): Measurement of greyscale orientations.
+  - [LoG detector](https://github.com/Imaging-Server-Kit/imaging-server-kit/tree/main/examples/servers/serverkit-skimage-log): Laplacian of Gaussian filter.
+  - [Trackpy](https://github.com/Imaging-Server-Kit/imaging-server-kit/tree/main/examples/servers/serverkit-trackpy): Object tracking.
+
+You can also take a look at the [complete list of examples](https://github.com/orgs/Imaging-Server-Kit/repositories).

imaging_server_kit-0.0.7/docs/sections/getting_started.md

@@ -0,0 +1,65 @@
+# Getting started
+
+## Run your first algorithm server
+
+With the `imaging-server-kit` package installed, run:
+
+```
+serverkit demo
+```
+
+This will start a demo web server for a simple intensity threshold algorithm.
+
+The server will be running on http://localhost:8000. Open your web browser and navigate to this page to check that the server is running. You should see a web page displaying information about the running threshold algorithm server.
+
+![screenshot](../assets/screenshot_running_server.png)
+
+## Usage from Napari
+
+Now that the server is running, you can interact with it from different client apps. For usage in [Napari](https://github.com/Imaging-Server-Kit/napari-serverkit), you need to install napari and the `napari-serverkit` plugin.
+
+You can install the `napari-serverkit` plugin with `pip`:
+
+```sh
+pip install napari-serverkit
+```
+
+Then, start Napari with the plugin:
+
+```
+napari -w napari-serverkit
+```
+
+or open the plugin from `Plugins > Server Kit (Napari Server Kit)` in Napari.
+
+With your server still running on http://localhost:8000, you should be able to connect to it, load a sample image, run the threshold algorithm on it, and have the results displayed in the viewer.
+
+![screenshot](../assets/screenshot_napari_threshold.png)
+
+## Usage from QuPath
+
+You can also interact with the algorithm server via QuPath. To try it out, you need to install the [qupath-extension-serverkit](https://github.com/Imaging-Server-Kit/qupath-extension-serverkit).
+
+## Usage from Python
+
+It is also possible to connect to an algorithm server and run computation from Python directly:
+
+```python
+from imaging_server_kit import Client
+
+# Connect to the server
+client = Client("http://localhost:8000")
+
+# run_algorithm returns a list of data tuples
+results = client.run_algorithm(
+    algorithm="intensity-threshold", 
+    image=image, 
+    threshold=0.5,
+)
+
+# Unpack the first result data tuple
+mask, result_metadata, result_type = results[0]
+
+# Segmentaiton mask
+print(mask.shape)
+```