biomedisa 24.8.5__py3-none-any.whl → 24.8.7__py3-none-any.whl

biomedisa/deeplearning.py

@@ -71,7 +71,7 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
     learning_rate=0.01, stride_size=32, validation_stride_size=32, validation_freq=1,
     batch_size=None, x_scale=256, y_scale=256, z_scale=256, scaling=True, early_stopping=0,
     pretrained_model=None, fine_tune=False, workers=1, cropping_epochs=50,
-    x_range=None, y_range=None, z_range=None, header=None, extension='.tif',
+    x_range=None, y_range=None, z_range=None, header=None, extension=None,
     img_header=None, img_extension='.tif', average_dice=False, django_env=False,
     path=None, success=True, return_probs=False, patch_normalization=False,
     z_patch=64, y_patch=64, x_patch=64, path_to_logfile=None, img_id=None, label_id=None,
@@ -228,9 +228,11 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
             bm.scaling = bool(meta['scaling'][()])
 
         # check if amira header is available in the network
-        if bm.header is None and meta.get('header') is not None:
+        if bm.extension is None and bm.header is None and meta.get('header') is not None:
             bm.header = [np.array(meta.get('header'))]
             bm.extension = '.am'
+        if bm.extension is None:
+            bm.extension = '.tif'
 
         # crop data
         crop_data = True if 'cropping_weights' in hf else False
@@ -301,6 +303,12 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
                 results, bm = predict_segmentation(bm, region_of_interest,
                     channels, normalization_parameters)
 
+                from mpi4py import MPI
+                comm = MPI.COMM_WORLD
+                rank = comm.Get_rank()
+                if rank>0:
+                    return 0
+
                 # results
                 if cropped_volume is not None:
                     results['cropped_volume'] = cropped_volume
@@ -488,8 +496,8 @@ if __name__ == '__main__':
                         help='Location of mask')
     parser.add_argument('-rf','--refinement', action='store_true', default=False,
                         help='Refine segmentation on full size data')
-    parser.add_argument('-ext','--extension', type=str, default='.tif',
-                        help='Save data for example as NRRD file using --extension=".nrrd"')
+    parser.add_argument('-ext','--extension', type=str, default=None,
+                        help='Save data in formats like NRRD or TIFF using --extension=".nrrd"')
     bm = parser.parse_args()
     bm.success = True
 

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/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/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/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:
@@ -418,8 +424,6 @@ def load_training_data(bm, img_list, label_list, channels, img_in=None, label_in
 
             # if header is not single data stream Amira Mesh falling back to Multi-TIFF
             if extension != '.am':
-                if extension != '.tif':
-                    print(f'Warning! Please use --header_file="path_to_training_label{extension}" for prediction to save your result as "{extension}"')
                 extension, header = '.tif', None
             elif len(header) > 1:
                 print('Warning! Multiple data streams are not supported. Falling back to TIFF.')
@@ -475,6 +479,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 +507,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 +540,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 +574,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):
@@ -761,6 +796,35 @@ class Metrics(Callback):
                 if self.early_stopping > 0 and max(self.history['val_dice']) not in self.history['val_dice'][-self.early_stopping:]:
                     self.model.stop_training = True
 
+class HistoryCallback(Callback):
+    def __init__(self, bm):
+        self.path_to_model = bm.path_to_model
+        self.train_dice = bm.train_dice
+        self.val_img_data = bm.val_img_data
+
+    def on_train_begin(self, logs={}):
+        self.history = {}
+        self.history['loss'] = []
+        self.history['accuracy'] = []
+        if self.train_dice:
+            self.history['dice'] = []
+        if self.val_img_data is not None:
+            self.history['val_loss'] = []
+            self.history['val_accuracy'] = []
+
+    def on_epoch_end(self, epoch, logs={}):
+        # append history
+        self.history['loss'].append(logs['loss'])
+        self.history['accuracy'].append(logs['accuracy'])
+        if self.train_dice:
+            self.history['dice'].append(logs['dice'])
+        if self.val_img_data is not None:
+            self.history['val_loss'].append(logs['val_loss'])
+            self.history['val_accuracy'].append(logs['val_accuracy'])
+
+        # plot history in figure and save as numpy array
+        save_history(self.history, self.path_to_model)
+
 def softmax(x):
     # Avoiding numerical instability by subtracting the maximum value
     exp_values = np.exp(x - np.max(x, axis=-1, keepdims=True))
