batchgeneratorsv2 0.3.6__tar.gz → 0.3.7__tar.gz

{batchgeneratorsv2-0.3.6 → batchgeneratorsv2-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: batchgeneratorsv2
-Version: 0.3.6
+Version: 0.3.7
 Summary: Batchgenerators but better
 Author: Helmholtz Imaging Applied Computer Vision Lab
 Author-email: Fabian Isensee <f.isensee@dkfz-heidelberg.de>

{batchgeneratorsv2-0.3.6 → batchgeneratorsv2-0.3.7}/batchgeneratorsv2/transforms/intensity/contrast.py

@@ -14,7 +14,9 @@ class BGContrast():
             factor = self.contrast_range()
         else:
             if np.random.random() < 0.5 and self.contrast_range[0] < 1:
-                factor = np.random.uniform(self.contrast_range[0], 1)
+                factor = np.random.uniform(self.contrast_range[0], min(1, self.contrast_range[1]))
+            elif self.contrast_range[1] <= 1:
+                factor = np.random.uniform(self.contrast_range[0], self.contrast_range[1])
             else:
                 factor = np.random.uniform(max(self.contrast_range[0], 1), self.contrast_range[1])
         return factor

{batchgeneratorsv2-0.3.6 → batchgeneratorsv2-0.3.7}/batchgeneratorsv2/transforms/spatial/spatial.py

@@ -5,7 +5,7 @@ from typing import Tuple, List, Union
 import numpy as np
 import pandas as pd
 import torch
-from scipy.ndimage import fourier_gaussian
+from scipy.ndimage import find_objects, fourier_gaussian
 from torch.nn.functional import grid_sample
 
 from batchgeneratorsv2.helpers.scalar_type import RandomScalar, sample_scalar
@@ -462,14 +462,21 @@ class SpatialTransform(BasicTransform):
                         nn_c = _nearest()[c]
                         nn_score = torch.full(nn_c.shape, float('-inf'), dtype=torch.float16)
                         is_nn = torch.empty(nn_c.shape, dtype=torch.bool)
+                        # A label can only be the nearest neighbour's inside the bounding box of its nearest
+                        # neighbour voxels, so that is all the bookkeeping has to look at: typically a few % of
+                        # the patch per label instead of all of it. One pass over nn_c finds every box.
+                        nn_boxes = _label_boxes(nn_c, int(labels[-1]))
                     else:
                         nn_c = None
                     better = torch.empty(tuple(self.patch_size), dtype=torch.bool)
                     for u in labels:
                         cur = _score(u)
                         if nn_c is not None:
-                            torch.eq(nn_c, u, out=is_nn)
-                            torch.where(is_nn, cur, nn_score, out=nn_score)
+                            box = _label_box(nn_boxes, u)
+                            if box is not None:
+                                is_nn_b, nn_score_b = is_nn[box], nn_score[box]
+                                torch.eq(nn_c[box], u, out=is_nn_b)
+                                torch.where(is_nn_b, cur[box], nn_score_b, out=nn_score_b)
                         if best_val is None:
                             best_val = cur
                             result_seg[c] = u.item()
@@ -498,6 +505,32 @@ class SpatialTransform(BasicTransform):
         raise NotImplementedError
     
 
+def _label_boxes(labels: torch.Tensor, max_label: int):
+    """
+    {label: tuple of slices}, the bounding box of every positive label in an integer label map whose largest
+    label is max_label, from one pass over it (scipy's find_objects). Labels <= 0 and labels that do not occur
+    have no entry. None where that does not apply - float or bool label maps, tensors not on the CPU, or label
+    values so large (instance ids, say) that find_objects' list of max_label entries would cost more than it
+    saves: callers then use the whole volume.
+    """
+    if (labels.device.type != 'cpu' or labels.dtype.is_floating_point or labels.dtype == torch.bool
+            or max_label > 65535):
+        return None
+    return {i + 1: b for i, b in enumerate(find_objects(labels.numpy(), max_label=max(max_label, 1)))
+            if b is not None}
+
+
+def _label_box(boxes, u):
+    """
+    Where label u can occur according to _label_boxes: its box, the whole volume (no boxes, or u <= 0, which
+    find_objects does not report), or None if it does not occur at all.
+    """
+    u = int(u)
+    if boxes is None or u <= 0:
+        return (slice(None),)
+    return boxes.get(u)
+
+
 def create_affine_matrix_3d(rotation_angles, scaling_factors):
     # Rotation matrices for each axis
     Rx = np.array([[1, 0, 0],

{batchgeneratorsv2-0.3.6 → batchgeneratorsv2-0.3.7}/batchgeneratorsv2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: batchgeneratorsv2
-Version: 0.3.6
+Version: 0.3.7
 Summary: Batchgenerators but better
 Author: Helmholtz Imaging Applied Computer Vision Lab
 Author-email: Fabian Isensee <f.isensee@dkfz-heidelberg.de>

{batchgeneratorsv2-0.3.6 → batchgeneratorsv2-0.3.7}/batchgeneratorsv2.egg-info/SOURCES.txt

@@ -59,4 +59,5 @@ batchgeneratorsv2/transforms/utils/pseudo2d.py
 batchgeneratorsv2/transforms/utils/random.py
 batchgeneratorsv2/transforms/utils/remove_label.py
 batchgeneratorsv2/transforms/utils/seg_to_regions.py
+tests/test_contrast.py
 tests/test_seg_sampling.py

{batchgeneratorsv2-0.3.6 → batchgeneratorsv2-0.3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "batchgeneratorsv2"
-version = "0.3.6"
+version = "0.3.7"
 requires-python = ">=3.9"
 description = "Batchgenerators but better"
 readme = "readme.md"

batchgeneratorsv2-0.3.7/tests/test_contrast.py

@@ -0,0 +1,42 @@
+import unittest
+from itertools import product
+
+import numpy as np
+
+from batchgeneratorsv2.transforms.intensity.contrast import BGContrast
+
+
+class TestBGContrast(unittest.TestCase):
+    """
+    Ranges that end at or below one must be sampled from the range, as in batchgenerators' contrast, gamma and scale
+    sampling. A range ending at one used to return exactly one for half of the draws.
+    """
+
+    def setUp(self):
+        self.addCleanup(np.random.set_state, np.random.get_state())
+
+    def test_ranges_up_to_one_are_respected(self):
+        for value_range, seed in product(((0.7, 0.9), (0.8, 0.8), (0.7, 1)), range(50)):
+            with self.subTest(value_range=value_range, seed=seed):
+                np.random.seed(seed)
+                factor = BGContrast(value_range)()
+                self.assertGreaterEqual(factor, value_range[0])
+                self.assertLessEqual(factor, value_range[1])
+                # uniform never returns its upper bound, so a factor of exactly one comes from the old upper branch
+                self.assertLess(factor, 1)
+
+    def test_number_of_draws_is_unchanged(self):
+        # a branch choice and the factor
+        for value_range in ((0.7, 0.9), (0.8, 0.8), (0.75, 1.25), (0.7, 1.5), (0.5, 2), (1.1, 1.5), (0.7, 1), (1, 1)):
+            with self.subTest(value_range=value_range):
+                expected = np.random.RandomState(0)
+                expected.random_sample(2)
+                np.random.seed(0)
+                BGContrast(value_range)()
+                actual_state, expected_state = np.random.get_state(), expected.get_state()
+                np.testing.assert_array_equal(actual_state[1], expected_state[1])
+                self.assertEqual(actual_state[2:], expected_state[2:])
+
+
+if __name__ == '__main__':
+    unittest.main()