Merge remote-tracking branch 'origin/master' into renerichter-rl

the-lay · the-lay · Dec 14, 2021 · Sep 27, 2021 · Sep 29, 2021 · Nov 8, 2021
commit 6db742e504b0f5b4e5fb95567212da37b0f5df09
diff --git a/tiler/merger.py b/tiler/merger.py
@@ -56,11 +56,8 @@ class Merger:
         (Ronneberger et al. 2015, U-Net paper)
     """
 
-    def __init__(self,
-                 tiler: Tiler,
-                 window: Union[None, str, np.ndarray] = None,
-                 logits: int = 0,
-                 atol: float = 1e-10):
+    def __init__(
+        self, tiler: Tiler, window: Union[None, str, np.ndarray] = None, logits: int = 0, atol: float = 1e-10):
         """Merger precomputes everything for merging together tiles created by given Tiler.
 
         TODO:
@@ -173,7 +170,8 @@ def set_window(self, window: Union[None, str, np.ndarray] = None) -> None:
             self.window = window
         else:
             raise ValueError(
-                f'Unsupported type for window function ({type(window)}), expected str or np.ndarray.')
+                f"Unsupported type for window function ({type(window)}), expected str or np.ndarray."
+            )
 
     def reset(self) -> None:
         """Reset data and normalization buffers.
@@ -215,8 +213,11 @@ def add(self, tile_id: int, data: np.ndarray) -> None:
             )
 
         data_shape = np.array(data.shape)
-        expected_tile_shape = ((self.logits, ) + tuple(self.tiler.tile_shape)
-                               ) if self.logits > 0 else tuple(self.tiler.tile_shape)
+        expected_tile_shape = (
+            ((self.logits,) + tuple(self.tiler.tile_shape))
+            if self.logits > 0
+            else tuple(self.tiler.tile_shape)
+        )
 
         if self.tiler.mode != "irregular":
             if not np.all(np.equal(data_shape, expected_tile_shape)):
@@ -243,8 +244,9 @@ def add(self, tile_id: int, data: np.ndarray) -> None:
 
         # TODO check for self.data and data dtypes mismatch?
         if self.logits > 0:
-            self.data[tuple([slice(None, None, None)] + sl)
-                      ] += (data * self.window[tuple(win_sl[1:])])
+            self.data[tuple([slice(None, None, None)] + sl)] += (
+                data * self.window[tuple(win_sl[1:])]
+            )
             self.weights_sum[tuple(sl)] += self.window[tuple(win_sl[1:])]
         else:
             self.data[tuple(sl)] += data * self.window[tuple(win_sl)]
@@ -269,15 +271,19 @@ def add_batch(self, batch_id: int, batch_size: int, data: np.ndarray) -> None:
 
         if batch_id < 0 or batch_id >= n_batches:
             raise IndexError(
-                f'Out of bounds. There are {n_batches} batches of {batch_size}, starting from index 0.')
+                f"Out of bounds. There are {n_batches} batches of {batch_size}, starting from index 0."
+            )
 
         # add each tile in a batch with computed tile_id
-        for data_i, tile_i in enumerate(range(batch_id * batch_size,
-                                              min((batch_id + 1) * batch_size, len(self.tiler)))):
+        for data_i, tile_i in enumerate(
+            range(
+                batch_id * batch_size, min((batch_id + 1) * batch_size, len(self.tiler))
+            )
+        ):
             self.add(tile_i, data[data_i])
 
     def norm_by_weights(self, data: np.ndarray, weights: np.ndarray, atol: float = 1e-10, in_place: bool = True) -> np.ndarray:
-        """Normalised applied weights such that sum guarantees approx. 1. 
+        """Normalised applied weights such that sum guarantees approx. 1.
 
         Parameters
         ----------

diff --git a/tiler/tiler.py b/tiler/tiler.py
@@ -28,14 +28,16 @@ class Tiler:
         The first values are used to pad the end and the end values are used to pad the beginning.
     """
 
