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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: acvl_utils
-Version: 0.2.2
+Version: 0.2.4
 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
@@ -12,3 +12,8 @@ Requires-Dist: SimpleITK
 Requires-Dist: scikit-image
 Requires-Dist: connected-components-3d
 Requires-Dist: blosc2>=3.0.0b4
+Dynamic: author
+Dynamic: author-email
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary

{acvl_utils-0.2.2 → acvl_utils-0.2.4}/acvl_utils/cropping_and_padding/bounding_boxes.py

@@ -11,7 +11,57 @@ 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]]:
     """
+    Pads a bounding box by a specified amount and optionally ensures that it stays within the bounds of an array.
 
+    Parameters:
+    -----------
+    bounding_box : Union[List[List[int]], Tuple[Tuple[int, int]]]
+        The input bounding box, represented as a list or tuple of coordinate pairs. Each pair corresponds to
+        one dimension and should have the form `[start, end]`, where `start` is inclusive and `end` is exclusive.
+
+    pad_amount : Union[int, List[int]]
+        The amount of padding to apply to each dimension of the bounding box.
+        - If an integer is provided, the same padding is applied to all dimensions.
+        - If a list is provided, each element specifies the padding for the corresponding dimension.
+
+    array_shape : Tuple[int, ...], optional
+        The shape of the array to which the bounding box is applied.
+        If provided, the padded bounding box will be clipped to stay within these bounds.
+
+    Returns:
+    --------
+    List[List[int]]
+        A new bounding box with the specified padding applied. Each dimension will be represented as a pair `[start, end]`.
+
+    Notes:
+    ------
+    - The input `bounding_box` is converted to a list to ensure it can be modified without affecting the original data.
+    - The padding is applied symmetrically, reducing the `start` coordinate and increasing the `end` coordinate.
+    - If `array_shape` is provided, the padded bounding box will not exceed the valid indices of the array.
+
+    Examples:
+    ---------
+    1. Padding a bounding box without array shape constraints:
+       ```python
+       bbox = [[2, 10], [5, 15]]
+       padded_bbox = pad_bbox(bbox, pad_amount=2)
+       # Result: [[0, 12], [3, 17]]
+       ```
+
+    2. Padding with array shape constraints:
+       ```python
+       bbox = [[2, 10], [5, 15]]
+       array_shape = (12, 20)
+       padded_bbox = pad_bbox(bbox, pad_amount=2, array_shape=array_shape)
+       # Result: [[0, 12], [3, 17]]
+       ```
+
+    3. Using dimension-specific padding:
+       ```python
+       bbox = [[2, 10], [5, 15]]
+       padded_bbox = pad_bbox(bbox, pad_amount=[3, 1])
+       # Result: [[0, 13], [4, 16]]
+       ```
     """
     if isinstance(bounding_box, tuple):
         # convert to list
@@ -41,10 +91,26 @@ def regionprops_bbox_to_proper_bbox(regionprops_bbox: Tuple[int, ...]) -> List[L
 
 
 def bounding_box_to_slice(bounding_box: List[List[int]]):
+    """
+    ALL bounding boxes in acvl_utils and nnU-Netv2 are half open interval [start, end)!
+    - Alignment with Python Slicing
+    - Ease of Subdivision
+    - Consistency in Multi-Dimensional Arrays
+    - Precedent in Computer Graphics
+    https://chatgpt.com/share/679203ec-3fbc-8013-a003-13a7adfb1e73
+    """
     return tuple([slice(*i) for i in bounding_box])
 
 
 def crop_to_bbox(array: np.ndarray, bounding_box: List[List[int]]):
+    """
+    ALL bounding boxes in acvl_utils and nnU-Netv2 are half open interval [start, end)!
+    - Alignment with Python Slicing
+    - Ease of Subdivision
+    - Consistency in Multi-Dimensional Arrays
+    - Precedent in Computer Graphics
+    https://chatgpt.com/share/679203ec-3fbc-8013-a003-13a7adfb1e73
+    """
     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)
