Reading nd datasets

webknossos/script_collection/reading_nd_data.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+
+import pims
+
+import webknossos as wk
+
+
+def main(input_path: Path, output_path: Path) -> None:
+    """Imports a dataset with more than 3 dimensions."""
+
+    wk.Dataset.from_images(
+        input_path, output_path, voxel_size=(10, 10, 10), data_format="zarr3"
+    )
+    # reader = pims.Bioformats(input_path)
+    # print(reader.sizes)
+    # print(isinstance(reader, pims.FramesSequenceND))
+
+
+if __name__ == "__main__":
+    input_path = Path(".") / "webknossos" / "testdata" / "4D"  # / "4D-series.ome.tif"
+    output_path = Path(".") / "webknossos" / "testoutput" / "4D"
+    main(input_path, output_path)

webknossos/webknossos/dataset/_utils/pims_images.py

@@ -142,6 +142,7 @@ def __init__(
             self.dtype = images.dtype
 
             if isinstance(images, pims.FramesSequenceND):
+                # TODO: assertion that phrohibites nd data
                 assert all(
                     axis in "xyzct" for axis in images.axes
                 ), f"Found unknown axes {set(images.axes) - set('xyzct')}"

webknossos/webknossos/dataset/dataset.py

@@ -1235,6 +1235,7 @@ def add_layer_from_images(
                 z_end = min(z_start + batch_size, pims_images.expected_shape.z)
                 # return shapes and set to union when using --pad
                 args.append((z_start, z_end))
+            print(args)
             with warnings.catch_warnings():
                 # Block alignmnent within the dataset should not be a problem, since shard-wise chunking is enforced.
                 # However, dataset borders might change between different parallelized writes, when sizes differ.

webknossos/webknossos/geometry/bounding_box.py

@@ -7,13 +7,14 @@
 import numpy as np
 
 from .mag import Mag
+from .nd_bounding_box import NDBoundingBox
 from .vec3_int import Vec3Int, Vec3IntLike
 
 _DEFAULT_BBOX_NAME = "Unnamed Bounding Box"
 
 
 @attr.frozen
-class BoundingBox:
+class BoundingBox(NDBoundingBox):
     """
     This class is used to represent an axis-aligned cuboid in 3D.
     The top-left coordinate is inclusive and the bottom-right coordinate is exclusive.
@@ -32,6 +33,7 @@ class BoundingBox:
 
     topleft: Vec3Int = attr.field(converter=Vec3Int)
     size: Vec3Int = attr.field(converter=Vec3Int)
+    axes: Tuple[str, str, str] = attr.field(default=("x", "y", "z"))
     bottomright: Vec3Int = attr.field(init=False)
     name: Optional[str] = _DEFAULT_BBOX_NAME
     is_visible: bool = True
@@ -51,61 +53,38 @@ def __attrs_post_init__(self) -> None:
         # it is needed.
         object.__setattr__(self, "bottomright", self.topleft + self.size)
 
-    def with_topleft(self, new_topleft: Vec3IntLike) -> "BoundingBox":
-        return attr.evolve(self, topleft=new_topleft)
+    def with_additional_axis(self, name: str, extent: Tuple[int, int]) -> "NDBoundingBox":
+        assert (name not in ["x", "y", "z"]), f"The name '{name}' of the axis is already taken."
+        new_topleft = min(extent)
+        new_size = max(extent) - new_topleft
 
-    def with_size(self, new_size: Vec3IntLike) -> "BoundingBox":
-        return attr.evolve(self, size=new_size)
-
-    def with_name(self, name: Optional[str]) -> "BoundingBox":
-        return attr.evolve(self, name=name)
-
-    def with_is_visible(self, is_visible: bool) -> "BoundingBox":
-        return attr.evolve(self, is_visible=is_visible)
-
-    def with_color(
-        self, color: Optional[Tuple[float, float, float, float]]
-    ) -> "BoundingBox":
-        return attr.evolve(self, color=color)
+        return NDBoundingBox(
+            topleft=(*self.topleft, new_topleft),
+            size=(*self.size, new_size),
+            axes=(*self.axes, name)
+        )
 
     def with_bounds_x(
         self, new_topleft_x: Optional[int] = None, new_size_x: Optional[int] = None
     ) -> "BoundingBox":
         """Returns a copy of the bounding box with topleft.x optionally replaced and size.x optionally replaced."""
 
-        new_topleft = (
-            self.topleft.with_x(new_topleft_x)
-            if new_topleft_x is not None
-            else self.topleft
-        )
-        new_size = self.size.with_x(new_size_x) if new_size_x is not None else self.size
-        return attr.evolve(self, topleft=new_topleft, size=new_size)
+        return cast(BoundingBox, self.with_bounds("x", new_topleft_x, new_size_x))
 
     def with_bounds_y(
         self, new_topleft_y: Optional[int] = None, new_size_y: Optional[int] = None
     ) -> "BoundingBox":
         """Returns a copy of the bounding box with topleft.y optionally replaced and size.y optionally replaced."""
 
-        new_topleft = (
-            self.topleft.with_y(new_topleft_y)
-            if new_topleft_y is not None
-            else self.topleft
-        )
-        new_size = self.size.with_y(new_size_y) if new_size_y is not None else self.size
-        return attr.evolve(self, topleft=new_topleft, size=new_size)
+        return cast(BoundingBox, self.with_bounds("y", new_topleft_y, new_size_y))
 
     def with_bounds_z(
         self, new_topleft_z: Optional[int] = None, new_size_z: Optional[int] = None
     ) -> "BoundingBox":
         """Returns a copy of the bounding box with topleft.z optionally replaced and size.z optionally replaced."""
 
-        new_topleft = (
-            self.topleft.with_z(new_topleft_z)
-            if new_topleft_z is not None
-            else self.topleft
-        )
-        new_size = self.size.with_z(new_size_z) if new_size_z is not None else self.size
-        return attr.evolve(self, topleft=new_topleft, size=new_size)
+        return cast(BoundingBox, self.with_bounds("z", new_topleft_z, new_size_z))
+
 
     @classmethod
     def from_wkw_dict(cls, bbox: Dict) -> "BoundingBox":
@@ -231,18 +210,7 @@ def to_csv(self) -> str:
         return ",".join(map(str, self.to_tuple6()))
 
     def __repr__(self) -> str:
-        return "BoundingBox(topleft={}, size={})".format(
-            str(tuple(self.topleft)), str(tuple(self.size))
-        )
-
-    def __str__(self) -> str:
-        return self.__repr__()
-
-    def __eq__(self, other: object) -> bool:
-        if isinstance(other, BoundingBox):
-            return self.topleft == other.topleft and self.size == other.size
-        else:
-            raise NotImplementedError()
+        return f"BoundingBox(topleft={self.topleft.to_tuple()}, size={self.size.to_tuple()})"
 
     def padded_with_margins(
         self, margins_left: Vec3IntLike, margins_right: Optional[Vec3IntLike] = None
@@ -427,9 +395,6 @@ def chunk(
                 ):
                     yield BoundingBox([x, y, z], chunk_shape).intersected_with(self)
 
-    def volume(self) -> int:
-        return self.size.prod()
-
     def slice_array(self, array: np.ndarray) -> np.ndarray:
         return array[
             self.topleft.x : self.bottomright.x,