Interpret offsets for MagDataset.get_view as absolute values (#237)

* interpret the offset parameter for MagDataset.get_view as an absolute value

* fix calculation for the size of the new view and add tests

* imporve error messages for View creation

Author: rschwanhold

tests/test_dataset.py

@@ -1204,3 +1204,75 @@ def test_changing_layer_bounding_box():
     new_data = mag.read(new_bbox_size)
     assert new_data.shape == (1, 255, 255, 10)
     assert np.array_equal(original_data[:, 10:, 10:, :], new_data)
+
+
+def test_view_offsets():
+    delete_dir("./testoutput/wk_offset_tests")
+
+    ds = WKDataset.create("./testoutput/wk_offset_tests", scale=(1, 1, 1))
+    mag = ds.add_layer("color", "color").add_mag("1")
+
+    # The dataset is new -> no data has been written.
+    # Therefore, the size of the bounding box in the properties.json is (0, 0, 0)
+
+    # Creating this view works because the size is set to (0, 0, 0)
+    # However, in practice such a view would not make sense because 'is_bounded' is set to 'True'
+    wk_view = ds.get_view("color", "1", size=(0, 0, 0), is_bounded=True)
+    assert wk_view.global_offset == tuple((0, 0, 0))
+    assert wk_view.size == tuple((0, 0, 0))
+
+    try:
+        # Creating this view does not work because the size (16, 16, 16) would exceed the boundingbox from the properties.json
+        ds.get_view("color", "1", size=(16, 16, 16), is_bounded=True)
+        raise Exception(expected_error_msg)
+    except AssertionError:
+        pass
+
+    # This works because 'is_bounded' is set to 'False'
+    # Therefore, the bounding box of the view can be larger than the bounding box from the properties.json
+    wk_view = ds.get_view("color", "1", size=(16, 16, 16), is_bounded=False)
+    assert wk_view.global_offset == tuple((0, 0, 0))
+    assert wk_view.size == tuple((16, 16, 16))
+
+    np.random.seed(1234)
+    write_data = (np.random.rand(100, 200, 300) * 255).astype(np.uint8)
+    mag.write(write_data, offset=(10, 20, 30))
+
+    # The bounding box of the dataset was updated according to the written data
+    # Therefore, creating a view with a size of (16, 16, 16) is now allowed
+    wk_view = ds.get_view("color", "1", size=(16, 16, 16), is_bounded=True)
+    assert wk_view.global_offset == tuple((10, 20, 30))
+    assert wk_view.size == tuple((16, 16, 16))
+
+    try:
+        # Creating this view does not work because the offset (0, 0, 0) would be outside of the boundingbox from the properties.json
+        ds.get_view("color", "1", size=(16, 16, 16), offset=(0, 0, 0), is_bounded=True)
+        raise Exception(expected_error_msg)
+    except AssertionError:
+        pass
+
+    # Creating this view works, even though the offset (0, 0, 0) is outside of the boundingbox from the properties.json, because 'is_bounded' is set to 'False'
+    wk_view = ds.get_view(
+        "color", "1", size=(16, 16, 16), offset=(0, 0, 0), is_bounded=False
+    )
+    assert wk_view.global_offset == tuple((0, 0, 0))
+    assert wk_view.size == tuple((16, 16, 16))
+
+    # Creating this view works because the bounding box of the view is inside the bounding box from the properties.json
+    wk_view = ds.get_view(
+        "color", "1", size=(16, 16, 16), offset=(20, 30, 40), is_bounded=True
+    )
+    assert wk_view.global_offset == tuple((20, 30, 40))
+    assert wk_view.size == tuple((16, 16, 16))
+
+    # Creating this subview works because the subview is completely inside the 'wk_view'
+    sub_view = wk_view.get_view(size=(8, 8, 8), relative_offset=(8, 8, 8))
+    assert sub_view.global_offset == tuple((28, 38, 48))
+    assert sub_view.size == tuple((8, 8, 8))
+
+    try:
+        # Creating this subview does not work because it is not completely inside the 'wk_view'
+        wk_view.get_view(size=(10, 10, 10), relative_offset=(8, 8, 8))
+        raise Exception(expected_error_msg)
+    except AssertionError:
+        pass

wkcuber/api/Dataset.py

@@ -129,9 +129,7 @@ def delete_layer(self, layer_name):
         # delete files on disk
         rmtree(join(self.path, layer_name))
 
-    def get_view(
-        self, layer_name, mag, size, offset=(0, 0, 0), is_bounded=True
-    ) -> View:
+    def get_view(self, layer_name, mag, size, offset=None, is_bounded=True) -> View:
         layer = self.get_layer(layer_name)
         mag_ds = layer.get_mag(mag)
 

wkcuber/api/MagDataset.py

@@ -15,7 +15,7 @@ def __init__(self, layer, name):
         self.name = name
         self.header = self.get_header()
 
-        self.view = self.get_view(is_bounded=False)
+        self.view = self.get_view(offset=(0, 0, 0), is_bounded=False)
 
     def open(self):
         self.view.open()
@@ -68,30 +68,40 @@ def get_view(self, size=None, offset=None, is_bounded=True):
             self.layer.name
         ].get_bounding_box_size()
 
