acvl-utils 0.2__tar.gz → 0.2.2__tar.gz

{acvl_utils-0.2 → acvl_utils-0.2.2}/PKG-INFO

@@ -1,7 +1,14 @@
 Metadata-Version: 2.1
 Name: acvl_utils
-Version: 0.2
+Version: 0.2.2
 Summary: Super cool utilities that we just love to use
 Author: Applied Computer Vision Lab, Helmholtz Imaging & Division of Medical Image Computing, German Cancer Research Center
 Author-email: f.isensee@dkfz.de
 License: Apache License Version 2.0, January 2004
+Requires-Dist: numpy
+Requires-Dist: batchgenerators
+Requires-Dist: torch
+Requires-Dist: SimpleITK
+Requires-Dist: scikit-image
+Requires-Dist: connected-components-3d
+Requires-Dist: blosc2>=3.0.0b4

acvl_utils-0.2.2/acvl_utils/cropping_and_padding/bounding_boxes.py

@@ -0,0 +1,267 @@
+from copy import deepcopy
+from typing import Tuple
+from typing import Union, List
+
+import blosc2
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+def pad_bbox(bounding_box: Union[List[List[int]], Tuple[Tuple[int, int]]], pad_amount: Union[int, List[int]],
+             array_shape: Tuple[int, ...] = None) -> List[List[int]]:
+    """
+
+    """
+    if isinstance(bounding_box, tuple):
+        # convert to list
+        bounding_box = [list(i) for i in bounding_box]
+    else:
+        # needed because otherwise we overwrite input which could have unforseen consequences
+        bounding_box = deepcopy(bounding_box)
+
+    if isinstance(pad_amount, int):
+        pad_amount = [pad_amount] * len(bounding_box)
+
+    for i in range(len(bounding_box)):
+        new_values = [max(0, bounding_box[i][0] - pad_amount[i]), bounding_box[i][1] + pad_amount[i]]
+        if array_shape is not None:
+            new_values[1] = min(array_shape[i], new_values[1])
+        bounding_box[i] = new_values
+
+    return bounding_box
+
+
+def regionprops_bbox_to_proper_bbox(regionprops_bbox: Tuple[int, ...]) -> List[List[int]]:
+    """
+    regionprops_bbox is what you get from `from skimage.measure import regionprops`
+    """
+    dim = len(regionprops_bbox) // 2
+    return [[regionprops_bbox[i], regionprops_bbox[i + dim]] for i in range(dim)]
+
+
+def bounding_box_to_slice(bounding_box: List[List[int]]):
+    return tuple([slice(*i) for i in bounding_box])
+
+
+def crop_to_bbox(array: np.ndarray, bounding_box: List[List[int]]):
+    assert len(bounding_box) == len(array.shape), f"Dimensionality of bbox and array do not match. bbox has length " \
+                                          f"{len(bounding_box)} while array has dimension {len(array.shape)}"
+    slicer = bounding_box_to_slice(bounding_box)
+    return array[slicer]
+
+
+def get_bbox_from_mask(mask: np.ndarray) -> List[List[int]]:
+    """
+    this implementation uses less ram than the np.where one and is faster as well IF we expect the bounding box to
+    be close to the image size. If it's not it's likely slower!
+    
+    bbox is returned so that you can just do slice(minzidx, maxzidx) to retrieve the object of interest with nothing cut off
+
+    :param mask:
+    :param outside_value:
+    :return:
+    """
+    Z, X, Y = mask.shape
+    minzidx, maxzidx, minxidx, maxxidx, minyidx, maxyidx = 0, Z, 0, X, 0, Y
+    zidx = list(range(Z))
+    for z in zidx:
+        if np.any(mask[z]):
+            minzidx = z
+            break
+    for z in zidx[::-1]:
+        if np.any(mask[z]):
+            maxzidx = z + 1
+            break
+
+    xidx = list(range(X))
+    for x in xidx:
+        if np.any(mask[:, x]):
+            minxidx = x
+            break
+    for x in xidx[::-1]:
+        if np.any(mask[:, x]):
+            maxxidx = x + 1
+            break
+
+    yidx = list(range(Y))
+    for y in yidx:
+        if np.any(mask[:, :, y]):
+            minyidx = y
+            break
+    for y in yidx[::-1]:
+        if np.any(mask[:, :, y]):
+            maxyidx = y + 1
+            break
+    return [[minzidx, maxzidx], [minxidx, maxxidx], [minyidx, maxyidx]]
+
+
+def get_bbox_from_mask_npwhere(mask: np.ndarray) -> List[List[int]]:
+    where = np.array(np.where(mask))
+    mins = np.min(where, 1)
+    maxs = np.max(where, 1) + 1
+    return [[i, j] for i, j in zip(mins, maxs)]
+
+
+def crop_and_pad_nd(
+        image: Union[torch.Tensor, np.ndarray, blosc2.ndarray.NDArray],
+        bbox: List[List[int]],
+        pad_value = 0
+) -> Union[torch.Tensor, np.ndarray]:
+    """
+    Crops a bounding box directly specified by bbox, excluding the upper bound.
+    If the bounding box extends beyond the image boundaries, the cropped area is padded
+    to maintain the desired size. Initial dimensions not included in bbox remain unaffected.
+
+    Parameters:
+    - image: N-dimensional torch.Tensor or np.ndarray representing the image
+    - bbox: List of [[dim_min, dim_max], ...] defining the bounding box for the last dimensions.
+
+    Returns:
+    - Cropped and padded patch of the requested bounding box size, as the same type as `image`.
+    """
+
+    # Determine the number of dimensions to crop based on bbox
+    crop_dims = len(bbox)
+    img_shape = image.shape
+    num_dims = len(img_shape)
+
+    # Initialize the crop and pad specifications for each dimension
+    slices = []
+    padding = []
+    output_shape = list(img_shape[:num_dims - crop_dims])  # Initial dimensions remain as in the original image
+    target_shape = output_shape + [max_val - min_val for min_val, max_val in bbox]
+
+    # Iterate through dimensions, applying bbox to the last `crop_dims` dimensions
+    for i in range(num_dims):
+        if i < num_dims - crop_dims:
+            # For initial dimensions not covered by bbox, include the entire dimension
+            slices.append(slice(None))
+            padding.append([0, 0])
+            output_shape.append(img_shape[i])  # Keep the initial dimensions as they are
+        else:
+            # For dimensions specified in bbox, directly use the min and max bounds
+            dim_idx = i - (num_dims - crop_dims)  # Index within bbox
+
+            min_val = bbox[dim_idx][0]
+            max_val = bbox[dim_idx][1]
+
+            # Check if the bounding box is completely outside the image bounds
+            if max_val <= 0 or min_val >= img_shape[i]:
+                # If outside bounds, return an empty array or tensor of the target shape
+                if isinstance(image, torch.Tensor):
+                    return torch.zeros(target_shape, dtype=image.dtype, device=image.device)
+                elif isinstance(image, (np.ndarray, blosc2.ndarray.NDArray)):
+                    return np.zeros(target_shape, dtype=image.dtype)
+
+            # Calculate valid cropping ranges within image bounds, excluding the upper bound
+            valid_min = max(min_val, 0)
+            valid_max = min(max_val, img_shape[i])  # Exclude upper bound by using max_val directly
+            slices.append(slice(valid_min, valid_max))
+
+            # Calculate padding needed for this dimension
+            pad_before = max(0, -min_val)
+            pad_after = max(0, max_val - img_shape[i])
+            padding.append([pad_before, pad_after])
+
+            # Define the shape based on the bbox range in this dimension
+            output_shape.append(max_val - min_val)
+
+    # Crop the valid part of the bounding box
+    cropped = image[tuple(slices)]
+
+    # Apply padding to the cropped patch
+    if isinstance(image, torch.Tensor):
+        flattened_padding = [p for sublist in reversed(padding) for p in sublist]  # Flatten in reverse order for PyTorch
+        padded_cropped = F.pad(cropped, flattened_padding, mode="constant", value=pad_value)
+    elif isinstance(image, (np.ndarray, blosc2.ndarray.NDArray)):
+        pad_width = [(p[0], p[1]) for p in padding]
+        padded_cropped = np.pad(cropped, pad_width=pad_width, mode='constant', constant_values=pad_value)
+    else:
+        raise ValueError(f'Unsupported image type {type(image)}')
+
+    return padded_cropped
+
+
+def insert_crop_into_image(
+        image: Union[torch.Tensor, np.ndarray],
+        crop: Union[torch.Tensor, np.ndarray],
+        bbox: List[List[int]]
+) -> Union[torch.Tensor, np.ndarray]:
+    """
+    Inserts a cropped patch back into the original image at the position specified by bbox.
+    If the bounding box extends beyond the image boundaries, only the valid portions are inserted.
+    If the bounding box lies entirely outside the image, the original image is returned.
+
+    Parameters:
+    - image: Original N-dimensional torch.Tensor or np.ndarray to which the crop will be inserted.
+    - crop: Cropped patch of the image to be reinserted. May have additional dimensions compared to bbox.
+    - bbox: List of [[dim_min, dim_max], ...] defining the bounding box for the last dimensions of the crop in the original image.
+
+    Returns:
+    - image: The original image with the crop reinserted at the specified location (modified in-place).
+    """
+
+    # Ensure that bbox only applies to the last len(bbox) dimensions of crop and image
+    num_dims = len(image.shape)
+    crop_dims = len(crop.shape)
+    bbox_dims = len(bbox)
+
+    if crop_dims < bbox_dims:
+        raise ValueError("Bounding box dimensions cannot exceed crop dimensions.")
+
+    # Validate that non-cropped leading dimensions match between image and crop
+    leading_dims = num_dims - bbox_dims
+    if image.shape[:leading_dims] != crop.shape[:leading_dims]:
+        raise ValueError("Leading dimensions of crop and image must match.")
+
+    # Check if the bounding box lies completely outside the image bounds for each cropped dimension
+    for i in range(bbox_dims):
+        min_val, max_val = bbox[i]
+        dim_idx = leading_dims + i  # Corresponding dimension in the image
+
+        if max_val <= 0 or min_val >= image.shape[dim_idx]:
+            # If completely out of bounds in any dimension, return the original image
+            return image
+
+    # Prepare slices for inserting the crop into the original image
+    image_slices = []
+    crop_slices = []
+
+    # Iterate over all dimensions, applying bbox only to the last len(bbox) dimensions
+    for i in range(num_dims):
+        if i < leading_dims:
+            # For leading dimensions, use entire dimension (slice(None)) and validate shape
+            image_slices.append(slice(None))
+            crop_slices.append(slice(None))
+        else:
+            # For dimensions specified by bbox, calculate the intersection with image bounds
+            dim_idx = i - leading_dims
+            min_val, max_val = bbox[dim_idx]
+
+            crop_start = max(0, -min_val)  # Start of the crop within the valid area
+            image_start = max(0, min_val)  # Start of the image where the crop will be inserted
+            image_end = min(max_val, image.shape[i])  # Exclude upper bound by using max_val directly
+
+            # Adjusted range for insertion
+            crop_end = crop_start + (image_end - image_start)
+
+            # Append slices for both image and crop insertion ranges
+            image_slices.append(slice(image_start, image_end))
+            crop_slices.append(slice(crop_start, crop_end))
+
+    # Insert the valid part of the crop back into the original image
+    if isinstance(image, torch.Tensor):
+        image[tuple(image_slices)] = crop[tuple(crop_slices)]
+    elif isinstance(image, np.ndarray):
+        image[tuple(image_slices)] = crop[tuple(crop_slices)]
+    else:
+        raise ValueError(f"Unsupported image type {type(image)}")
+
+    return image
+
+
+if __name__ == '__main__':
+    bbox = [[32, 64], [21, 46]]
+    bbox_padded = pad_bbox(bbox, 3)
+    slicer = bounding_box_to_slice(bbox_padded)

