Merge pull request #5 from Imaging-Server-Kit/hidableui

Hidableui

Author: MalloryWittwer

src/imaging_server_kit/core/algorithm.py

@@ -241,6 +241,7 @@ def __init__(
         project_url: str = "https://github.com/Imaging-Server-Kit/imaging-server-kit",
         metadata_file: str = "metadata.yaml",
         samples: Optional[List[Dict[str, Any]]] = None,
+        tileable: bool = True,
     ):
         # Initialize mutables
         if tags is None:
@@ -261,6 +262,9 @@ def __init__(
 
         # Samples
         self.samples = samples
+        
+        # Tileability
+        self.tileable = tileable
 
         # Resolve the Pydantic parameters model
         self.parameters_model = _parse_pydantic_params_schema(
@@ -277,7 +281,7 @@ def __init__(
     @property
     def algorithms(self) -> Iterable[str]:
         return self._algorithms
-
+    
     @algorithms.setter
     def algorithms(self, algorithms: Iterable[str]):
         self._algorithms = algorithms
@@ -340,14 +344,17 @@ def get_sample(self, algorithm=None, idx: int = 0) -> Optional[Results]:
         sample_results = Results()
         for param_name, param_value in resolved_params.items():
             kind = algo_params_defs.get(param_name).get("param_type")
-            if (kind == "image") & (not isinstance(param_value, np.ndarray)):
+            if (kind in ["image", "mask"]) & (not isinstance(param_value, np.ndarray)):
                 param_value = skimage.io.imread(param_value)
             sample_results.create(kind, param_value, param_name)
         return sample_results
 
     def get_n_samples(self, algorithm=None):
         return len(self.samples)
 
+    def is_tileable(self, algorithm=None):
+        return self.tileable
+    
     @validate_algorithm
     def get_signature_params(self, algorithm=None) -> List[str]:
         """List parameter names of the algo run function."""
@@ -413,7 +420,8 @@ def algorithm(
     project_url: str = "https://github.com/Imaging-Server-Kit/imaging-server-kit",
     metadata_file: str = "metadata.yaml",
     samples: Optional[List[Dict[str, Any]]] = None,
-):
+    tileable: bool = True,
+) -> Algorithm:
     """Convert a Python function into an algorithm instance (sk.Algorithm).
 
     Parameters
@@ -426,7 +434,8 @@ def algorithm(
     project_url: A link to a related, or the original project (gets displayed on the algo doc page).
     metadata_file: A path to a metadata.yaml file with algorithm metadata.
     samples: A list of sample parameters for the algorithm, each represented as a dictionary mapping parameter_name to example_value. Sample images can be a Numpy array, a URL, or a local path to a file readable by `skimag.io.imread`.
-
+    tileable: Whether to allow running the algorithm tile-by-tile. Can be set to False to explicitely disable that functionality.
+    
     Returns
     -------
     An algorithm instance (sk.Algorithm).
@@ -442,6 +451,7 @@ def _decorate(run_aglorithm_func: Callable):
             project_url=project_url,
             metadata_file=metadata_file,
             samples=samples,
+            tileable=tileable,
         )
 
     if func is not None and callable(func):

src/imaging_server_kit/core/app.py

@@ -252,6 +252,17 @@ def get_n_samples(algorithm_name: str):
             algorithm = find_algorithm(algorithm_name, self.algorithms_dict)
             n_samples = algorithm.get_n_samples(algorithm=algorithm_name)
             return {"n_samples": n_samples}
+        
+        @self.app.get(
+            "/{algorithm_name}/tileable",
+            response_model=dict,
+            summary="Whether the algorithm is tileable.",
+            tags=["algorithm"],
+        )
+        def is_tileable(algorithm_name: str):
+            algorithm = find_algorithm(algorithm_name, self.algorithms_dict)
+            tileable = algorithm.is_tileable(algorithm=algorithm_name)
+            return {"tileable": tileable}
 
         @self.app.get("/{algorithm_name}/signature", tags=["algorithm"])
         def get_signature(algorithm_name: str):

src/imaging_server_kit/core/client.py

@@ -103,6 +103,13 @@ def get_n_samples(self, algorithm=None) -> int:
         json_response = self._access_algo_get_endpoint(endpoint)
         n_samples = json_response.get("n_samples")
         return n_samples
+    
+    @validate_algorithm
+    def is_tileable(self, algorithm=None) -> bool:
+        endpoint = f"{self.server_url}/{algorithm}/tileable"
+        json_response = self._access_algo_get_endpoint(endpoint)
+        is_tileable = json_response.get("tileable")
+        return is_tileable
 
     @validate_algorithm
     def get_signature_params(self, algorithm: str) -> List[str]:

src/imaging_server_kit/core/errors.py

@@ -1,4 +1,5 @@
 import importlib.util
+from typing import Optional
 
 class AlgorithmNotFoundError(Exception):
     """Exception raised when a specified algorithm is not found."""
@@ -83,10 +84,12 @@ class AlgorithmRuntimeError(Exception):
     def __init__(
         self,
         algorithm: str,
-        error: Exception,
+        error: Optional[Exception] = None,
         message="Algorithm did not run successfully. ",
     ):
-        self.message = message + f"{algorithm=}, Error: {error}"
+        self.message = message + f"{algorithm=}"
+        if error is not None:
+            self.message = self.message + ", Error: {error}"
         super().__init__(self.message)
 
 

src/imaging_server_kit/core/multialgo.py

@@ -23,7 +23,7 @@ def algorithms_dict(self) -> Dict[str, Algorithm]:
     @property
     def algorithms(self) -> List[str]:
         return list(self.algorithms_dict.keys())
-
+    
     @validate_algorithm
     def info(self, algorithm: str):
         return self.algorithms_dict[algorithm].info(algorithm)
@@ -39,6 +39,10 @@ def get_sample(self, algorithm: str, idx: int = 0) -> Optional[Results]:
     @validate_algorithm
     def get_n_samples(self, algorithm: str) -> int:
         return self.algorithms_dict[algorithm].get_n_samples(algorithm)
+    
+    @validate_algorithm
+    def is_tileable(self, algorithm: str) -> bool:
+        return self.algorithms_dict[algorithm].is_tileable(algorithm)
 
     @validate_algorithm
     def get_signature_params(self, algorithm: str) -> List[str]:

src/imaging_server_kit/core/runner.py

@@ -83,6 +83,9 @@ def get_sample(self, algorithm: str, idx: int = 0) -> LayerStackBase: ...
 
     @abstractmethod
     def get_n_samples(self, algorithm: str) -> int: ...
+    
+    @abstractmethod
+    def is_tileable(self, algorithm: str) -> bool: ...
 
     @abstractmethod
     def get_signature_params(self, algorithm: str) -> List[str]: ...
@@ -175,6 +178,11 @@ def run(
         stream = self._is_stream(algorithm)
 
         if tiled:
+            if self.tileable is False:
+                raise AlgorithmRuntimeError(
+                    algorithm,
+                    message="Algorithm cannot be run in tiled mode.",
+                )
             if stream:
                 raise AlgorithmStreamError(
                     algorithm,

src/imaging_server_kit/demo/examples.py

@@ -517,3 +517,39 @@ def project(image, method, axis: str):
         name=f"Projection",
         meta={"contrast_limits": [proj.min(), proj.max()], "colormap": "viridis"},
     )
+
+
+## Conway's game of life (inspired by: https://www.geeksforgeeks.org/dsa/conways-game-life-python-implementation/)
+@sk.algorithm(
+    name="Game of Life",
+    description="Conway's game of life.",
+    project_url="https://www.geeksforgeeks.org/dsa/conways-game-life-python-implementation/",
+)
+def conway_algo(max_iter=200, delay=0.1):
+    min_val = 0
+    max_val = 255
+    
+    N=100  # Size of the grid
+
+    def update(grid: np.ndarray, N: int) -> np.ndarray:
+        newGrid = grid.copy()
+        for i in range(N):
+            for j in range(N):
+                total = int((grid[i, (j-1)%N] + grid[i, (j+1)%N] + 
+                            grid[(i-1)%N, j] + grid[(i+1)%N, j] + 
+                            grid[(i-1)%N, (j-1)%N] + grid[(i-1)%N, (j+1)%N] + 
+                            grid[(i+1)%N, (j-1)%N] + grid[(i+1)%N, (j+1)%N]))
+                total = total / max_val
+                if grid[i, j] == max_val:
+                    if (total < 2) or (total > 3):
+                        newGrid[i, j] = min_val
+                else:
+                    if total == 3:
+                        newGrid[i, j] = max_val
+        return newGrid
+
+    grid = np.random.choice([min_val, max_val], N*N, p=[0.5, 0.5]).reshape(N, N)
+    for k in range(max_iter):
+        grid = update(grid, N)
+        time.sleep(delay)
+        yield sk.Mask(grid), f"Iterations: {k} / {max_iter}"

src/imaging_server_kit/types/_mask.py

@@ -150,7 +150,7 @@ def features2instance_mask_3d(features, image_shape):
     _, ry, rx = image_shape
     for feature in features:
         feature_xy_coordinates = np.array(feature["geometry"]["coordinates"])
-        feature_coordinates = feature_coordinates[0, :, :]  # Remove an extra dimension
+        feature_xy_coordinates = feature_xy_coordinates[0, :, :]  # Remove an extra dimension
         feature_xy_coordinates = feature_xy_coordinates[:, ::-1]  # Invert XY
         feature_mask = polygon2mask((ry, rx), feature_xy_coordinates)
         feature_z_idx = feature["properties"]["z_idx"]