@@ -53,10 +119,15 @@ def crop_to_bbox(array: np.ndarray, bounding_box: List[List[int]]):
 
 def get_bbox_from_mask(mask: np.ndarray) -> List[List[int]]:
     """
+    ALL bounding boxes in acvl_utils and nnU-Netv2 are half open interval [start, end)!
+    - Alignment with Python Slicing
+    - Ease of Subdivision
+    - Consistency in Multi-Dimensional Arrays
+    - Precedent in Computer Graphics
+    https://chatgpt.com/share/679203ec-3fbc-8013-a003-13a7adfb1e73
+
     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:
@@ -96,7 +167,22 @@ def get_bbox_from_mask(mask: np.ndarray) -> List[List[int]]:
     return [[minzidx, maxzidx], [minxidx, maxxidx], [minyidx, maxyidx]]
 
 
+def int_bbox(bbox):
+    bbox2 = [[int(i) for i in row] for row in bbox]  # Convert all values to int
+    if bbox2 != bbox:  # Directly compare the original and casted versions
+        raise RuntimeError(f"Invalid bbox encountered. Cannot be safely cast to int: {bbox}. Casting result: {bbox2}")
+    return bbox2
+
+
 def get_bbox_from_mask_npwhere(mask: np.ndarray) -> List[List[int]]:
+    """
+    ALL bounding boxes in acvl_utils and nnU-Netv2 are half open interval [start, end)!
+    - Alignment with Python Slicing
+    - Ease of Subdivision
+    - Consistency in Multi-Dimensional Arrays
+    - Precedent in Computer Graphics
+    https://chatgpt.com/share/679203ec-3fbc-8013-a003-13a7adfb1e73
+    """
     where = np.array(np.where(mask))
     mins = np.min(where, 1)
     maxs = np.max(where, 1) + 1
@@ -106,21 +192,37 @@ def get_bbox_from_mask_npwhere(mask: np.ndarray) -> List[List[int]]:
 def crop_and_pad_nd(
         image: Union[torch.Tensor, np.ndarray, blosc2.ndarray.NDArray],
         bbox: List[List[int]],
-        pad_value = 0
+        pad_value=0,
+        pad_mode: str = 'constant'
 ) -> Union[torch.Tensor, np.ndarray]:
     """
-    Crops a bounding box directly specified by bbox, excluding the upper bound.
+    Crops a bounding box directly specified by bbox, adhering to the half-open interval [start, end).
     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.
 
+    ALL bounding boxes in acvl_utils and nnU-Netv2 are half open interval [start, end)!
+    - Alignment with Python Slicing
+    - Ease of Subdivision
+    - Consistency in Multi-Dimensional Arrays
+    - Precedent in Computer Graphics
+    https://chatgpt.com/share/679203ec-3fbc-8013-a003-13a7adfb1e73
+
     Parameters:
-    - image: N-dimensional torch.Tensor or np.ndarray representing the image
+    - image: N-dimensional torch.Tensor, np.ndarray, or blosc2.ndarray.NDArray representing the image.
     - bbox: List of [[dim_min, dim_max], ...] defining the bounding box for the last dimensions.
