biomedisa 24.8.5__tar.gz → 24.8.6__tar.gz

{biomedisa-24.8.5 → biomedisa-24.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biomedisa
-Version: 24.8.5
+Version: 24.8.6
 Summary: Segmentation of 3D volumetric image data
 Author: Philipp Lösel
 Author-email: philipp.loesel@anu.edu.au
@@ -41,12 +41,12 @@ Biomedisa (https://biomedisa.info) is a free and easy-to-use open-source applica
 ## Installation (command-line based)
 + [Ubuntu 22.04 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_interpolation_cli.md)
 + [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_cli.md)
-+ [Windows 10 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_cli.md)
++ [Windows 10/11 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_cli.md)
 + [Windows (WSL) + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows_wsl.md)
 
 ## Installation (3D Slicer extension)
 + [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_slicer.md)
-+ [Windows 10 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_slicer.md)
++ [Windows 10/11 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_slicer.md)
 
 ## Installation (browser based)
 + [Ubuntu 22.04](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8.md)

{biomedisa-24.8.5 → biomedisa-24.8.6}/README.md

@@ -25,12 +25,12 @@ Biomedisa (https://biomedisa.info) is a free and easy-to-use open-source applica
 ## Installation (command-line based)
 + [Ubuntu 22.04 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_interpolation_cli.md)
 + [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_cli.md)
-+ [Windows 10 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_cli.md)
++ [Windows 10/11 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_cli.md)
 + [Windows (WSL) + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows_wsl.md)
 
 ## Installation (3D Slicer extension)
 + [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_slicer.md)
-+ [Windows 10 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_slicer.md)
++ [Windows 10/11 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_slicer.md)
 
 ## Installation (browser based)
 + [Ubuntu 22.04](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8.md)

{biomedisa-24.8.5 → biomedisa-24.8.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "biomedisa"
-version = "24.8.5"
+version = "24.8.6"
 authors = [
   { name="Philipp Lösel"}, {email="philipp.loesel@anu.edu.au" },
 ]

{biomedisa-24.8.5 → biomedisa-24.8.6}/src/biomedisa/features/DataGenerator.py

@@ -129,39 +129,25 @@ class DataGenerator(tf.keras.utils.Sequence):
     def __len__(self):
         'Denotes the number of batches per epoch'
         if len(self.list_IDs_bg) > 0:
-            len_IDs = 2 * max(len(self.list_IDs_fg), len(self.list_IDs_bg))
+            len_IDs = max(len(self.list_IDs_fg), len(self.list_IDs_bg))
+            n_batches = len_IDs // (self.batch_size // 2)
         else:
             len_IDs = len(self.list_IDs_fg)
-        n_batches = int(np.floor(len_IDs / self.batch_size))
+            n_batches = len_IDs // self.batch_size
         return n_batches
 
     def __getitem__(self, index):
         'Generate one batch of data'
-
         if len(self.list_IDs_bg) > 0:
-
-            # len IDs
-            len_IDs = max(len(self.list_IDs_fg), len(self.list_IDs_bg))
-
-            # upsample lists of indexes to the same size
-            repetitions = int(np.floor(len_IDs / len(self.list_IDs_fg))) + 1
-            upsampled_indexes_fg = np.tile(self.indexes_fg, repetitions)
-            upsampled_indexes_fg = upsampled_indexes_fg[:len_IDs]
-
-            repetitions = int(np.floor(len_IDs / len(self.list_IDs_bg))) + 1
-            upsampled_indexes_bg = np.tile(self.indexes_bg, repetitions)
-            upsampled_indexes_bg = upsampled_indexes_bg[:len_IDs]
-
             # Generate indexes of the batch
-            tmp_batch_size = int(self.batch_size / 2)
-            indexes_fg = upsampled_indexes_fg[index*tmp_batch_size:(index+1)*tmp_batch_size]
-            indexes_bg = upsampled_indexes_bg[index*tmp_batch_size:(index+1)*tmp_batch_size]
+            half_batch_size = self.batch_size // 2
+            indexes_fg = self.indexes_fg[index*half_batch_size:(index+1)*half_batch_size]
+            indexes_bg = self.indexes_bg[index*half_batch_size:(index+1)*half_batch_size]
 
             # Find list of IDs
             list_IDs_temp = [self.list_IDs_fg[k] for k in indexes_fg] + [self.list_IDs_bg[k] for k in indexes_bg]
 
         else:
-
             # Generate indexes of the batch
             indexes_fg = self.indexes_fg[index*self.batch_size:(index+1)*self.batch_size]
 
@@ -175,11 +161,22 @@ class DataGenerator(tf.keras.utils.Sequence):
 
     def on_epoch_end(self):
         'Updates indexes after each epoch'
-        self.indexes_fg = np.arange(len(self.list_IDs_fg))
-        self.indexes_bg = np.arange(len(self.list_IDs_bg))
+        if len(self.list_IDs_bg) > 0:
+            # upsample lists of indexes
+            indexes_fg = np.arange(len(self.list_IDs_fg))
+            indexes_bg = np.arange(len(self.list_IDs_bg))
+            len_IDs = max(len(self.list_IDs_fg), len(self.list_IDs_bg))
+            repetitions = len_IDs // len(self.list_IDs_fg) + 1
+            self.indexes_fg = np.tile(indexes_fg, repetitions)
+            repetitions = len_IDs // len(self.list_IDs_bg) + 1
+            self.indexes_bg = np.tile(indexes_bg, repetitions)
+        else:
+            self.indexes_fg = np.arange(len(self.list_IDs_fg))
+        # shuffle indexes
         if self.shuffle == True:
             np.random.shuffle(self.indexes_fg)
-            np.random.shuffle(self.indexes_bg)
+            if len(self.list_IDs_bg) > 0:
+                np.random.shuffle(self.indexes_bg)
 
     def __data_generation(self, list_IDs_temp):
         'Generates data containing batch_size samples' # X : (n_samples, *dim, n_channels)

{biomedisa-24.8.5 → biomedisa-24.8.6}/src/biomedisa/features/DataGeneratorCrop.py

@@ -28,22 +28,25 @@
 
 import numpy as np
 import tensorflow as tf
-from scipy.ndimage import gaussian_filter, map_coordinates
+from scipy.ndimage import gaussian_filter, map_coordinates, rotate
+import random
 
 def elastic_transform(image, alpha=100, sigma=20):
-    zsh, ysh, xsh = image.shape
+    ysh, xsh, csh = image.shape
     dx = gaussian_filter((np.random.rand(ysh, xsh) * 2 - 1) * alpha, sigma)
     dy = gaussian_filter((np.random.rand(ysh, xsh) * 2 - 1) * alpha, sigma)
     y, x = np.meshgrid(np.arange(ysh), np.arange(xsh), indexing='ij')
     indices = np.reshape(y+dy, (-1, 1)), np.reshape(x+dx, (-1, 1))
-    for k in range(zsh):
-        image[k] = map_coordinates(image[k], indices, order=1, mode='reflect').reshape(ysh, xsh)
+    for k in range(csh):
+        image[:,:,k] = map_coordinates(image[:,:,k], indices, order=0, mode='reflect').reshape(ysh, xsh)
     return image
 
 class DataGeneratorCrop(tf.keras.utils.Sequence):
     'Generates data for Keras'
-    def __init__(self, img, label, list_IDs_fg, list_IDs_bg, batch_size=32, dim=(32,32,32),
-                 n_channels=3, n_classes=2, shuffle=True):
+    def __init__(self, img, label, list_IDs_fg, list_IDs_bg, batch_size=32,
+            dim=(32,32,32), n_channels=3, n_classes=2, shuffle=True,
+            augment=(False,False,False,0), train=True):
+
         'Initialization'
         self.dim = dim
         self.list_IDs_fg = list_IDs_fg
@@ -54,6 +57,8 @@ class DataGeneratorCrop(tf.keras.utils.Sequence):
         self.n_channels = n_channels
         self.n_classes = n_classes
         self.shuffle = shuffle
+        self.augment = augment
+        self.train = train
         self.on_epoch_end()
 
     def __len__(self):
@@ -108,14 +113,37 @@ class DataGeneratorCrop(tf.keras.utils.Sequence):
     def __data_generation(self, list_IDs_temp):
         'Generates data containing batch_size samples' # X : (n_samples, *dim, n_channels)
 
+        # get augmentation parameter
+        flip_x, flip_y, flip_z, rotation = self.augment
+        elastic = False
+
         # Initialization
         X = np.empty((self.batch_size, *self.dim, self.n_channels), dtype=np.uint8)
         y = np.empty((self.batch_size,), dtype=np.int32)
 
         # Generate data
         for i, ID in enumerate(list_IDs_temp):
-            X[i,...] = self.img[ID,...]
-            y[i] = self.label[ID]
+            tmp_X = self.img[ID,...].copy()
+
+            # augmentation
+            if self.train and (any(self.augment) or elastic):
+                if flip_x and np.random.randint(2) and abs(self.label[ID])!=3:
+                    tmp_X = np.flip(tmp_X, 1)
+                if flip_y and np.random.randint(2):
+                    if abs(self.label[ID])==1:
+                        tmp_X = np.flip(tmp_X, 0)
+                    elif abs(self.label[ID])==3:
+                        tmp_X = np.flip(tmp_X, 1)
+                if flip_z and np.random.randint(2) and abs(self.label[ID])!=1:
+                    tmp_X = np.flip(tmp_X, 0)
+                if rotation:
+                    angle = random.uniform(-rotation, rotation)
+                    tmp_X = rotate(tmp_X, angle, order=0, mode='reflect', reshape=False)
+                if elastic:
+                    tmp_X = elastic_transform(tmp_X)
+
+            X[i,...] = tmp_X
+            y[i] = 0 if self.label[ID] < 0 else 1
 
         return X, y
 

{biomedisa-24.8.5 → biomedisa-24.8.6}/src/biomedisa/features/crop_helper.py

@@ -44,6 +44,7 @@ import h5py
 import tarfile
 import matplotlib.pyplot as plt
 import tempfile
+import copy
 
 class InputError(Exception):
     def __init__(self, message=None):
@@ -117,9 +118,12 @@ def load_cropping_training_data(normalize, img_list, label_list, x_scale, y_scal
                 a = label_in
             a = a.astype(np.uint8)
             a = set_labels_to_zero(a, labels_to_compute, labels_to_remove)
-            label_z = np.any(a,axis=(1,2))
-            label_y = np.any(a,axis=(0,2))
-            label_x = np.any(a,axis=(0,1))
+            label_z = np.any(a,axis=(1,2)).astype(np.int8) * 1
+            label_y = np.any(a,axis=(0,2)).astype(np.int8) * 2
+            label_x = np.any(a,axis=(0,1)).astype(np.int8) * 3
+            label_z[label_z==0] = -1
+            label_y[label_y==0] = -2
+            label_x[label_x==0] = -3
             label = np.append(label_z,label_y,axis=0)
             label = np.append(label,label_x,axis=0)
 
@@ -178,12 +182,15 @@ def load_cropping_training_data(normalize, img_list, label_list, x_scale, y_scal
                         a = label_in[k]
                     a = a.astype(np.uint8)
                     a = set_labels_to_zero(a, labels_to_compute, labels_to_remove)
-                    next_label_z = np.any(a,axis=(1,2))
-                    next_label_y = np.any(a,axis=(0,2))
-                    next_label_x = np.any(a,axis=(0,1))
-                    label = np.append(label,next_label_z,axis=0)
-                    label = np.append(label,next_label_y,axis=0)
-                    label = np.append(label,next_label_x,axis=0)
+                    label_z = np.any(a,axis=(1,2)).astype(np.int8) * 1
+                    label_y = np.any(a,axis=(0,2)).astype(np.int8) * 2
+                    label_x = np.any(a,axis=(0,1)).astype(np.int8) * 3
+                    label_z[label_z==0] = -1
+                    label_y[label_y==0] = -2
+                    label_x[label_x==0] = -3
+                    label = np.append(label,label_z,axis=0)
+                    label = np.append(label,label_y,axis=0)
+                    label = np.append(label,label_x,axis=0)
 
                     # append image
                     if any(img_list):
@@ -228,20 +235,20 @@ def load_cropping_training_data(normalize, img_list, label_list, x_scale, y_scal
     return img_rgb, label, normalization_parameters, channels
 
 def train_cropping(img, label, path_to_model, epochs, batch_size,
-                    validation_split, flip_x, flip_y, flip_z, rotate,
-                    img_val, label_val):
+    validation_split, flip_x, flip_y, flip_z, rotate,
+    img_val, label_val):
 
     # img shape
     zsh, ysh, xsh, channels = img.shape
 
     # list of IDs
-    list_IDs_fg = list(np.where(label)[0])
-    list_IDs_bg = list(np.where(label==False)[0])
+    list_IDs_fg = list(np.where(label>0)[0])
+    list_IDs_bg = list(np.where(label<0)[0])
 
     # validation data
     if np.any(img_val):
-        list_IDs_val_fg = list(np.where(label_val)[0])
-        list_IDs_val_bg = list(np.where(label_val==False)[0])
+        list_IDs_val_fg = list(np.where(label_val>0)[0])
+        list_IDs_val_bg = list(np.where(label_val<0)[0])
     elif validation_split:
         split_fg = int(len(list_IDs_fg) * validation_split)
         split_bg = int(len(list_IDs_bg) * validation_split)
@@ -287,14 +294,13 @@ def train_cropping(img, label, path_to_model, epochs, batch_size,
               'batch_size': batch_size,
               'n_classes': 2,
               'n_channels': channels,
-              'shuffle': True}
+              'shuffle': True,
+              'augment': (flip_x, flip_y, flip_z, rotate),
+              'train': True}
 
     # validation parameters
-    params_val = {'dim': (ysh, xsh),
-                  'batch_size': batch_size,
-                  'n_classes': 2,
-                  'n_channels': channels,
-                  'shuffle': False}
+    params_val = copy.deepcopy(params)
+    params_val['train'] = False
 
     # data generator
     training_generator = DataGeneratorCrop(img, label, list_IDs_fg, list_IDs_bg, **params)
@@ -497,7 +503,7 @@ def crop_volume(img, path_to_model, path_to_final, z_shape, y_shape, x_shape, ba
 # main functions
 #=====================
 
-def load_and_train(bm, x_scale=256, y_scale=256, z_scale=256):
+def load_and_train(bm, x_scale=256, y_scale=256, z_scale=256, batch_size=24):
 
     # load training data
     img, label, normalization_parameters, channels = load_cropping_training_data(bm.normalize,
@@ -512,8 +518,8 @@ def load_and_train(bm, x_scale=256, y_scale=256, z_scale=256):
             bm.only, bm.ignore, bm.val_img_data, bm.val_label_data, normalization_parameters, channels)
 
     # train cropping
-    train_cropping(img, label, bm.path_to_model, bm.cropping_epochs,
-        bm.batch_size, bm.validation_split,
+    train_cropping(img, label, bm.path_to_model,
+        bm.cropping_epochs, batch_size, bm.validation_split,
         bm.flip_x, bm.flip_y, bm.flip_z, bm.rotate,
         img_val, label_val)
 
@@ -531,7 +537,7 @@ def load_and_train(bm, x_scale=256, y_scale=256, z_scale=256):
 
     return cropping_weights, cropping_config, normalization_parameters
 
-def crop_data(bm):
+def crop_data(bm, batch_size=32):
 
     # get meta data
     hf = h5py.File(bm.path_to_model, 'r')
@@ -554,7 +560,7 @@ def crop_data(bm):
 
     # make prediction
     z_lower, z_upper, y_lower, y_upper, x_lower, x_upper, cropped_volume = crop_volume(img, bm.path_to_model,
-        bm.path_to_cropped_image, z_shape, y_shape, x_shape, bm.batch_size, bm.debug_cropping, bm.save_cropped, bm.img_data)
+        bm.path_to_cropped_image, z_shape, y_shape, x_shape, batch_size, bm.debug_cropping, bm.save_cropped, bm.img_data)
 
     # region of interest
     region_of_interest = np.array([z_lower, z_upper, y_lower, y_upper, x_lower, x_upper])

{biomedisa-24.8.5 → biomedisa-24.8.6}/src/biomedisa/features/keras_helper.py

@@ -400,6 +400,12 @@ def load_training_data(bm, img_list, label_list, channels, img_in=None, label_in
                 label = label_in
                 label_names = ['label_1']
             label_dim = label.shape
+            # no-scaling for list of images needs negative values as it encodes padded areas as -1
+            label_dtype = label.dtype
+            if label_dtype==np.uint8:
+                label_dtype = np.int16
+            elif label_dtype in [np.uint16, np.uint32]:
+                label_dtype = np.int32
             label = set_labels_to_zero(label, bm.only, bm.ignore)
             if any([bm.x_range, bm.y_range, bm.z_range]):
                 if len(label_names)>1:
@@ -475,6 +481,11 @@ def load_training_data(bm, img_list, label_list, channels, img_in=None, label_in
                     img[:,:,:,c] = (img[:,:,:,c] - mean) / std
                     img[:,:,:,c] = img[:,:,:,c] * normalization_parameters[1,c] + normalization_parameters[0,c]
 
+            # pad data
+            if not bm.scaling:
+                img_data_list = [img]
+                label_data_list = [label]
+
             # loop over list of images
             if any(img_list) or type(img_in) is list:
                 number_of_images = len(img_names) if any(img_list) else len(img_in)
@@ -498,7 +509,9 @@ def load_training_data(bm, img_list, label_list, channels, img_in=None, label_in
                         label_values, counts = np.unique(a, return_counts=True)
                         print(f'{os.path.basename(label_names[k])}:', 'Labels:', label_values[1:], 'Sizes:', counts[1:])
                         a = img_resize(a, bm.z_scale, bm.y_scale, bm.x_scale, labels=True)
-                    label = np.append(label, a, axis=0)
+                        label = np.append(label, a, axis=0)
+                    else:
+                        label_data_list.append(a)
 
                     # append image
                     if any(img_list):
@@ -529,11 +542,33 @@ def load_training_data(bm, img_list, label_list, channels, img_in=None, label_in
                             mean, std = np.mean(a[:,:,:,c]), np.std(a[:,:,:,c])
                             a[:,:,:,c] = (a[:,:,:,c] - mean) / std
                             a[:,:,:,c] = a[:,:,:,c] * normalization_parameters[1,c] + normalization_parameters[0,c]
-                    img = np.append(img, a, axis=0)
+                    if bm.scaling:
+                        img = np.append(img, a, axis=0)
+                    else:
+                        img_data_list.append(a)
+
+    # pad and append data to a single volume
+    if not bm.scaling and len(img_data_list)>1:
+        target_y, target_x = 0, 0
+        for img in img_data_list:
+            target_y = max(target_y, img.shape[1])
+            target_x = max(target_x, img.shape[2])
+        img = np.empty((0, target_y, target_x, channels), dtype=np.float32)
+        label = np.empty((0, target_y, target_x), dtype=label_dtype)
+        for k in range(len(img_data_list)):
+            pad_y = target_y - img_data_list[k].shape[1]
+            pad_x = target_x - img_data_list[k].shape[2]
+            pad_width = [(0, 0), (0, pad_y), (0, pad_x), (0, 0)]
+            tmp = np.pad(img_data_list[k], pad_width, mode='constant', constant_values=0)
+            img = np.append(img, tmp, axis=0)
+            pad_width = [(0, 0), (0, pad_y), (0, pad_x)]
+            tmp = np.pad(label_data_list[k].astype(label_dtype), pad_width, mode='constant', constant_values=-1)
+            label = np.append(label, tmp, axis=0)
 
     # limit intensity range
-    img[img<0] = 0
-    img[img>1] = 1
+    if bm.normalize:
+        img[img<0] = 0
+        img[img>1] = 1
 
     if bm.separation:
         allLabels = np.array([0,1])
@@ -541,6 +576,8 @@ def load_training_data(bm, img_list, label_list, channels, img_in=None, label_in
         # get labels
         if allLabels is None:
             allLabels = np.unique(label)
+            index = np.argwhere(allLabels<0)
+            allLabels = np.delete(allLabels, index)
 
         # labels must be in ascending order
         for k, l in enumerate(allLabels):
@@ -833,25 +870,30 @@ def train_segmentation(bm):
     list_IDs_fg, list_IDs_bg = [], []
 
     # get IDs of patches
-    if bm.balance:
-        for k in range(0, zsh-bm.z_patch+1, bm.stride_size):
-            for l in range(0, ysh-bm.y_patch+1, bm.stride_size):
-                for m in range(0, xsh-bm.x_patch+1, bm.stride_size):
-                    if np.any(bm.label_data[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]):
-                        list_IDs_fg.append(k*ysh*xsh+l*xsh+m)
-                    else:
-                        list_IDs_bg.append(k*ysh*xsh+l*xsh+m)
-    else:
-        for k in range(0, zsh-bm.z_patch+1, bm.stride_size):
-            for l in range(0, ysh-bm.y_patch+1, bm.stride_size):
-                for m in range(0, xsh-bm.x_patch+1, bm.stride_size):
-                    if bm.separation:
-                        centerLabel = bm.label_data[k+bm.z_patch//2,l+bm.y_patch//2,m+bm.x_patch//2]
-                        patch = bm.label_data[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
-                        if centerLabel>0 and np.any(patch!=centerLabel):
-                            list_IDs_fg.append(k*ysh*xsh+l*xsh+m)
+    for k in range(0, zsh-bm.z_patch+1, bm.stride_size):
+        for l in range(0, ysh-bm.y_patch+1, bm.stride_size):
+            for m in range(0, xsh-bm.x_patch+1, bm.stride_size):
+                patch = bm.label_data[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+                index = k*ysh*xsh+l*xsh+m
+                if not np.any(patch==-1): # ignore padded areas
+                    if bm.balance:
+                        if bm.separation:
+                            centerLabel = bm.label_data[k+bm.z_patch//2,l+bm.y_patch//2,m+bm.x_patch//2]
+                            if centerLabel>0 and np.any(np.logical_and(patch!=centerLabel, patch>0)):
+                                list_IDs_fg.append(index)
+                            elif centerLabel>0 and np.any(patch!=centerLabel):
+                                list_IDs_bg.append(index)
+                        elif np.any(patch>0):
+                            list_IDs_fg.append(index)
+                        else:
+                            list_IDs_bg.append(index)
                     else:
-                        list_IDs_fg.append(k*ysh*xsh+l*xsh+m)
+                        if bm.separation:
+                            centerLabel = bm.label_data[k+bm.z_patch//2,l+bm.y_patch//2,m+bm.x_patch//2]
+                            if centerLabel>0 and np.any(patch!=centerLabel):
+                                list_IDs_fg.append(index)
+                        else:
+                            list_IDs_fg.append(index)
 
     if bm.val_img_data is not None:
 
@@ -862,25 +904,35 @@ def train_segmentation(bm):
         list_IDs_val_fg, list_IDs_val_bg = [], []
 
         # get validation IDs of patches
-        if bm.balance and not bm.val_dice:
-            for k in range(0, zsh_val-bm.z_patch+1, bm.validation_stride_size):
-                for l in range(0, ysh_val-bm.y_patch+1, bm.validation_stride_size):
-                    for m in range(0, xsh_val-bm.x_patch+1, bm.validation_stride_size):
-                        if np.any(bm.val_label_data[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]):
-                            list_IDs_val_fg.append(k*ysh_val*xsh_val+l*xsh_val+m)
-                        else:
-                            list_IDs_val_bg.append(k*ysh_val*xsh_val+l*xsh_val+m)
-        else:
-            for k in range(0, zsh_val-bm.z_patch+1, bm.validation_stride_size):
-                for l in range(0, ysh_val-bm.y_patch+1, bm.validation_stride_size):
-                    for m in range(0, xsh_val-bm.x_patch+1, bm.validation_stride_size):
-                        if bm.separation:
-                            centerLabel = bm.val_label_data[k+bm.z_patch//2,l+bm.y_patch//2,m+bm.x_patch//2]
-                            patch = bm.val_label_data[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
-                            if centerLabel>0 and np.any(patch!=centerLabel):
-                                list_IDs_val_fg.append(k*ysh_val*xsh_val+l*xsh_val+m)
+        for k in range(0, zsh_val-bm.z_patch+1, bm.validation_stride_size):
+            for l in range(0, ysh_val-bm.y_patch+1, bm.validation_stride_size):
+                for m in range(0, xsh_val-bm.x_patch+1, bm.validation_stride_size):
+                    patch = bm.val_label_data[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+                    index = k*ysh_val*xsh_val+l*xsh_val+m
+                    if not np.any(patch==-1): # ignore padded areas
+                        if bm.balance and not bm.val_dice:
+                            if bm.separation:
+                                centerLabel = bm.val_label_data[k+bm.z_patch//2,l+bm.y_patch//2,m+bm.x_patch//2]
+                                if centerLabel>0 and np.any(np.logical_and(patch!=centerLabel, patch>0)):
+                                    list_IDs_val_fg.append(index)
+                                elif centerLabel>0 and np.any(patch!=centerLabel):
+                                    list_IDs_val_bg.append(index)
+                            elif np.any(patch>0):
+                                list_IDs_val_fg.append(index)
+                            else:
+                                list_IDs_val_bg.append(index)
                         else:
-                            list_IDs_val_fg.append(k*ysh_val*xsh_val+l*xsh_val+m)
+                            if bm.separation:
+                                centerLabel = bm.val_label_data[k+bm.z_patch//2,l+bm.y_patch//2,m+bm.x_patch//2]
+                                if centerLabel>0 and np.any(patch!=centerLabel):
+                                    list_IDs_val_fg.append(index)
+                            else:
+                                list_IDs_val_fg.append(index)
+
+    # remove padding label
+    bm.label_data[bm.label_data<0]=0
+    if bm.val_img_data is not None:
+        bm.val_label_data[bm.val_label_data<0]=0
 
     # number of labels
     nb_labels = len(allLabels)

{biomedisa-24.8.5 → biomedisa-24.8.6}/src/biomedisa.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biomedisa
-Version: 24.8.5
+Version: 24.8.6
 Summary: Segmentation of 3D volumetric image data
 Author: Philipp Lösel
 Author-email: philipp.loesel@anu.edu.au
@@ -41,12 +41,12 @@ Biomedisa (https://biomedisa.info) is a free and easy-to-use open-source applica
 ## Installation (command-line based)
 + [Ubuntu 22.04 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_interpolation_cli.md)
 + [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_cli.md)
-+ [Windows 10 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_cli.md)
++ [Windows 10/11 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_cli.md)
 + [Windows (WSL) + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows_wsl.md)
 
 ## Installation (3D Slicer extension)
 + [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_slicer.md)
-+ [Windows 10 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_slicer.md)
++ [Windows 10/11 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_slicer.md)
 
 ## Installation (browser based)
 + [Ubuntu 22.04](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8.md)