@@ -833,25 +897,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 +931,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)
+        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_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)
-                        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)
@@ -968,11 +1047,11 @@ def train_segmentation(bm):
                 monitor='val_accuracy',
                 mode='max',
                 save_best_only=True)
-            callbacks = [model_checkpoint_callback, meta_data]
+            callbacks = [model_checkpoint_callback, HistoryCallback(bm), meta_data]
             if bm.early_stopping > 0:
                 callbacks.insert(0, EarlyStopping(monitor='val_accuracy', mode='max', patience=bm.early_stopping))
     else:
-        callbacks = [ModelCheckpoint(filepath=str(bm.path_to_model)), meta_data]
+        callbacks = [ModelCheckpoint(filepath=str(bm.path_to_model)), HistoryCallback(bm), meta_data]
 
     # monitor dice score on training data
     if bm.train_dice:
@@ -983,15 +1062,11 @@ def train_segmentation(bm):
         callbacks.insert(-1, CustomCallback(bm.img_id, bm.epochs))
 
     # train model
-    history = model.fit(training_generator,
-              epochs=bm.epochs,
-              validation_data=validation_generator,
-              callbacks=callbacks,
-              workers=bm.workers)
-
-    # save monitoring figure on train end
-    if bm.val_img_data is None or not bm.val_dice:
-        save_history(history.history, bm.path_to_model)
+    model.fit(training_generator,
+        epochs=bm.epochs,
+        validation_data=validation_generator,
+        callbacks=callbacks,
+        workers=bm.workers)
 
 def load_prediction_data(bm, channels, normalize, normalization_parameters,
     region_of_interest, img, img_header, load_blockwise=False, z=None):
@@ -1099,6 +1174,21 @@ def gradient(volData):
 
 def predict_segmentation(bm, region_of_interest, channels, normalization_parameters):
 
+    from mpi4py import MPI
+    comm = MPI.COMM_WORLD
+    rank = comm.Get_rank()
+    ngpus = comm.Get_size()
+
+    # Set the visible GPU by ID
+    gpus = tf.config.experimental.list_physical_devices('GPU')
+    if gpus:
+        try:
+            # Restrict TensorFlow to only use the specified GPU
+            tf.config.experimental.set_visible_devices(gpus[rank], 'GPU')
+            tf.config.experimental.set_memory_growth(gpus[rank], True)
+        except RuntimeError as e:
+            print(e)
+
     # initialize results
     results = {}
 