+            Each dimension follows the half-open interval [start, end).
+    - pad_value: Value used for padding when bbox extends beyond image boundaries.
+    - pad_mode: Padding mode, one of 'constant', 'reflect', or 'replicate' (alias for 'edge').
 
     Returns:
     - Cropped and padded patch of the requested bounding box size, as the same type as `image`.
     """
 
+    assert pad_mode in ['constant', 'reflect', 'replicate', 'edge'], "Unsupported pad_mode."
+
+    # make sure bounding boxes are int and not uint. Otherwise we may get underflow
+    bbox = int_bbox(bbox)
+
     # Determine the number of dimensions to crop based on bbox
     crop_dims = len(bbox)
     img_shape = image.shape
@@ -130,7 +232,7 @@ def crop_and_pad_nd(
     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]
+    target_shape = output_shape + [max_val - min_val for min_val, max_val in bbox]  # Half-open interval
 
     # Iterate through dimensions, applying bbox to the last `crop_dims` dimensions
     for i in range(num_dims):
@@ -138,13 +240,13 @@ def crop_and_pad_nd(
             # 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
+            output_shape.append(img_shape[i])
         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]
+            max_val = bbox[dim_idx][1]  # This is exclusive by definition
 
             # Check if the bounding box is completely outside the image bounds
             if max_val <= 0 or min_val >= img_shape[i]:
@@ -154,9 +256,9 @@ def crop_and_pad_nd(
                 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
+            # Calculate valid cropping ranges within image bounds (half-open interval)
             valid_min = max(min_val, 0)
-            valid_max = min(max_val, img_shape[i])  # Exclude upper bound by using max_val directly
+            valid_max = min(max_val, img_shape[i])  # Exclusive upper bound
             slices.append(slice(valid_min, valid_max))
 
             # Calculate padding needed for this dimension
@@ -171,14 +273,28 @@ def crop_and_pad_nd(
     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)
+    if np.any(padding):
+        if isinstance(image, torch.Tensor):
+            if pad_mode == 'edge':
+                pad_mode = 'replicate'
+                cropped = cropped[None, None]  # Adjust shape for PyTorch padding requirements
+            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=pad_mode, value=pad_value)
+            if pad_mode == 'replicate':
+                padded_cropped = padded_cropped[0, 0]
+        elif isinstance(image, (np.ndarray, blosc2.ndarray.NDArray)):
+            if pad_mode == 'replicate':
+                pad_mode = 'edge'
+            if pad_mode == 'edge' or pad_mode == 'reflect':
+                kwargs = {}
+            else:
+                kwargs = {'constant_values': pad_value}
+            pad_width = [(p[0], p[1]) for p in padding]
+            padded_cropped = np.pad(cropped, pad_width=pad_width, mode=pad_mode, **kwargs)
+        else:
+            raise ValueError(f'Unsupported image type {type(image)}')
     else:
-        raise ValueError(f'Unsupported image type {type(image)}')
+        padded_cropped = cropped
 
     return padded_cropped
 
@@ -201,6 +317,8 @@ def insert_crop_into_image(
     Returns:
     - image: The original image with the crop reinserted at the specified location (modified in-place).
     """
+    # make sure bounding boxes are int and not uint. Otherwise we may get underflow
+    bbox = int_bbox(bbox)
 
     # Ensure that bbox only applies to the last len(bbox) dimensions of crop and image
     num_dims = len(image.shape)

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

@@ -2,20 +2,24 @@ from typing import Union, Tuple, List, Callable, Dict
 
 import numpy as np
 from skimage.measure import label
-from skimage.morphology import ball
+from skimage.morphology import ball, disk
 from skimage.transform import resize
 import cc3d
 
 
-def generate_ball(radius: Union[Tuple, List], spacing: Union[Tuple, List] = (1, 1, 1), dtype=np.uint8) -> np.ndarray:
+def generate_ball(radius: Union[Tuple, List], spacing: Union[Tuple, List] = None, dtype=np.uint8) -> np.ndarray:
     """
     Returns a ball/ellipsoid corresponding to the specified size (radius = list/tuple of len 3 with one radius per axis)
     If you use spacing, both radius and spacing will be interpreted relative to each other, so a radius of 10 with a
     spacing of 5 will result in a ball with radius 2 pixels.
     """
-    radius_in_voxels = np.array([round(i) for i in radius / np.array(spacing)])
+    if spacing is None:
+        spacing = [1] * len(radius)
+    radius_in_voxels = np.array([round(i) for i in radius]) / np.array(spacing)
+    if all([i == radius_in_voxels[0] for i in radius_in_voxels[1:]]):
+        return ball(radius_in_voxels[0]) if len(radius) == 3 else disk(radius_in_voxels[0])
     n = 2 * radius_in_voxels + 1
-    ball_iso = ball(max(n) * 2, dtype=np.float64)
+    ball_iso = ball(max(n) * 2, dtype=np.float64) if len(radius) == 3 else disk(max(n) * 2, dtype=np.float64)
     ball_resampled = resize(ball_iso, n, 1, 'constant', 0, clip=True, anti_aliasing=False, preserve_range=True)
     ball_resampled[ball_resampled > 0.5] = 1
     ball_resampled[ball_resampled <= 0.5] = 0