-    def __init__(self,
-                 data_shape: Union[Tuple, List],
-                 tile_shape: Union[Tuple, List],
-                 overlap: Union[int, float, Tuple, List] = 0,
-                 channel_dimension: Optional[int] = None,
-                 mode: str = 'constant',
-                 constant_value: float = 0.0,
-                 get_padding: bool = False):
+    def __init__(
+        self,
+        data_shape: Union[Tuple, List],
+        tile_shape: Union[Tuple, List],
+        overlap: Union[int, float, Tuple, List] = 0,
+        channel_dimension: Optional[int] = None,
+        mode: str = "constant",
+        constant_value: float = 0.0,
+        get_padding: bool = False
+    ):
         """Tiler class precomputes everything for tiling with specified parameters, without actually slicing data.
         You can access tiles individually with `Tiler.get_tile()` or with an iterator, both individually and in batches,
         with `Tiler.iterate()` (or the alias `Tiler.__call__()`).
@@ -126,11 +128,13 @@ def __init__(self,
                 self._tile_overlap[self.channel_dimension] = 0
 
         elif isinstance(self.overlap, int):
-            tile_shape_without_channel = self.tile_shape[np.arange(
-                self._n_dim) != self.channel_dimension]
+            tile_shape_without_channel = self.tile_shape[
+                np.arange(self._n_dim) != self.channel_dimension
+            ]
             if self.overlap < 0 or np.any(self.overlap >= tile_shape_without_channel):
                 raise ValueError(
-                    f'Integer overlap must be in range of 0 to {np.max(tile_shape_without_channel)}')
+                    f"Integer overlap must be in range of 0 to {np.max(tile_shape_without_channel)}"
+                )
 
             self._tile_overlap: np.ndarray = np.array(
                 [self.overlap for _ in self.tile_shape]
@@ -151,13 +155,16 @@ def __init__(self,
                 "Unsupported overlap mode (not float, int, list or tuple)."
             )
 
-        self._tile_step: np.ndarray = (
-            self.tile_shape - self._tile_overlap).astype(int)  # tile step
+        self._tile_step: np.ndarray = (self.tile_shape - self._tile_overlap).astype(
+            int
+        )  # tile step
 
         # Calculate mosaic (collection of tiles) shape
-        div, mod = np.divmod([self.data_shape[d] - self._tile_overlap[d]
-                              for d in range(self._n_dim)], self._tile_step)
-        if self.mode == 'drop':
+        div, mod = np.divmod(
+            [self.data_shape[d] - self._tile_overlap[d] for d in range(self._n_dim)],
+            self._tile_step,
+        )
+        if self.mode == "drop":
             self._indexing_shape = div
         else:
             self._indexing_shape = div + (mod != 0)
@@ -180,8 +187,9 @@ def __init__(self,
             self._tile_step[self.channel_dimension] = 0
 
         # Tile indexing
-        self._tile_index = np.vstack(np.meshgrid(
-            *[np.arange(0, x) for x in self._indexing_shape], indexing='ij'))
+        self._tile_index = np.vstack(
+            np.meshgrid(*[np.arange(0, x) for x in self._indexing_shape], indexing="ij")
+        )
         self._tile_index = self._tile_index.reshape(self._n_dim, -1).T
         self.n_tiles = len(self._tile_index)
 
@@ -356,8 +364,13 @@ def get_tile(
         # get tile data
         tile_corner = self._tile_index[tile_id] * self._tile_step
         # take the lesser of the tile shape and the distance to the edge
-        sampling = [slice(tile_corner[d], np.min(
-            [self.data_shape[d], tile_corner[d] + self.tile_shape[d]])) for d in range(self._n_dim)]
+        sampling = [
+            slice(
+                tile_corner[d],
+                np.min([self.data_shape[d], tile_corner[d] + self.tile_shape[d]]),
+            )
+            for d in range(self._n_dim)
+        ]
 
         if callable(data):
             sampling = [x.stop - x.start for x in sampling]
@@ -369,13 +382,18 @@ def get_tile(
             tile_data = tile_data.copy()
 
         shape_diff = self.tile_shape - tile_data.shape
-        if (self.mode != 'irregular') and np.any(shape_diff > 0):
-            if self.mode == 'constant':
-                tile_data = np.pad(tile_data, list((0, diff) for diff in shape_diff), mode=self.mode,
-                                   constant_values=self.constant_value)
-            elif self.mode == 'reflect' or self.mode == 'edge' or self.mode == 'wrap':
-                tile_data = np.pad(tile_data, list((0, diff)
-                                                   for diff in shape_diff), mode=self.mode)
+        if (self.mode != "irregular") and np.any(shape_diff > 0):
+            if self.mode == "constant":
+                tile_data = np.pad(
+                    tile_data,
+                    list((0, diff) for diff in shape_diff),
+                    mode=self.mode,
+                    constant_values=self.constant_value,
+                )
+            elif self.mode == "reflect" or self.mode == "edge" or self.mode == "wrap":
+                tile_data = np.pad(
+                    tile_data, list((0, diff) for diff in shape_diff), mode=self.mode
+                )
 
         return tile_data
 
@@ -404,8 +422,9 @@ def get_tile_bbox_position(
         starting_corner = self._tile_step * self.get_tile_mosaic_position(tile_id, True)
         finish_corner = starting_corner + self.tile_shape
         if self.channel_dimension is not None and not with_channel_dim:
-            dim_indices = list(range(self.channel_dimension)) + \
-                list(range(self.channel_dimension + 1, len(self._tile_step)))
+            dim_indices = list(range(self.channel_dimension)) + list(
+                range(self.channel_dimension + 1, len(self._tile_step))
+            )
             starting_corner = starting_corner[dim_indices]
             finish_corner = finish_corner[dim_indices]
         return starting_corner, finish_corner
@@ -457,7 +476,7 @@ def calculate_padding(self,
                           tile_shape: np.ndarray,
                           overlap: np.ndarray,
                           pprint: Optional[bool] = False) -> np.ndarray:
-        """Calculates the Padding from a given input. 
+        """Calculates the Padding from a given input.
 
 
         Parameters