@@ -1125,6 +1215,7 @@ def predict_segmentation(bm, region_of_interest, channels, normalization_paramet
     load_blockwise = False
     if not bm.scaling and not bm.normalize and bm.path_to_image and not np.any(region_of_interest) and \
       os.path.splitext(bm.path_to_image)[1] in ['.tif', '.tiff'] and not bm.acwe:
+        # get image shape
         tif = TiffFile(bm.path_to_image)
         zsh = len(tif.pages)
         ysh, xsh = tif.pages[0].shape
@@ -1240,17 +1331,23 @@ def predict_segmentation(bm, region_of_interest, channels, normalization_paramet
         # stream data batchwise to GPU to reduce memory usage
         X = np.empty((bm.batch_size, bm.z_patch, bm.y_patch, bm.x_patch, channels), dtype=np.float32)
 
-        # allocate final array
-        if bm.return_probs:
+        # allocate final probabilities array
+        if rank==0 and bm.return_probs:
             final = np.zeros((zsh, ysh, xsh, nb_labels), dtype=np.float32)
 
-        # allocate result array
-        label = np.zeros((zsh, ysh, xsh), dtype=np.uint8)
+        # allocate final result array
+        if rank==0:
+            label = np.zeros((zsh, ysh, xsh), dtype=np.uint8)
 
         # predict segmentation block by block
         z_indices = range(0, zsh-bm.z_patch+1, bm.stride_size)
         for j, z in enumerate(z_indices):
-
+          # handle len(z_indices) % ngpus != 0
+          if len(z_indices)-1-j < ngpus:
+            nprocs = len(z_indices)-j
+          else:
+            nprocs = ngpus
+          if j % ngpus == rank:
             # load blockwise from TIFF
             if load_blockwise:
                 img, _, _, _, _, _, _ = load_prediction_data(bm,
@@ -1284,8 +1381,11 @@ def predict_segmentation(bm, region_of_interest, channels, normalization_paramet
             # number of patches
             nb_patches = len(list_IDs_block)
 
-            # allocate tmp probabilities array
-            probs = np.zeros((bm.z_patch, ysh, xsh, nb_labels), dtype=np.float32)
+            # allocate block array
+            if bm.separation:
+                block_label = np.zeros((bm.z_patch, ysh, xsh), dtype=np.uint8)
+            else:
+                block_probs = np.zeros((bm.z_patch, ysh, xsh, nb_labels), dtype=np.float32)
 
             # get one batch of image patches
             for step in range(nb_patches//bm.batch_size):
@@ -1317,157 +1417,186 @@ def predict_segmentation(bm, region_of_interest, channels, normalization_paramet
                     if step*bm.batch_size+i < max_i_block:
                         if bm.separation:
                             patch = np.argmax(Y[i], axis=-1).astype(np.uint8)
-                            label[z:z+bm.z_patch,l:l+bm.y_patch,m:m+bm.x_patch] += gradient(patch)
+                            block_label[:,l:l+bm.y_patch,m:m+bm.x_patch] += gradient(patch)
                         else:
-                            probs[:,l:l+bm.y_patch,m:m+bm.x_patch] += Y[i]
-
-            if not bm.separation:
-                # overlap in z direction
-                if bm.stride_size < bm.z_patch:
-                    if j>0:
-                        probs[:bm.stride_size] += overlap
-                    overlap = probs[bm.stride_size:].copy()
-
-                # calculate result
-                if z==z_indices[-1]:
-                    label[z:z+bm.z_patch] = np.argmax(probs, axis=-1).astype(np.uint8)
-                    if bm.return_probs:
-                        final[z:z+bm.z_patch] = probs
+                            block_probs[:,l:l+bm.y_patch,m:m+bm.x_patch] += Y[i]
+
+            # communicate results
+            if bm.separation:
+                if rank==0:
+                    label[z:z+bm.z_patch] += block_label
+                    for source in range(1, nprocs):
+                        receivedata = np.empty_like(block_label)
+                        for i in range(bm.z_patch):
+                            comm.Recv([receivedata[i], MPI.BYTE], source=source, tag=i)
+                        block_start = z_indices[j+source]
+                        label[block_start:block_start+bm.z_patch] += receivedata
                 else:
-                    block_zsh = min(bm.stride_size, bm.z_patch)
-                    label[z:z+block_zsh] = np.argmax(probs[:block_zsh], axis=-1).astype(np.uint8)
-                    if bm.return_probs:
-                        final[z:z+block_zsh] = probs[:block_zsh]
-
-    # refine mask data with result
-    if bm.refinement:
-        # loop over boundary patches
-        for i, ID in enumerate(list_IDs):
-            if i < max_i:
-                k = ID // (ysh*xsh)
-                rest = ID % (ysh*xsh)
-                l = rest // xsh
-                m = rest % xsh
-                mask[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch] = label[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
-        label = mask
-
-    # remove appendix
-    if bm.return_probs:
-        final = final[:-z_rest,:-y_rest,:-x_rest]
-    label = label[:-z_rest,:-y_rest,:-x_rest]
-    zsh, ysh, xsh = label.shape
-
-    # return probabilities
-    if bm.return_probs:
-        counter = np.zeros((zsh, ysh, xsh, nb_labels), dtype=np.float32)
-        nb = 0
-        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):
-                    counter[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch] += 1
-                    nb += 1
-        counter[counter==0] = 1
-        probabilities = final / counter
+                    for i in range(bm.z_patch):
+                        comm.Send([block_label[i].copy(), MPI.BYTE], dest=0, tag=i)
+            else:
+                if rank==0:
+                    for source in range(nprocs):
+                        if source>0:
+                            probs = np.empty_like(block_probs)
+                            for i in range(bm.z_patch):
+                                comm.Recv([probs[i], MPI.FLOAT], source=source, tag=i)
+                        else:
+                            probs = block_probs
+
+                        # overlap in z direction
+                        if bm.stride_size < bm.z_patch:
+                            if j+source>0:
+                                probs[:bm.stride_size] += overlap
+                            overlap = probs[bm.stride_size:].copy()
+
+                        # calculate result
+                        block_z = z_indices[j+source]
+                        if j+source==len(z_indices)-1:
+                            label[block_z:block_z+bm.z_patch] = np.argmax(probs, axis=-1).astype(np.uint8)
+                            if bm.return_probs:
+                                final[block_z:block_z+bm.z_patch] = probs
+                        else:
+                            block_zsh = min(bm.stride_size, bm.z_patch)
+                            label[block_z:block_z+block_zsh] = np.argmax(probs[:block_zsh], axis=-1).astype(np.uint8)
+                            if bm.return_probs:
+                                final[block_z:block_z+block_zsh] = probs[:block_zsh]
+                else:
+                    for i in range(bm.z_patch):
+                        comm.Send([block_probs[i].copy(), MPI.FLOAT], dest=0, tag=i)
+    if rank==0:
+
+        # refine mask data with result
+        if bm.refinement:
+            # loop over boundary patches
+            for i, ID in enumerate(list_IDs):
+                if i < max_i:
+                    k = ID // (ysh*xsh)
+                    rest = ID % (ysh*xsh)
+                    l = rest // xsh
+                    m = rest % xsh
+                    mask[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch] = label[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+            label = mask
+
+        # remove appendix
+        if bm.return_probs:
+            final = final[:-z_rest,:-y_rest,:-x_rest]
+        label = label[:-z_rest,:-y_rest,:-x_rest]
+        zsh, ysh, xsh = label.shape
+
+        # return probabilities
+        if bm.return_probs:
+            counter = np.zeros((zsh, ysh, xsh, nb_labels), dtype=np.float32)
+            nb = 0
+            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):
+                        counter[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch] += 1
+                        nb += 1
+            counter[counter==0] = 1
+            probabilities = final / counter
+            if bm.scaling:
+                probabilities = img_resize(probabilities, z_shape, y_shape, x_shape)
+            if np.any(region_of_interest):
+                min_z,max_z,min_y,max_y,min_x,max_x,original_zsh,original_ysh,original_xsh = region_of_interest[:]
+                tmp = np.zeros((original_zsh, original_ysh, original_xsh, nb_labels), dtype=np.float32)
+                tmp[min_z:max_z,min_y:max_y,min_x:max_x] = probabilities
+                probabilities = np.copy(tmp, order='C')
+            results['probs'] = probabilities
+
+        # rescale final to input size
         if bm.scaling:
-            probabilities = img_resize(probabilities, z_shape, y_shape, x_shape)
+            label = img_resize(label, z_shape, y_shape, x_shape, labels=True)
+
+        # revert automatic cropping
         if np.any(region_of_interest):
             min_z,max_z,min_y,max_y,min_x,max_x,original_zsh,original_ysh,original_xsh = region_of_interest[:]
-            tmp = np.zeros((original_zsh, original_ysh, original_xsh, nb_labels), dtype=np.float32)
-            tmp[min_z:max_z,min_y:max_y,min_x:max_x] = probabilities
-            probabilities = np.copy(tmp, order='C')
-        results['probs'] = probabilities
-
-    # rescale final to input size
-    if bm.scaling:
-        label = img_resize(label, z_shape, y_shape, x_shape, labels=True)
+            tmp = np.zeros((original_zsh, original_ysh, original_xsh), dtype=np.uint8)
+            tmp[min_z:max_z,min_y:max_y,min_x:max_x] = label
+            label = np.copy(tmp, order='C')
+
+        # get result
+        if not bm.separation:
+            label = get_labels(label, bm.allLabels)
+        results['regular'] = label
+
+        # load header from file
+        if bm.header_file and os.path.exists(bm.header_file):
+            _, bm.header = load_data(bm.header_file)
+            # update file extension
+            if bm.header is not None and bm.path_to_image:
+                bm.extension = os.path.splitext(bm.header_file)[1]
+                if bm.extension == '.gz':
+                    bm.extension = '.nii.gz'
+                bm.path_to_final = os.path.splitext(bm.path_to_final)[0] + bm.extension
+                if bm.django_env and not bm.remote and not bm.tarfile:
+                    bm.path_to_final = unique_file_path(bm.path_to_final)
+
+        # handle amira header
+        if bm.header is not None:
+            if bm.extension == '.am':
+                bm.header = set_image_dimensions(bm.header[0], label)
+                if bm.img_header is not None:
+                    try:
+                        bm.header = set_physical_size(bm.header, bm.img_header[0])
+                    except:
+                        pass
+                bm.header = [bm.header]
+            else:
+                # build new header
+                if bm.img_header is None:
+                    zsh, ysh, xsh = label.shape
+                    bm.img_header = sitk.Image(xsh, ysh, zsh, bm.header.GetPixelID())
+                # copy metadata
+                for key in bm.header.GetMetaDataKeys():
+                    if not (re.match(r'Segment\d+_Extent$', key) or key=='Segmentation_ConversionParameters'):
+                        bm.img_header.SetMetaData(key, bm.header.GetMetaData(key))
+                bm.header = bm.img_header
+        results['header'] = bm.header
+
+        # save result
+        if bm.path_to_image:
+            save_data(bm.path_to_final, label, header=bm.header, compress=bm.compression)
 
-    # revert automatic cropping
-    if np.any(region_of_interest):
-        min_z,max_z,min_y,max_y,min_x,max_x,original_zsh,original_ysh,original_xsh = region_of_interest[:]
-        tmp = np.zeros((original_zsh, original_ysh, original_xsh), dtype=np.uint8)
-        tmp[min_z:max_z,min_y:max_y,min_x:max_x] = label
-        label = np.copy(tmp, order='C')
-
-    # get result
-    if not bm.separation:
-        label = get_labels(label, bm.allLabels)
-    results['regular'] = label
-
-    # load header from file
-    if bm.header_file and os.path.exists(bm.header_file):
-        _, bm.header = load_data(bm.header_file)
-        # update file extension
-        if bm.header is not None and bm.path_to_image:
-            bm.extension = os.path.splitext(bm.header_file)[1]
+            # paths to optional results
+            filename, bm.extension = os.path.splitext(bm.path_to_final)
             if bm.extension == '.gz':
                 bm.extension = '.nii.gz'
-            bm.path_to_final = os.path.splitext(bm.path_to_final)[0] + bm.extension
-            if bm.django_env and not bm.remote and not bm.tarfile:
-                bm.path_to_final = unique_file_path(bm.path_to_final)
-
-    # handle amira header
-    if bm.header is not None:
-        if bm.extension == '.am':
-            bm.header = set_image_dimensions(bm.header[0], label)
-            if bm.img_header is not None:
-                try:
-                    bm.header = set_physical_size(bm.header, bm.img_header[0])
-                except:
-                    pass
-            bm.header = [bm.header]
-        else:
-            # build new header
-            if bm.img_header is None:
-                zsh, ysh, xsh = label.shape
-                bm.img_header = sitk.Image(xsh, ysh, zsh, bm.header.GetPixelID())
-            # copy metadata
-            for key in bm.header.GetMetaDataKeys():
-                if not (re.match(r'Segment\d+_Extent$', key) or key=='Segmentation_ConversionParameters'):
-                    bm.img_header.SetMetaData(key, bm.header.GetMetaData(key))
-            bm.header = bm.img_header
-    results['header'] = bm.header
-
-    # save result
-    if bm.path_to_image:
-        save_data(bm.path_to_final, label, header=bm.header, compress=bm.compression)
-
-        # paths to optional results
-        filename, bm.extension = os.path.splitext(bm.path_to_final)
-        if bm.extension == '.gz':
-            bm.extension = '.nii.gz'
-            filename = filename[:-4]
-        path_to_cleaned = filename + '.cleaned' + bm.extension
-        path_to_filled = filename + '.filled' + bm.extension
-        path_to_cleaned_filled = filename + '.cleaned.filled' + bm.extension
-        path_to_refined = filename + '.refined' + bm.extension
-        path_to_acwe = filename + '.acwe' + bm.extension
-
-    # remove outliers
-    if bm.clean:
-        cleaned_result = clean(label, bm.clean)
-        results['cleaned'] = cleaned_result
-        if bm.path_to_image:
-            save_data(path_to_cleaned, cleaned_result, header=bm.header, compress=bm.compression)
-    if bm.fill:
-        filled_result = clean(label, bm.fill)
-        results['filled'] = filled_result
-        if bm.path_to_image:
-            save_data(path_to_filled, filled_result, header=bm.header, compress=bm.compression)
-    if bm.clean and bm.fill:
-        cleaned_filled_result = cleaned_result + (filled_result - label)
-        results['cleaned_filled'] = cleaned_filled_result
-        if bm.path_to_image:
-            save_data(path_to_cleaned_filled, cleaned_filled_result, header=bm.header, compress=bm.compression)
-
-    # post-processing with active contour
-    if bm.acwe:
-        acwe_result = activeContour(bm.img_data, label, bm.acwe_alpha, bm.acwe_smooth, bm.acwe_steps)
-        refined_result = activeContour(bm.img_data, label, simple=True)
-        results['acwe'] = acwe_result
-        results['refined'] = refined_result
-        if bm.path_to_image:
-            save_data(path_to_acwe, acwe_result, header=bm.header, compress=bm.compression)
-            save_data(path_to_refined, refined_result, header=bm.header, compress=bm.compression)
-
-    return results, bm
+                filename = filename[:-4]
+            path_to_cleaned = filename + '.cleaned' + bm.extension
+            path_to_filled = filename + '.filled' + bm.extension
+            path_to_cleaned_filled = filename + '.cleaned.filled' + bm.extension
+            path_to_refined = filename + '.refined' + bm.extension
+            path_to_acwe = filename + '.acwe' + bm.extension
+
+        # remove outliers
+        if bm.clean:
+            cleaned_result = clean(label, bm.clean)
+            results['cleaned'] = cleaned_result
+            if bm.path_to_image:
+                save_data(path_to_cleaned, cleaned_result, header=bm.header, compress=bm.compression)
+        if bm.fill:
+            filled_result = clean(label, bm.fill)
+            results['filled'] = filled_result
+            if bm.path_to_image:
+                save_data(path_to_filled, filled_result, header=bm.header, compress=bm.compression)
+        if bm.clean and bm.fill:
+            cleaned_filled_result = cleaned_result + (filled_result - label)
+            results['cleaned_filled'] = cleaned_filled_result
+            if bm.path_to_image:
+                save_data(path_to_cleaned_filled, cleaned_filled_result, header=bm.header, compress=bm.compression)
+
+        # post-processing with active contour
+        if bm.acwe:
+            acwe_result = activeContour(bm.img_data, label, bm.acwe_alpha, bm.acwe_smooth, bm.acwe_steps)
+            refined_result = activeContour(bm.img_data, label, simple=True)
+            results['acwe'] = acwe_result
+            results['refined'] = refined_result
+            if bm.path_to_image:
+                save_data(path_to_acwe, acwe_result, header=bm.header, compress=bm.compression)
+                save_data(path_to_refined, refined_result, header=bm.header, compress=bm.compression)
+
+        return results, bm
+    else:
+        return None, None
 

{biomedisa-24.8.5.dist-info → biomedisa-24.8.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: biomedisa
-Version: 24.8.5
+Version: 24.8.7
 Summary: Segmentation of 3D volumetric image data
 Author: Philipp Lösel
 Author-email: philipp.loesel@anu.edu.au
@@ -10,7 +10,7 @@ Project-URL: GitHub, https://github.com/biomedisa/biomedisa
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: European Union Public Licence 1.2 (EUPL 1.2)
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
@@ -19,6 +19,7 @@ License-File: LICENSE
 - [Overview](#overview)
 - [Hardware Requirements](#hardware-requirements)
 - [Installation (command-line based)](#installation-command-line-based)
+- [Installation (3D Slicer extension)](#installation-3d-slicer-extension)
 - [Installation (browser based)](#installation-browser-based)
 - [Download Data](#download-data)
 - [Revisions](#revisions)
@@ -33,20 +34,21 @@ License-File: LICENSE
 - [License](#license)
 
 ## Overview
-Biomedisa (https://biomedisa.info) is a free and easy-to-use open-source application for segmenting large 3D volumetric images such as CT and MRI scans, developed at [The Australian National University CTLab](https://ctlab.anu.edu.au/). Biomedisa's smart interpolation of sparsely pre-segmented slices enables accurate semi-automated segmentation by considering the complete underlying image data. Additionally, Biomedisa enables deep learning for fully automated segmentation across similar samples and structures. It is compatible with segmentation tools like Amira/Avizo, ImageJ/Fiji and 3D Slicer. If you are using Biomedisa or the data for your research please cite: Lösel, P.D. et al. [Introducing Biomedisa as an open-source online platform for biomedical image segmentation.](https://www.nature.com/articles/s41467-020-19303-w) *Nat. Commun.* **11**, 5577 (2020).
+Biomedisa (https://biomedisa.info) is a free and easy-to-use open-source application for segmenting large 3D volumetric images such as CT and MRI scans, developed at [The Australian National University CTLab](https://ctlab.anu.edu.au/). Biomedisa's smart interpolation of sparsely pre-segmented slices enables accurate semi-automated segmentation by considering the complete underlying image data. Additionally, Biomedisa enables deep learning for fully automated segmentation across similar samples and structures. It is compatible with segmentation tools like Amira/Avizo, ImageJ/Fiji, and 3D Slicer. If you are using Biomedisa or the data for your research please cite: Lösel, P.D. et al. [Introducing Biomedisa as an open-source online platform for biomedical image segmentation.](https://www.nature.com/articles/s41467-020-19303-w) *Nat. Commun.* **11**, 5577 (2020).
 
 ## Hardware Requirements
-+ One or more NVIDIA GPUs with compute capability 3.0 or higher.
++ One or more NVIDIA GPUs.
 
 ## 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)
++ [Ubuntu 22/24 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu_interpolation_cli.md)
++ [Ubuntu 22/24 + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu_deeplearning_cli.md)
++ [Ubuntu 22/24 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu_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)
@@ -165,7 +167,7 @@ save_data('final.Head5.am', results['regular'], results['header'])
 
 #### Command-line based (prediction)
 ```
-python -m biomedisa.deeplearning C:\Users\%USERNAME%\Downloads\testing_axial_crop_pat13.nii.gz C:\Users\%USERNAME%\Downloads\heart.h5 -p
+python -m biomedisa.deeplearning C:\Users\%USERNAME%\Downloads\testing_axial_crop_pat13.nii.gz C:\Users\%USERNAME%\Downloads\heart.h5
 ```
 
 ## Mesh Generator

{biomedisa-24.8.5.dist-info → biomedisa-24.8.7.dist-info}/RECORD

@@ -1,10 +1,10 @@
 biomedisa/__init__.py,sha256=hw4mzEjGFXm-vxus2DBfKFW0nKoG0ibL5SH6ShfchrY,1526
 biomedisa/__main__.py,sha256=a1--8vhtztWEloHVtbM43FZLCfrFo4BELgdsgtWE8ls,536
-biomedisa/deeplearning.py,sha256=UD4IeaxITLLqzoaQ1Ul5HI_bN8wINouOGxf14yZ7SWQ,28008
+biomedisa/deeplearning.py,sha256=r4YzFUss_2u6I7clIg9QD4DDx7bq8AFUnUgU1TCwS1c,28273
 biomedisa/interpolation.py,sha256=i10aqwEl-wsVU_nQ-zyubhAs27NSKF4ial7LyhaBLv0,17273
 biomedisa/mesh.py,sha256=8-iuVsrfW5JovaMrAez7qSxv1LCU3eiqOdik0s0DV1w,16062
-biomedisa/features/DataGenerator.py,sha256=MINc7emhELPxACOYdnLFHgh-RHUKODLH0DH7zz6u6mc,13116
-biomedisa/features/DataGeneratorCrop.py,sha256=23R4Z-8tB1CsjYTYfhHGovlJpAny_q9OV9hq8kc2GJg,5454
+biomedisa/features/DataGenerator.py,sha256=m7vsKkLhRsVF1BE3Y8YGVx-xx0DWjbBw_inIdZBq6pQ,13111
+biomedisa/features/DataGeneratorCrop.py,sha256=KtGqNadghOd59wIU9hATM_5YgSks95rS1kJ2lsSSX7w,6612
 biomedisa/features/PredictDataGenerator.py,sha256=JH8SPGQm-Y7_Drec2fw3jBUupvpIkQ1FvkDXP7mUjDY,4074
 biomedisa/features/PredictDataGeneratorCrop.py,sha256=HF5tJbGtlJMHr7lMT9IiIdLG2CTjXstbKoOjlZJ93Is,3431
 biomedisa/features/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -12,10 +12,10 @@ biomedisa/features/active_contour.py,sha256=FnPuvYck_KL4xYRFqwzm4Grdm288EdlcLFt8
 biomedisa/features/assd.py,sha256=q9NUQXEoA4Pi3d8b5fmys615CWu06Sm0N9-OGwJOFnw,6537
 biomedisa/features/biomedisa_helper.py,sha256=oIsOmIJ8xUQVwgbzMgw65dXcZmzwePpFQoIdbgLTnF8,32727
 biomedisa/features/create_slices.py,sha256=uSDH1OcEYc5BFPZHSy3UpS4P2DuoVnxOZ-l7wmyT_Po,13108
-biomedisa/features/crop_helper.py,sha256=R0_uZ8rxg1l0-HxP1fYBWWCSUjvSvTBSgW47Nq8eK4s,23789
+biomedisa/features/crop_helper.py,sha256=wNVbb1c6qNmJFbDJ2jrjjvqJw-EMLkJt1HLjEolMwAA,24089
 biomedisa/features/curvop_numba.py,sha256=AjKQJcUBoURTB8pq1HmugQYpBwBELthhcEu51_r_xPI,7049
 biomedisa/features/django_env.py,sha256=LNrZ6rBHZ5I0FaWa5xN8K-ASPgq0r5dGDEUI56HzJxE,8615
-biomedisa/features/keras_helper.py,sha256=Emf-Fx9rB3jECL7XgK8DYMRwO27ynijt5YdnwMlDMXY,62747
+biomedisa/features/keras_helper.py,sha256=r9Knb5GlJCU3nQ601wBJF_9pOpdTL20KUO-x0xRP6WM,68853
 biomedisa/features/nc_reader.py,sha256=RoRMwu3ELSNfoV3qZtaT2OWACnXb2EhNFu_DAF1T93o,7406
 biomedisa/features/pid.py,sha256=Jmn1VIp0fBlgBrqZ-yUIQVVb5-NAxNBdibXALVr2PPI,2545
 biomedisa/features/process_image.py,sha256=VtS3fGDvglqJiiJLPK1toe76J58j914NJ8XQKg3CRwo,11091
@@ -37,8 +37,8 @@ biomedisa/features/random_walk/pyopencl_large.py,sha256=q79AxG3p3qFjxfiAZfUK9I5B
 biomedisa/features/random_walk/pyopencl_small.py,sha256=opNlS-qzOa9qWafBNJdvf6r1aRAFf7_JXf6ISDnkdXE,17068
 biomedisa/features/random_walk/rw_large.py,sha256=ZnITvk00Y11ZZlGuBRaJO1EwU0wYBdEwdpj9vvXCqF4,19805
 biomedisa/features/random_walk/rw_small.py,sha256=RPzZe24YrEwYelJukDjvqaoD_SyhgdriEi7uV3kZGXI,14881
-biomedisa-24.8.5.dist-info/LICENSE,sha256=sehayP6UhydNnmstfL4yFR3genMRdpuUh6uZVWJN1H0,14152
-biomedisa-24.8.5.dist-info/METADATA,sha256=IMCcEHNKZKWZqsMN8vu4h6S812_vkYyKj0NNAiebrrY,10569
-biomedisa-24.8.5.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-biomedisa-24.8.5.dist-info/top_level.txt,sha256=opsf1Eb4vCguPSxev4HHSeiUKCccT_C_RcUCdAYbHWQ,10
-biomedisa-24.8.5.dist-info/RECORD,,
+biomedisa-24.8.7.dist-info/LICENSE,sha256=sehayP6UhydNnmstfL4yFR3genMRdpuUh6uZVWJN1H0,14152
+biomedisa-24.8.7.dist-info/METADATA,sha256=7qJuRtt6SHy4MnZDyn-lqgSPXIjjSTrFZYRbXMbW5Mc,10708
+biomedisa-24.8.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+biomedisa-24.8.7.dist-info/top_level.txt,sha256=opsf1Eb4vCguPSxev4HHSeiUKCccT_C_RcUCdAYbHWQ,10
+biomedisa-24.8.7.dist-info/RECORD,,

{biomedisa-24.8.5.dist-info → biomedisa-24.8.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any