@@ -59,6 +63,14 @@ def remove_all_but_largest_component(binary_image: np.ndarray, connectivity: int
     return generic_filter_components(binary_image, filter_fn, connectivity)
 
 
+def remove_all_but_largest_component_cc3d(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
+    """
+    filter_fn = lambda x, y: [i for i, j in zip(x, y) if j == max(y)]
+    return generic_filter_components_cc3d(binary_image, filter_fn, connectivity)
+
+
 def generic_filter_components(binary_image: np.ndarray, filter_fn: Callable[[List[int], List[int]], List[int]],
                               connectivity: int = None):
     """
@@ -74,6 +86,17 @@ def generic_filter_components(binary_image: np.ndarray, filter_fn: Callable[[Lis
     return np.isin(labeled_image.ravel(), keep).reshape(labeled_image.shape)
 
 
+def generic_filter_components_cc3d(binary_image: np.ndarray, filter_fn: Callable[[List[int], List[int]], List[int]],
+                              connectivity: int = None):
+    """
+    """
+    labeled_image, component_sizes = cc3d_label_with_component_sizes(binary_image, connectivity)
+    component_ids = list(component_sizes.keys())
+    component_sizes = list(component_sizes.values())
+    keep = filter_fn(component_ids, component_sizes)
+    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',
                       connectivity=None, verbose: bool = False):
     """
@@ -165,6 +188,7 @@ def remove_components_cc3d(binary_image: np.ndarray, threshold_size_in_pixels: i
     return keep
 
 
+
 if __name__ == '__main__':
     print(generate_ball((10, 10, 10), (5, 5, 5)).shape)
     print(generate_ball((10, 5, 15), (1, 1, 1)).shape)

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: acvl_utils
-Version: 0.2.2
+Version: 0.2.4
 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
@@ -12,3 +12,8 @@ Requires-Dist: SimpleITK
 Requires-Dist: scikit-image
 Requires-Dist: connected-components-3d
 Requires-Dist: blosc2>=3.0.0b4
+Dynamic: author
+Dynamic: author-email
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary

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

@@ -25,6 +25,7 @@ tests/test_component_removal.py
 tests/test_crop_and_pad.py
 tests/test_insert_crop.py
 tests/test_instance_matching.py
+tests/test_pad_bbox.py
 tests/test_padding.py
 tests/test_ptqdm.py
 tests/test_slicer.py

{acvl_utils-0.2.2 → acvl_utils-0.2.4}/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.2',
+      version='0.2.4',
       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',

{acvl_utils-0.2.2 → acvl_utils-0.2.4}/tests/test_crop_and_pad.py

@@ -264,7 +264,6 @@ class TestCropAndPadND(unittest.TestCase):
         self.assertEqual(cropped_patch.shape, (5, 10, 10, 5))
         np.testing.assert_array_equal(cropped_patch, self.image_np[:, :, :, 3:8])
 
-
     def test_two_dimensions_crop_np(self):
         """Test cropping the last two dimensions of a 4D np.ndarray."""
         bbox = [[3, 8], [1, 7]]
@@ -274,7 +273,6 @@ class TestCropAndPadND(unittest.TestCase):
         self.assertEqual(cropped_patch.shape, (5, 10, 5, 6))
         np.testing.assert_array_equal(cropped_patch, self.image_np[:, :, 3:8, 1:7])
 
-
     def test_three_dimensions_crop_np(self):
         """Test cropping the last three dimensions of a 4D np.ndarray."""
         bbox = [[1, 6], [2, 9], [3, 8]]
@@ -284,7 +282,6 @@ class TestCropAndPadND(unittest.TestCase):
         self.assertEqual(cropped_patch.shape, (5, 5, 7, 5))
         np.testing.assert_array_equal(cropped_patch, self.image_np[:, 1:6, 2:9, 3:8])
 
-
     def test_all_dimensions_crop_np(self):
         """Test cropping all dimensions of a 4D np.ndarray."""
         bbox = [[1, 4], [2, 7], [0, 6], [4, 9]]
@@ -294,7 +291,6 @@ class TestCropAndPadND(unittest.TestCase):
         self.assertEqual(cropped_patch.shape, (3, 5, 6, 5))
         np.testing.assert_array_equal(cropped_patch, self.image_np[1:4, 2:7, 0:6, 4:9])
 
-
     def test_single_dimension_crop_torch(self):
         """Test cropping only the last dimension of a 4D torch.Tensor."""
         bbox = [[3, 8]]
@@ -304,7 +300,6 @@ class TestCropAndPadND(unittest.TestCase):
         self.assertEqual(cropped_patch.shape, (5, 10, 10, 5))
         torch.testing.assert_close(cropped_patch, self.image_torch[:, :, :, 3:8])
 
-
     def test_two_dimensions_crop_torch(self):
         """Test cropping the last two dimensions of a 4D torch.Tensor."""
         bbox = [[3, 8], [1, 7]]
@@ -314,7 +309,6 @@ class TestCropAndPadND(unittest.TestCase):
         self.assertEqual(cropped_patch.shape, (5, 10, 5, 6))
         torch.testing.assert_close(cropped_patch, self.image_torch[:, :, 3:8, 1:7])
 
-
     def test_three_dimensions_crop_torch(self):
         """Test cropping the last three dimensions of a 4D torch.Tensor."""
         bbox = [[1, 6], [2, 9], [3, 8]]
@@ -324,7 +318,6 @@ class TestCropAndPadND(unittest.TestCase):
         self.assertEqual(cropped_patch.shape, (5, 5, 7, 5))
         torch.testing.assert_close(cropped_patch, self.image_torch[:, 1:6, 2:9, 3:8])
 
-
     def test_all_dimensions_crop_torch(self):
         """Test cropping all dimensions of a 4D torch.Tensor."""
         bbox = [[1, 4], [2, 7], [0, 6], [4, 9]]
@@ -334,6 +327,26 @@ class TestCropAndPadND(unittest.TestCase):
         self.assertEqual(cropped_patch.shape, (3, 5, 6, 5))
         torch.testing.assert_close(cropped_patch, self.image_torch[1:4, 2:7, 0:6, 4:9])
 
+    def test_pad_all_dims(self):
+        seg = np.ones((128, 128))
+        bbox = [[-5, 133], [-5, 133]]
+        out = crop_and_pad_nd(seg, bbox)
+        self.assertEqual(out.shape, (138, 138))
+        bbox_reverse = [[5, 133], [5, 133]]
+        out2 = crop_and_pad_nd(out, bbox_reverse)
+        self.assertEqual(out2.shape, (128, 128))
+        self.assertTrue(np.all(out2==1))
+
+    def test_pad_all_dims_torch(self):
+        seg = torch.ones((128, 128))
+        bbox = [[-5, 133], [-5, 133]]
+        out = crop_and_pad_nd(seg, bbox)
+        self.assertEqual(out.shape, (138, 138))
+        bbox_reverse = [[5, 133], [5, 133]]
+        out2 = crop_and_pad_nd(out, bbox_reverse)
+        self.assertEqual(out2.shape, (128, 128))
+        self.assertTrue(torch.all(out2==1))
+
 
 if __name__ == "__main__":
     unittest.main()

acvl_utils-0.2.4/tests/test_pad_bbox.py

@@ -0,0 +1,46 @@
+import unittest
+
+from acvl_utils.cropping_and_padding.bounding_boxes import pad_bbox
+
+
+class TestPadBBox(unittest.TestCase):
+
+    def test_no_array_shape(self):
+        bbox = [[2, 10], [5, 15]]
+        pad_amount = 2
+        expected = [[0, 12], [3, 17]]
+        result = pad_bbox(bbox, pad_amount)
+        self.assertEqual(result, expected)
+
+    def test_with_array_shape(self):
+        bbox = [[2, 10], [5, 15]]
+        pad_amount = 2
+        array_shape = (12, 20)
+        expected = [[0, 12], [3, 17]]
+        result = pad_bbox(bbox, pad_amount, array_shape)
+        self.assertEqual(result, expected)
+
+    def test_dimension_specific_padding(self):
+        bbox = [[2, 10], [5, 15]]
+        pad_amount = [3, 1]
+        expected = [[0, 13], [4, 16]]
+        result = pad_bbox(bbox, pad_amount)
+        self.assertEqual(result, expected)
+
+    def test_clipping_with_array_shape(self):
+        bbox = [[2, 10], [5, 15]]
+        pad_amount = 5
+        array_shape = (12, 18)
+        expected = [[0, 12], [0, 18]]
+        result = pad_bbox(bbox, pad_amount, array_shape)
+        self.assertEqual(result, expected)
+
+    def test_no_padding(self):
+        bbox = [[2, 10], [5, 15]]
+        pad_amount = 0
+        expected = [[2, 10], [5, 15]]
+        result = pad_bbox(bbox, pad_amount)
+        self.assertEqual(result, expected)
+
+if __name__ == "__main__":
+    unittest.main()