{acvl_utils-0.2 → acvl_utils-0.2.2}/acvl_utils/instance_segmentation/instance_as_semantic_seg.py

@@ -2,6 +2,7 @@ from time import time
 from multiprocessing import Pool
 from typing import Union, Tuple, List
 
+import SimpleITK
 import numpy as np
 
 from acvl_utils.cropping_and_padding.bounding_boxes import pad_bbox, bounding_box_to_slice
@@ -79,11 +80,11 @@ def convert_semantic_to_instanceseg_mp(arr: np.ndarray,
     # we first identify centers that are too small and set them to be border. This should remove false positive instances
     labeled_image, component_sizes = label_with_component_sizes(arr == CENTER_LABEL, connectivity=1)
     remove = np.array([i for i, j in component_sizes.items() if j <= small_center_threshold_in_pixels])
-    remove = np.in1d(labeled_image.ravel(), remove).reshape(labeled_image.shape)
+    remove = np.isin(labeled_image.ravel(), remove).reshape(labeled_image.shape)
     arr[remove] = BORDER_LABEL
 
     # recompute core labels
-    core_instances = label(arr == CENTER_LABEL)
+    core_instances = label(arr == CENTER_LABEL, connectivity=1)
 
     # prepare empty array for results. uint32 for allowing HEAPS of instances. Otherwise we would cap at 65535
     final = np.zeros_like(core_instances, dtype=np.uint32)
@@ -165,11 +166,11 @@ def convert_semantic_to_instanceseg(arr: np.ndarray,
     # we first identify centers that are too small and set them to be border. This should remove false positive instances
     labeled_image, component_sizes = label_with_component_sizes(arr == CENTER_LABEL, connectivity=1)
     remove = np.array([i for i, j in component_sizes.items() if j <= small_center_threshold_in_pixels])
-    remove = np.in1d(labeled_image.ravel(), remove).reshape(labeled_image.shape)
+    remove = np.isin(labeled_image.ravel(), remove).reshape(labeled_image.shape)
     arr[remove] = BORDER_LABEL
 
     # recompute core labels
-    core_instances = label(arr == CENTER_LABEL)
+    core_instances = label(arr == CENTER_LABEL, connectivity=1)
 
     # prepare empty array for results
     final = np.zeros_like(core_instances, dtype=np.uint32)
@@ -518,3 +519,4 @@ def main_sem_to_instance():
 
 if __name__ == '__main__':
     main_sem_to_instance()
+

{acvl_utils-0.2 → acvl_utils-0.2.2}/acvl_utils/morphology/morphology_helper.py

@@ -1,4 +1,4 @@
-from typing import Union, Tuple, List, Callable
+from typing import Union, Tuple, List, Callable, Dict
 
 import numpy as np
 from skimage.measure import label
@@ -30,6 +30,27 @@ def label_with_component_sizes(binary_image: np.ndarray, connectivity: int = Non
     return labeled_image, component_sizes
 
 
+def cc3d_label_with_component_sizes(binary_image: np.ndarray, connectivity: int = 6) -> Tuple[np.ndarray, Dict[int, int]]:
+    """
+    Uses cc3d to label connected components in a binary image and returns the labeled image along with
+    a dictionary of component sizes.
+
+    Parameters:
+    binary_image (np.ndarray): The input binary image where connected components should be labeled.
+    connectivity (int): Connectivity of components (default 6 for 3D images).
+
+    Returns:
+    Tuple[np.ndarray, dict]: A tuple with the labeled image and a dictionary of component sizes.
+    """
+    # Ensure the image is binary
+    labeled_image = cc3d.connected_components(binary_image, connectivity=connectivity)
+
+    # Get the sizes of each component (ignoring background, i.e., label 0)
+    component_sizes = {i: j for i, j in enumerate(np.bincount(labeled_image.ravel())[1:], start=1)}
+
+    return labeled_image, component_sizes
+
+
 def remove_all_but_largest_component(binary_image: np.ndarray, connectivity: int = None) -> np.ndarray:
     """
     Removes all but the largest component in binary_image. Replaces pixels that don't belong to it with background_label
@@ -50,7 +71,7 @@ def generic_filter_components(binary_image: np.ndarray, filter_fn: Callable[[Lis
     component_ids = list(component_sizes.keys())
     component_sizes = list(component_sizes.values())
     keep = filter_fn(component_ids, component_sizes)
-    return np.in1d(labeled_image.ravel(), keep).reshape(labeled_image.shape)
+    return np.isin(labeled_image.ravel(), keep).reshape(labeled_image.shape)
 
 
 def remove_components(binary_image: np.ndarray, threshold_size_in_pixels: int, threshold_type: str = 'min',
@@ -86,7 +107,7 @@ def remove_components(binary_image: np.ndarray, threshold_size_in_pixels: int, t
             print(f'{len(keep)} objects are smaller than the maximum size of {threshold_size_in_pixels}. '
                   f'Removing {len(component_sizes) - len(keep)} large objects...')
 
-    keep = np.in1d(labeled_image, keep).astype(binary_image.dtype).reshape(binary_image.shape)
+    keep = np.isin(labeled_image, keep).astype(binary_image.dtype).reshape(binary_image.shape)
     return keep
 
 
@@ -139,7 +160,7 @@ def remove_components_cc3d(binary_image: np.ndarray, threshold_size_in_pixels: i
                   f'Removing {num_components - len(labels_to_keep)} large objects...')
 
     # in the component mask set every label that should be removed to 0
-    keep = np.in1d(components, labels_to_keep).astype(binary_image.dtype).reshape(binary_image.shape)
+    keep = np.isin(components, labels_to_keep).astype(binary_image.dtype).reshape(binary_image.shape)
 
     return keep
 

{acvl_utils-0.2 → acvl_utils-0.2.2}/acvl_utils.egg-info/PKG-INFO

@@ -1,7 +1,14 @@
 Metadata-Version: 2.1
-Name: acvl-utils
-Version: 0.2
+Name: acvl_utils
+Version: 0.2.2
 Summary: Super cool utilities that we just love to use
 Author: Applied Computer Vision Lab, Helmholtz Imaging & Division of Medical Image Computing, German Cancer Research Center
 Author-email: f.isensee@dkfz.de
 License: Apache License Version 2.0, January 2004
+Requires-Dist: numpy
+Requires-Dist: batchgenerators
+Requires-Dist: torch
+Requires-Dist: SimpleITK
+Requires-Dist: scikit-image
+Requires-Dist: connected-components-3d
+Requires-Dist: blosc2>=3.0.0b4

{acvl_utils-0.2 → acvl_utils-0.2.2}/acvl_utils.egg-info/SOURCES.txt

@@ -20,4 +20,11 @@ acvl_utils/miscellaneous/test_all_images_same.py
 acvl_utils/morphology/__init__.py
 acvl_utils/morphology/gpu_binary_morphology.py
 acvl_utils/morphology/morphology_helper.py
-acvl_utils/morphology/slice_interpolation.py
+acvl_utils/morphology/slice_interpolation.py
+tests/test_component_removal.py
+tests/test_crop_and_pad.py
+tests/test_insert_crop.py
+tests/test_instance_matching.py
+tests/test_padding.py
+tests/test_ptqdm.py
+tests/test_slicer.py

{acvl_utils-0.2 → acvl_utils-0.2.2}/acvl_utils.egg-info/requires.txt

@@ -4,3 +4,4 @@ torch
 SimpleITK
 scikit-image
 connected-components-3d
+blosc2>=3.0.0b4

{acvl_utils-0.2 → acvl_utils-0.2.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_namespace_packages
 
 setup(name='acvl_utils',
       packages=find_namespace_packages(include=["acvl_utils", "acvl_utils.*"]),
-      version='0.2',
+      version='0.2.2',
       description='Super cool utilities that we just love to use',
       # url='',
       author='Applied Computer Vision Lab, Helmholtz Imaging & Division of Medical Image Computing, German Cancer Research Center',
@@ -14,6 +14,7 @@ setup(name='acvl_utils',
           "torch",
           "SimpleITK",
           "scikit-image",
-          "connected-components-3d"
+          "connected-components-3d",
+          "blosc2>=3.0.0b4"
       ],
       )

acvl_utils-0.2.2/tests/test_component_removal.py

@@ -0,0 +1,107 @@
+import unittest
+from acvl_utils.morphology.morphology_helper import remove_components, remove_components_cc3d
+import numpy as np
+
+
+class TestComponentRemoval(unittest.TestCase):
+    def setUp(self) -> None:
+        self.binary_image_2D = np.array([[1, 0, 1, 1, 0, 0, 1],
+                                         [0, 1, 1, 1, 0, 0, 1],
+                                         [0, 0, 0, 0, 0, 1, 0],
+                                         [1, 0, 0, 1, 0, 0, 0],
+                                         [1, 1, 0, 1, 0, 0, 1]]).astype(bool)
+
+        self.binary_image_3D = np.array([[[1, 0, 1, 1, 0, 0, 1],
+                                         [0, 1, 1, 1, 0, 0, 1],
+                                         [0, 0, 0, 0, 0, 1, 0],
+                                         [1, 0, 0, 1, 0, 0, 0],
+                                         [1, 1, 0, 1, 0, 0, 1]],
+                                         [[1, 0, 1, 1, 0, 0, 1],
+                                          [0, 1, 1, 1, 0, 0, 1],
+                                          [0, 0, 0, 0, 0, 1, 0],
+                                          [1, 0, 0, 1, 0, 0, 0],
+                                          [1, 1, 0, 1, 0, 0, 1]],
+                                         [[1, 0, 1, 1, 0, 0, 1],
+                                          [0, 1, 1, 1, 0, 0, 1],
+                                          [0, 0, 0, 0, 0, 1, 0],
+                                          [1, 0, 0, 1, 0, 0, 0],
+                                          [1, 1, 0, 1, 0, 0, 1]]
+                                         ]).astype(bool)
+
+    def test_remove_small_comp_2D(self):
+        skimage_res = remove_components(self.binary_image_2D, 3, 'min', verbose=False)
+        cc3d_res = remove_components_cc3d(self.binary_image_2D, 3, 'min', verbose=False, connectivity=8)
+
+        self.assertTrue((skimage_res == cc3d_res).all())
+
+        expected_output = np.array([[1, 0, 1, 1, 0, 0, 1],
+                                    [0, 1, 1, 1, 0, 0, 1],
+                                    [0, 0, 0, 0, 0, 1, 0],
+                                    [1, 0, 0, 0, 0, 0, 0],
+                                    [1, 1, 0, 0, 0, 0, 0]]).astype(bool)
+
+        self.assertTrue((skimage_res == expected_output).all())
+
+    def test_remove_large_comp_2D(self):
+        skimage_res = remove_components(self.binary_image_2D, 4, 'max', verbose=False)
+        cc3d_res = remove_components_cc3d(self.binary_image_2D, 4, 'max', verbose=False, connectivity=8)
+
+        self.assertTrue((skimage_res == cc3d_res).all())
+
+        expected_output = np.array([[0, 0, 0, 0, 0, 0, 1],
+                                    [0, 0, 0, 0, 0, 0, 1],
+                                    [0, 0, 0, 0, 0, 1, 0],
+                                    [1, 0, 0, 1, 0, 0, 0],
+                                    [1, 1, 0, 1, 0, 0, 1]]).astype(bool)
+
+        self.assertTrue((skimage_res == expected_output).all())
+
+    def test_remove_small_comp_3D(self):
+        skimage_res = remove_components(self.binary_image_3D, 9, 'min', verbose=False)
+        cc3d_res = remove_components_cc3d(self.binary_image_3D, 9, 'min', verbose=False, connectivity=26)
+
+        self.assertTrue((skimage_res == cc3d_res).all())
+
+        expected_output = np.array([[[1, 0, 1, 1, 0, 0, 1],
+                                    [0, 1, 1, 1, 0, 0, 1],
+                                    [0, 0, 0, 0, 0, 1, 0],
+                                    [1, 0, 0, 0, 0, 0, 0],
+                                    [1, 1, 0, 0, 0, 0, 0]],
+                                    [[1, 0, 1, 1, 0, 0, 1],
+                                     [0, 1, 1, 1, 0, 0, 1],
+                                     [0, 0, 0, 0, 0, 1, 0],
+                                     [1, 0, 0, 0, 0, 0, 0],
+                                     [1, 1, 0, 0, 0, 0, 0]],
+                                    [[1, 0, 1, 1, 0, 0, 1],
+                                     [0, 1, 1, 1, 0, 0, 1],
+                                     [0, 0, 0, 0, 0, 1, 0],
+                                     [1, 0, 0, 0, 0, 0, 0],
+                                     [1, 1, 0, 0, 0, 0, 0]],
+                                    ]).astype(bool)
+
+        self.assertTrue((skimage_res == expected_output).all())
+
+    def test_remove_large_comp_3D(self):
+        skimage_res = remove_components(self.binary_image_3D, 12, 'max', verbose=False)
+        cc3d_res = remove_components_cc3d(self.binary_image_3D, 12, 'max', verbose=False, connectivity=26)
+
+        self.assertTrue((skimage_res == cc3d_res).all())
+
+        expected_output = np.array([[[0, 0, 0, 0, 0, 0, 1],
+                                    [0, 0, 0, 0, 0, 0, 1],
+                                    [0, 0, 0, 0, 0, 1, 0],
+                                    [1, 0, 0, 1, 0, 0, 0],
+                                    [1, 1, 0, 1, 0, 0, 1]],
+                                    [[0, 0, 0, 0, 0, 0, 1],
+                                     [0, 0, 0, 0, 0, 0, 1],
+                                     [0, 0, 0, 0, 0, 1, 0],
+                                     [1, 0, 0, 1, 0, 0, 0],
+                                     [1, 1, 0, 1, 0, 0, 1]],
+                                    [[0, 0, 0, 0, 0, 0, 1],
+                                     [0, 0, 0, 0, 0, 0, 1],
+                                     [0, 0, 0, 0, 0, 1, 0],
+                                     [1, 0, 0, 1, 0, 0, 0],
+                                     [1, 1, 0, 1, 0, 0, 1]],
+                                    ]).astype(bool)
+
+        self.assertTrue((skimage_res == expected_output).all())