+        offset_in_properties = self.layer.dataset.properties.data_layers[
+            self.layer.name
+        ].get_bounding_box_offset()
+
+        if offset_in_properties == (-1, -1, -1):
+            offset_in_properties = (0, 0, 0)
+
         if offset is None:
-            offset = (0, 0, 0)
+            offset = offset_in_properties
 
         if size is None:
-            size = size_in_properties
-
-        # assert that the parameter size is valid
-        for s1, s2, off in zip(size_in_properties, size, offset):
-            if s2 + off > s1 and is_bounded:
-                raise AssertionError(
-                    f"The combination of the passed parameter 'size' {size} and {offset} are not compatible with the "
-                    f"size ({size_in_properties}) from the properties.json."
-                )
+            size = np.array(size_in_properties) - (
+                np.array(offset) - np.array(offset_in_properties)
+            )
+
+        # assert that the parameters size and offset are valid
+        if is_bounded:
+            for off_prop, off in zip(offset_in_properties, offset):
+                if off < off_prop:
+                    raise AssertionError(
+                        f"The passed parameter 'offset' {offset} is outside the bounding box from the properties.json. "
+                        f"Use is_bounded=False if you intend to write outside out the existing bounding box."
+                    )
+            for s1, s2, off in zip(size_in_properties, size, offset):
+                if s2 + off > s1:
+                    raise AssertionError(
+                        f"The combination of the passed parameter 'size' {size} and 'offset' {offset} are not compatible with the "
+                        f"size ({size_in_properties}) from the properties.json.  "
+                        f"Use is_bounded=False if you intend to write outside out the existing bounding box."
+                    )
 
         mag_file_path = join(self.layer.dataset.path, self.layer.name, self.name)
-        offset_in_properties = self.layer.dataset.properties.data_layers[
-            self.layer.name
-        ].get_bounding_box_offset()
-        dataset_offset = (
-            (0, 0, 0) if offset_in_properties == (-1, -1, -1) else offset_in_properties
-        )
-        global_offset = np.array(dataset_offset) + np.array(offset)
         return self._get_view_type()(
-            mag_file_path, self.header, size, global_offset, is_bounded
+            mag_file_path, self.header, size, offset, is_bounded
         )
 
     def _get_view_type(self):

wkcuber/api/View.py

@@ -36,14 +36,16 @@ def close(self):
             self.dataset = None
             self._is_opened = False
 
-    def write(self, data, offset=(0, 0, 0)):
+    def write(self, data, relative_offset=(0, 0, 0)):
         was_opened = self._is_opened
         # assert the size of the parameter data is not in conflict with the attribute self.size
-        assert_non_negative_offset(offset)
-        self.assert_bounds(offset, data.shape[-3:])
+        assert_non_negative_offset(relative_offset)
+        self.assert_bounds(relative_offset, data.shape[-3:])
 
         # calculate the absolute offset
-        absolute_offset = tuple(sum(x) for x in zip(self.global_offset, offset))
+        absolute_offset = tuple(
+            sum(x) for x in zip(self.global_offset, relative_offset)
+        )
 
         if not was_opened:
             self.open()
@@ -73,14 +75,14 @@ def read(self, size=None, offset=(0, 0, 0)) -> np.array:
 
         return data
 
-    def get_view(self, size, offset=(0, 0, 0)):
-        self.assert_bounds(offset, size)
-        view_offset = self.global_offset + np.array(offset)
+    def get_view(self, size, relative_offset=(0, 0, 0)):
+        self.assert_bounds(relative_offset, size)
+        view_offset = self.global_offset + np.array(relative_offset)
         return type(self)(
             self.path,
             self.header,
             size=size,
-            global_offset=view_offset,
+            global_offset=tuple(view_offset),
             is_bounded=self.is_bounded,
         )
 
@@ -107,7 +109,7 @@ def for_each_chunk(self, work_on_chunk, job_args_per_chunk, chunk_size, executor
             relative_offset = np.array(chunk.topleft) - np.array(self.global_offset)
             job_args.append(
                 (
-                    self.get_view(size=chunk.size, offset=relative_offset),
+                    self.get_view(size=chunk.size, relative_offset=relative_offset),
                     job_args_per_chunk,
                 )
             )