biomedisa 24.5.23__py3-none-any.whl → 24.7.1__py3-none-any.whl

biomedisa/deeplearning.py

@@ -65,11 +65,11 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
     path_to_images=None, path_to_labels=None, val_images=None, val_labels=None,
     path_to_model=None, predict=False, train=False, header_file=None,
     balance=False, crop_data=False, flip_x=False, flip_y=False, flip_z=False,
-    swapaxes=False, train_dice=False, val_dice=True, no_compression=False, ignore='none', only='all',
+    swapaxes=False, train_dice=False, val_dice=True, compression=True, ignore='none', only='all',
     network_filters='32-64-128-256-512', resnet=False, debug_cropping=False,
-    save_cropped=False, epochs=100, no_normalization=False, rotate=0.0, validation_split=0.0,
+    save_cropped=False, epochs=100, normalization=True, rotate=0.0, validation_split=0.0,
     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, no_scaling=False, early_stopping=0,
+    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',
     img_header=None, img_extension='.tif', average_dice=False, django_env=False,
@@ -91,17 +91,13 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
     for arg in key_copy:
         bm.__dict__[arg] = locals()[arg]
 
-    # compression
-    if bm.no_compression:
-        bm.compression = False
-    else:
-        bm.compression = True
-
     # normalization
-    if bm.no_normalization:
+    bm.normalize = 1 if bm.normalization else 0
+
+    # use patch normalization instead of normalizing the entire volume
+    if not bm.scaling:
         bm.normalize = 0
-    else:
-        bm.normalize = 1
+        bm.patch_normalization = True
 
     # django environment
     if bm.django_env:
@@ -217,14 +213,19 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
         hf = h5py.File(bm.path_to_model, 'r')
         meta = hf.get('meta')
         configuration = meta.get('configuration')
-        channels, bm.x_scale, bm.y_scale, bm.z_scale, normalize, mu, sig = np.array(configuration)[:]
-        channels, bm.x_scale, bm.y_scale, bm.z_scale, normalize, mu, sig = int(channels), int(bm.x_scale), \
-                                int(bm.y_scale), int(bm.z_scale), int(normalize), float(mu), float(sig)
-        if '/meta/normalization' in hf:
-            normalization_parameters = np.array(meta.get('normalization'), dtype=float)
+        channels, bm.x_scale, bm.y_scale, bm.z_scale, bm.normalize, mu, sig = np.array(configuration)[:]
+        channels, bm.x_scale, bm.y_scale, bm.z_scale, bm.normalize, mu, sig = int(channels), int(bm.x_scale), \
+                                int(bm.y_scale), int(bm.z_scale), int(bm.normalize), float(mu), float(sig)
+        if 'normalization' in meta:
+            normalization_parameters = np.array(meta['normalization'], dtype=float)
         else:
             normalization_parameters = np.array([[mu],[sig]])
         allLabels = np.array(meta.get('labels'))
+        if 'patch_normalization' in meta:
+            bm.patch_normalization = bool(meta['patch_normalization'][()])
+        if 'scaling' in meta:
+            bm.scaling = bool(meta['scaling'][()])
+
         # check if amira header is available in the network
         if header is None and meta.get('header') is not None:
             header = [np.array(meta.get('header'))]
@@ -290,16 +291,11 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
                     region_of_interest, cropped_volume = ch.crop_data(bm.path_to_image, bm.path_to_model, bm.path_to_cropped_image,
                         bm.batch_size, bm.debug_cropping, bm.save_cropped, img_data, bm.x_range, bm.y_range, bm.z_range)
 
-                # load prediction data
-                img, img_header, z_shape, y_shape, x_shape, region_of_interest, img_data = load_prediction_data(bm.path_to_image,
-                    channels, bm.x_scale, bm.y_scale, bm.z_scale, bm.no_scaling, normalize, normalization_parameters,
-                    region_of_interest, img_data, img_header)
-
                 # make prediction
-                results, bm = predict_semantic_segmentation(bm, img, bm.path_to_model,
-                    bm.z_patch, bm.y_patch, bm.x_patch, z_shape, y_shape, x_shape, bm.compression, header,
-                    img_header, bm.stride_size, allLabels, bm.batch_size, region_of_interest,
-                    bm.no_scaling, extension, img_data)
+                results, bm = predict_semantic_segmentation(bm,
+                    header, img_header, allLabels,
+                    region_of_interest, extension, img_data,
+                    channels, normalization_parameters)
 
                 # results
                 if cropped_volume is not None:
@@ -403,7 +399,7 @@ if __name__ == '__main__':
                         help='Dice loss function')
     parser.add_argument('-ad','--average_dice', action='store_true', default=False,
                         help='Use averaged dice score of each label')
-    parser.add_argument('-nc', '--no_compression', action='store_true', default=False,
+    parser.add_argument('-nc', '--no-compression', dest='compression', action='store_false',
                         help='Disable compression of segmentation results')
     parser.add_argument('-i', '--ignore', type=str, default='none',
                         help='Ignore specific label(s), e.g. 2,5,6')
@@ -421,12 +417,12 @@ if __name__ == '__main__':
                         help='Epochs the network is trained')
     parser.add_argument('-ce','--cropping_epochs', type=int, default=50,
                         help='Epochs the network for auto-cropping is trained')
-    parser.add_argument('-nn','--no_normalization', action='store_true', default=False,
-                        help='Disable image normalization')
+    parser.add_argument('-nn','--no-normalization', dest='normalization', action='store_false',
+                        help='Disable normalization of 3D image volumes')
     parser.add_argument('-r','--rotate', type=float, default=0.0,
                         help='Randomly rotate during training')
     parser.add_argument('-vs','--validation_split', type=float, default=0.0,
-                        help='Percentage of data used for validation')
+                        help='Percentage of data used for training')
     parser.add_argument('-lr','--learning_rate', type=float, default=0.01,
                         help='Learning rate')
     parser.add_argument('-ss','--stride_size', metavar="[1-64]", type=int, choices=range(1,65), default=32,
@@ -447,7 +443,7 @@ if __name__ == '__main__':
                         help='Images and labels are scaled at y-axis to this size before training')
     parser.add_argument('-zs','--z_scale', type=int, default=256,
                         help='Images and labels are scaled at z-axis to this size before training')
-    parser.add_argument('-ns','--no_scaling', action='store_true', default=False,
+    parser.add_argument('-ns','--no-scaling', dest='scaling', action='store_false',
                         help='Do not resize image and label data')
     parser.add_argument('-es','--early_stopping', type=int, default=0,
                         help='Training is terminated when the accuracy has not increased in the epochs defined by this')
@@ -484,8 +480,15 @@ if __name__ == '__main__':
     parser.add_argument('-hf','--header_file', type=str, metavar='PATH', default=None,
                         help='Location of header file')
     bm = parser.parse_args()
-
     bm.success = True
+
+    # prediction or training
+    if not any([bm.train, bm.predict]):
+        bm.predict = False
+        bm.train = True
+        if os.path.splitext(bm.path)[1] == '.h5':
+            bm.predict = True
+            bm.train = False
     if bm.predict:
         bm.path_to_labels = None
         bm.path_to_model = bm.path

biomedisa/features/DataGenerator.py

@@ -286,7 +286,7 @@ class DataGenerator(tf.keras.utils.Sequence):
 
                 # patch normalization
                 if self.patch_normalization:
-                    tmp_X = np.copy(tmp_X, order='C')
+                    tmp_X = tmp_X.copy()
                     for c in range(self.n_channels):
                         tmp_X[:,:,:,c] -= np.mean(tmp_X[:,:,:,c])
                         tmp_X[:,:,:,c] /= max(np.std(tmp_X[:,:,:,c]), 1e-6)

biomedisa/features/active_contour.py

@@ -106,7 +106,7 @@ def reduce_blocksize(raw, slices):
     return raw, slices, argmin_z, argmax_z, argmin_y, argmax_y, argmin_x, argmax_x
 
 def activeContour(data, labelData, alpha=1.0, smooth=1, steps=3,
-    path_to_data=None, path_to_labels=None, no_compression=False,
+    path_to_data=None, path_to_labels=None, compression=True,
     ignore='none', only='all', simple=False,
     img_id=None, friend_id=None, remote=False):
 
@@ -126,12 +126,6 @@ def activeContour(data, labelData, alpha=1.0, smooth=1, steps=3,
     else:
         bm.django_env = False
 
-    # compression
-    if bm.no_compression:
-        bm.compression = False
-    else:
-        bm.compression = True
-
     # disable file saving when called as a function
     if bm.data is not None:
         bm.path_to_data = None
@@ -374,8 +368,7 @@ def init_active_contour(image_id, friend_id, label_id, simple=False):
         else:
             try:
                 activeContour(None, None, path_to_data=image.pic.path, path_to_labels=friend.pic.path,
-                    alpha=label.ac_alpha, smooth=label.ac_smooth, steps=label.ac_steps,
-                    no_compression=(False if label.compression else True),
+                    alpha=label.ac_alpha, smooth=label.ac_smooth, steps=label.ac_steps, compression=label.compression,
                     simple=simple, img_id=image_id, friend_id=friend_id, remote=False)
             except Exception as e:
                 print(traceback.format_exc())
@@ -407,7 +400,7 @@ if __name__ == '__main__':
                         help='Number of smoothing steps')
     parser.add_argument('-st', '--steps', type=int, default=3,
                         help='Number of iterations')
-    parser.add_argument('-nc', '--no_compression', action='store_true', default=False,
+    parser.add_argument('-nc', '--no-compression', dest='compression', action='store_false',
                         help='Disable compression of segmentation results')
     parser.add_argument('-i', '--ignore', type=str, default='none',
                         help='Ignore specific label(s), e.g. 2,5,6')

biomedisa/features/biomedisa_helper.py

@@ -317,19 +317,23 @@ def load_data(path_to_data, process='None', return_extension=False):
                         data, header = None, None
                 else:
                     try:
-                        # remove unreadable files or directories
-                        for name in files:
-                            if os.path.isfile(name):
+                        # load data slice by slice
+                        file_names = []
+                        img_slices = []
+                        header = []
+                        files.sort()
+                        for file_name in files:
+                            if os.path.isfile(file_name):
                                 try:
-                                    img, _ = load(name)
+                                    img, img_header = load(file_name)
+                                    file_names.append(file_name)
+                                    img_slices.append(img)
+                                    header.append(img_header)
                                 except:
-                                    files.remove(name)
-                            else:
-                                files.remove(name)
-                        files.sort()
+                                    pass
 
                         # get data size
-                        img, _ = load(files[0])
+                        img = img_slices[0]
                         if len(img.shape)==3:
                             ysh, xsh, csh = img.shape[0], img.shape[1], img.shape[2]
                             channel = 'last'
@@ -340,11 +344,9 @@ def load_data(path_to_data, process='None', return_extension=False):
                             ysh, xsh = img.shape[0], img.shape[1]
                             csh, channel = 0, None
 
-                        # load data slice by slice
-                        data = np.empty((len(files), ysh, xsh), dtype=img.dtype)
-                        header, image_data_shape = [], []
-                        for k, file_name in enumerate(files):
-                            img, img_header = load(file_name)
+                        # create 3D volume
+                        data = np.empty((len(file_names), ysh, xsh), dtype=img.dtype)
+                        for k, img in enumerate(img_slices):
                             if csh==3:
                                 img = rgb2gray(img, channel)
                             elif csh==1 and channel=='last':
@@ -352,8 +354,7 @@ def load_data(path_to_data, process='None', return_extension=False):
                             elif csh==1 and channel=='first':
                                 img = img[0,:,:]
                             data[k] = img
-                            header.append(img_header)
-                        header = [header, files, data.dtype]
+                        header = [header, file_names, data.dtype]
                         data = np.swapaxes(data, 1, 2)
                         data = np.copy(data, order='C')
                     except Exception as e:

biomedisa/features/create_slices.py

@@ -151,6 +151,7 @@ def create_slices(path_to_data, path_to_label, on_site=False):
             # increase contrast
             raw = img_to_uint8(raw)
             raw = contrast(raw)
+            zsh, ysh, xsh = raw.shape
 
             # create slices for slice viewer
             if not os.path.isdir(path_to_slices):
@@ -160,9 +161,9 @@ def create_slices(path_to_data, path_to_label, on_site=False):
                 os.chmod(path_to_slices, 0o770)
 
                 # save slices
-                for k in range(raw.shape[0]):
+                for k in range(zsh):
                     im = Image.fromarray(raw[k])
-                    im.save(path_to_slices + f'/{k}.png')
+                    im.save(path_to_slices + '/slice_' + str(k).zfill(len(str(zsh-1))) + '.png')
 
             if path_to_label and not os.path.isdir(path_to_label_slices):
 
@@ -263,7 +264,7 @@ def create_slices(path_to_data, path_to_label, on_site=False):
 
                         # save slice
                         im = Image.fromarray(out)
-                        im.save(path_to_label_slices + f'/{k}.png')
+                        im.save(path_to_label_slices + '/slice_' + str(k).zfill(len(str(zsh-1))) + '.png')
 
     except Exception as e:
         print(e)

biomedisa/features/keras_helper.py

@@ -45,6 +45,7 @@ from biomedisa.features.biomedisa_helper import (
     img_resize, load_data, save_data, set_labels_to_zero, id_generator, unique_file_path)
 from biomedisa.features.remove_outlier import clean, fill
 from biomedisa.features.active_contour import activeContour
+from tifffile import TiffFile, imread
 import matplotlib.pyplot as plt
 import SimpleITK as sitk
 import tensorflow as tf
@@ -100,7 +101,7 @@ def save_history(history, path_to_model, val_dice, train_dice):
     # save history dictonary
     np.save(path_to_model.replace('.h5','.npy'), history)
 
-def predict_blocksize(labelData, x_puffer, y_puffer, z_puffer):
+def predict_blocksize(labelData, x_puffer=25, y_puffer=25, z_puffer=25):
     zsh, ysh, xsh = labelData.shape
     argmin_z, argmax_z, argmin_y, argmax_y, argmin_x, argmax_x = zsh, 0, ysh, 0, xsh, 0
     for k in range(zsh):
@@ -121,7 +122,7 @@ def predict_blocksize(labelData, x_puffer, y_puffer, z_puffer):
     argmax_z = argmax_z + z_puffer if argmax_z + z_puffer < zsh else zsh
     return argmin_z,argmax_z,argmin_y,argmax_y,argmin_x,argmax_x
 
-def get_image_dimensions(header, data):
+def set_image_dimensions(header, data):
 
     # read header as string
     b = header.tobytes()
@@ -148,7 +149,7 @@ def get_image_dimensions(header, data):
     new_header = np.frombuffer(b2, dtype=header.dtype)
     return new_header
 
-def get_physical_size(header, img_header):
+def set_physical_size(header, img_header):
 
     # read img_header as string
     b = img_header.tobytes()
@@ -354,7 +355,7 @@ def read_img_list(img_list, label_list, temp_img_dir, temp_label_dir):
             label_names.append(label_name)
     return img_names, label_names
 
-def load_training_data(normalize, img_list, label_list, channels, x_scale, y_scale, z_scale, no_scaling,
+def load_training_data(normalize, img_list, label_list, channels, x_scale, y_scale, z_scale, scaling,
         crop_data, labels_to_compute, labels_to_remove, img_in=None, label_in=None,
         normalization_parameters=None, allLabels=None, header=None, extension='.tif',
         x_puffer=25, y_puffer=25, z_puffer=25):
@@ -386,7 +387,7 @@ def load_training_data(normalize, img_list, label_list, channels, x_scale, y_sca
             if crop_data:
                 argmin_z,argmax_z,argmin_y,argmax_y,argmin_x,argmax_x = predict_blocksize(label, x_puffer, y_puffer, z_puffer)
                 label = np.copy(label[argmin_z:argmax_z,argmin_y:argmax_y,argmin_x:argmax_x], order='C')
-            if not no_scaling:
+            if scaling:
                 label = img_resize(label, z_scale, y_scale, x_scale, labels=True)
 
             # if header is not single data stream Amira Mesh falling back to Multi-TIFF
@@ -412,7 +413,7 @@ def load_training_data(normalize, img_list, label_list, channels, x_scale, y_sca
             else:
                 img = img_in
                 img_names = ['img_1']
-            if label_dim != img.shape:
+            if label_dim != img.shape[:3]:
                 InputError.message = f'Dimensions of "{os.path.basename(img_names[0])}" and "{os.path.basename(label_names[0])}" do not match'
                 raise InputError()
 
@@ -432,7 +433,7 @@ def load_training_data(normalize, img_list, label_list, channels, x_scale, y_sca
 
             # scale/resize image data
             img = img.astype(np.float32)
-            if not no_scaling:
+            if scaling:
                 img = img_resize(img, z_scale, y_scale, x_scale)
 
             # normalize image data
@@ -469,7 +470,7 @@ def load_training_data(normalize, img_list, label_list, channels, x_scale, y_sca
                     if crop_data:
                         argmin_z,argmax_z,argmin_y,argmax_y,argmin_x,argmax_x = predict_blocksize(a, x_puffer, y_puffer, z_puffer)
                         a = np.copy(a[argmin_z:argmax_z,argmin_y:argmax_y,argmin_x:argmax_x], order='C')
-                    if not no_scaling:
+                    if scaling:
                         a = img_resize(a, z_scale, y_scale, x_scale, labels=True)
                     label = np.append(label, a, axis=0)
 
@@ -481,7 +482,7 @@ def load_training_data(normalize, img_list, label_list, channels, x_scale, y_sca
                             raise InputError()
                     else:
                         a = img_in[k]
-                    if label_dim != a.shape:
+                    if label_dim != a.shape[:3]:
                         InputError.message = f'Dimensions of "{os.path.basename(img_names[k])}" and "{os.path.basename(label_names[k])}" do not match'
                         raise InputError()
                     if len(a.shape)==3:
@@ -493,7 +494,7 @@ def load_training_data(normalize, img_list, label_list, channels, x_scale, y_sca
                     if crop_data:
                         a = np.copy(a[argmin_z:argmax_z,argmin_y:argmax_y,argmin_x:argmax_x], order='C')
                     a = a.astype(np.float32)
-                    if not no_scaling:
+                    if scaling:
                         a = img_resize(a, z_scale, y_scale, x_scale)
                     for c in range(channels):
                         a[:,:,:,c] -= np.amin(a[:,:,:,c])
@@ -541,18 +542,17 @@ class CustomCallback(Callback):
                 time_remaining = str(t // 60) + 'min'
             else:
                 time_remaining = str(t // 3600) + 'h ' + str((t % 3600) // 60) + 'min'
-            try:
-                val_accuracy = round(float(logs["val_accuracy"])*100,1)
-                image.message = 'Progress {}%, {} remaining, {}% accuracy'.format(percentage,time_remaining,val_accuracy)
-            except KeyError:
-                image.message = 'Progress {}%, {} remaining'.format(percentage,time_remaining)
+            image.message = 'Progress {}%, {} remaining'.format(percentage,time_remaining)
+            if 'best_val_dice' in logs:
+                best_val_dice = round(float(logs['best_val_dice'])*100,1)
+                image.message += f', {best_val_dice}% accuracy'
             image.save()
             print("Start epoch {} of training; got log keys: {}".format(epoch, keys))
 
 class MetaData(Callback):
     def __init__(self, path_to_model, configuration_data, allLabels,
         extension, header, crop_data, cropping_weights, cropping_config,
-        normalization_parameters, cropping_norm):
+        normalization_parameters, cropping_norm, patch_normalization, scaling):
 
         self.path_to_model = path_to_model
         self.configuration_data = configuration_data
@@ -564,6 +564,8 @@ class MetaData(Callback):
         self.cropping_weights = cropping_weights
         self.cropping_config = cropping_config
         self.cropping_norm = cropping_norm
+        self.patch_normalization = patch_normalization
+        self.scaling = scaling
 
     def on_epoch_end(self, epoch, logs={}):
         hf = h5py.File(self.path_to_model, 'r')
@@ -574,6 +576,8 @@ class MetaData(Callback):
             group.create_dataset('configuration', data=self.configuration_data)
             group.create_dataset('normalization', data=self.normalization_parameters)
             group.create_dataset('labels', data=self.allLabels)
+            group.create_dataset('patch_normalization', data=int(self.patch_normalization))
+            group.create_dataset('scaling', data=int(self.scaling))
             if self.extension == '.am':
                 group.create_dataset('extension', data=self.extension)
                 group.create_dataset('header', data=self.header)
@@ -758,8 +762,8 @@ def dice_coef_loss(nb_labels):
         for index in range(1,nb_labels):
             dice += dice_coef(y_true[:,:,:,:,index], y_pred[:,:,:,:,index])
         dice = dice / (nb_labels-1)
-        loss = -K.log(dice)
-        #loss = 1 - dice
+        #loss = -K.log(dice)
+        loss = 1 - dice
         return loss
     return loss_fn
 
@@ -772,7 +776,7 @@ def train_semantic_segmentation(bm,
 
     # training data
     img, label, allLabels, normalization_parameters, header, extension, bm.channels = load_training_data(bm.normalize,
-                    img_list, label_list, None, bm.x_scale, bm.y_scale, bm.z_scale, bm.no_scaling, bm.crop_data,
+                    img_list, label_list, None, bm.x_scale, bm.y_scale, bm.z_scale, bm.scaling, bm.crop_data,
                     bm.only, bm.ignore, img, label, None, None, header, extension)
 
     # configuration data
@@ -784,7 +788,7 @@ def train_semantic_segmentation(bm,
     # validation data
     if any(val_img_list) or img_val is not None:
         img_val, label_val, _, _, _, _, _ = load_training_data(bm.normalize,
-                    val_img_list, val_label_list, bm.channels, bm.x_scale, bm.y_scale, bm.z_scale, bm.no_scaling, bm.crop_data,
+                    val_img_list, val_label_list, bm.channels, bm.x_scale, bm.y_scale, bm.z_scale, bm.scaling, bm.crop_data,
                     bm.only, bm.ignore, img_val, label_val, normalization_parameters, allLabels)
 
     elif bm.validation_split:
@@ -908,7 +912,7 @@ def train_semantic_segmentation(bm,
     # save meta data
     meta_data = MetaData(bm.path_to_model, configuration_data, allLabels,
         extension, header, bm.crop_data, bm.cropping_weights, bm.cropping_config,
-        normalization_parameters, bm.cropping_norm)
+        normalization_parameters, bm.cropping_norm, bm.patch_normalization, bm.scaling)
 
     # model checkpoint
     if img_val is not None:
@@ -946,22 +950,29 @@ def train_semantic_segmentation(bm,
     if img_val is not None and not bm.val_dice:
         save_history(history.history, bm.path_to_model, False, bm.train_dice)
 
-def load_prediction_data(path_to_img, channels, x_scale, y_scale, z_scale,
-                        no_scaling, normalize, normalization_parameters, region_of_interest,
-                        img, img_header):
+def load_prediction_data(bm, channels, normalize, normalization_parameters,
+    region_of_interest, img, img_header, load_blockwise=False, z=None):
+
     # read image data
     if img is None:
-        img, img_header = load_data(path_to_img, 'first_queue')
+        if load_blockwise:
+            img_header = None
+            tif = TiffFile(bm.path_to_image)
+            img = imread(bm.path_to_image, key=range(z,min(len(tif.pages),z+bm.z_patch)))
+        else:
+            img, img_header = load_data(bm.path_to_image, 'first_queue')
 
     # verify validity
     if img is None:
-        InputError.message = f'Invalid image data: {os.path.basename(path_to_img)}.'
+        InputError.message = f'Invalid image data: {os.path.basename(bm.path_to_image)}.'
         raise InputError()
 
-    # preserve original image data
-    img_data = img.copy()
+    # preserve original image data for post-processing
+    img_data = None
+    if bm.acwe:
+        img_data = img.copy()
 
-    # handle all images having channels >=1
+    # handle all images using number of channels >=1
     if len(img.shape)==3:
         z_shape, y_shape, x_shape = img.shape
         img = img.reshape(z_shape, y_shape, x_shape, 1)
@@ -969,7 +980,7 @@ def load_prediction_data(path_to_img, channels, x_scale, y_scale, z_scale,
         InputError.message = f'Number of channels must be {channels}.'
         raise InputError()
 
-    # image shape
+    # original image shape
     z_shape, y_shape, x_shape, _ = img.shape
 
     # automatic cropping of image to region of interest
@@ -981,8 +992,8 @@ def load_prediction_data(path_to_img, channels, x_scale, y_scale, z_scale,
 
     # scale/resize image data
     img = img.astype(np.float32)
-    if not no_scaling:
-        img = img_resize(img, z_scale, y_scale, x_scale)
+    if bm.scaling:
+        img = img_resize(img, bm.z_scale, bm.y_scale, bm.x_scale)
 
     # normalize image data
     for c in range(channels):
@@ -1000,94 +1011,255 @@ def load_prediction_data(path_to_img, channels, x_scale, y_scale, z_scale,
 
     return img, img_header, z_shape, y_shape, x_shape, region_of_interest, img_data
 
-def predict_semantic_segmentation(bm, img, path_to_model,
-    z_patch, y_patch, x_patch, z_shape, y_shape, x_shape, compress, header,
-    img_header, stride_size, allLabels, batch_size, region_of_interest,
-    no_scaling, extension, img_data):
+def append_ghost_areas(bm, img):
+    # append ghost areas to make image dimensions divisible by patch size (mirror edge areas)
+    zsh, ysh, xsh, _ = img.shape
+    z_rest = bm.z_patch - (zsh % bm.z_patch)
+    if z_rest == bm.z_patch:
+        z_rest = -zsh
+    else:
+        img = np.append(img, img[-z_rest:][::-1], axis=0)
+    y_rest = bm.y_patch - (ysh % bm.y_patch)
+    if y_rest == bm.y_patch:
+        y_rest = -ysh
+    else:
+        img = np.append(img, img[:,-y_rest:][:,::-1], axis=1)
+    x_rest = bm.x_patch - (xsh % bm.x_patch)
+    if x_rest == bm.x_patch:
+        x_rest = -xsh
+    else:
+        img = np.append(img, img[:,:,-x_rest:][:,:,::-1], axis=2)
+    return img, z_rest, y_rest, x_rest
 
-    results = {}
+def predict_semantic_segmentation(bm,
+    header, img_header, allLabels,
+    region_of_interest, extension, img_data,
+    channels, normalization_parameters):
 
-    # img shape
-    zsh, ysh, xsh, csh = img.shape
+    # initialize results
+    results = {}
 
     # number of labels
     nb_labels = len(allLabels)
 
-    # list of IDs
-    list_IDs = []
+    # load model
+    if bm.dice_loss:
+        def loss_fn(y_true, y_pred):
+            dice = 0
+            for index in range(1, nb_labels):
+                dice += dice_coef(y_true[:,:,:,:,index], y_pred[:,:,:,:,index])
+            dice = dice / (nb_labels-1)
+            #loss = -K.log(dice)
+            loss = 1 - dice
+            return loss
+        custom_objects = {'dice_coef_loss': dice_coef_loss,'loss_fn': loss_fn}
+        model = load_model(bm.path_to_model, custom_objects=custom_objects)
+    else:
+        model = load_model(bm.path_to_model)
+
+    # check if data can be loaded blockwise to save host memory
+    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:
+        tif = TiffFile(bm.path_to_image)
+        zsh = len(tif.pages)
+        ysh, xsh = tif.pages[0].shape
+
+        # determine new image size after appending ghost areas to make image dimensions divisible by patch size
+        z_rest = bm.z_patch - (zsh % bm.z_patch)
+        if z_rest == bm.z_patch:
+            z_rest = -zsh
+        else:
+            zsh +=  z_rest
+        y_rest = bm.y_patch - (ysh % bm.y_patch)
+        if y_rest == bm.y_patch:
+            y_rest = -ysh
+        else:
+            ysh +=  y_rest
+        x_rest = bm.x_patch - (xsh % bm.x_patch)
+        if x_rest == bm.x_patch:
+            x_rest = -xsh
+        else:
+            xsh +=  x_rest
 
-    # get Ids of patches
-    for k in range(0, zsh-z_patch+1, stride_size):
-        for l in range(0, ysh-y_patch+1, stride_size):
-            for m in range(0, xsh-x_patch+1, stride_size):
-                list_IDs.append(k*ysh*xsh+l*xsh+m)
+        # get Ids of patches
+        list_IDs = []
+        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):
+                    list_IDs.append(k*ysh*xsh+l*xsh+m)
 
-    # make length of list divisible by batch size
-    rest = batch_size - (len(list_IDs) % batch_size)
-    list_IDs = list_IDs + list_IDs[:rest]
+        # make length of list divisible by batch size
+        rest = bm.batch_size - (len(list_IDs) % bm.batch_size)
+        list_IDs = list_IDs + list_IDs[:rest]
 
-    # number of patches
-    nb_patches = len(list_IDs)
+        # prediction
+        if len(list_IDs) > 400:
+            load_blockwise = True
 
-    # parameters
-    params = {'dim': (z_patch, y_patch, x_patch),
-              'dim_img': (zsh, ysh, xsh),
-              'batch_size': batch_size,
-              'n_channels': csh,
-              'patch_normalization': bm.patch_normalization}
+    # load image data and calculate patch IDs
+    if not load_blockwise:
 
-    # data generator
-    predict_generator = PredictDataGenerator(img, list_IDs, **params)
+        # load prediction data
+        img, img_header, z_shape, y_shape, x_shape, region_of_interest, img_data = load_prediction_data(
+            bm, channels, bm.normalize, normalization_parameters, region_of_interest, img_data, img_header)
 
-    # load model
-    model = load_model(str(path_to_model))
+        # append ghost areas
+        img, z_rest, y_rest, x_rest = append_ghost_areas(bm, img)
+
+        # img shape
+        zsh, ysh, xsh, _ = img.shape
+
+        # list of IDs
+        list_IDs = []
+
+        # get Ids of patches
+        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):
+                    list_IDs.append(k*ysh*xsh+l*xsh+m)
+
+        # make length of list divisible by batch size
+        rest = bm.batch_size - (len(list_IDs) % bm.batch_size)
+        list_IDs = list_IDs + list_IDs[:rest]
+
+        # number of patches
+        nb_patches = len(list_IDs)
+
+    # load all patches on GPU memory
+    if not load_blockwise and nb_patches < 400:
+
+        # parameters
+        params = {'dim': (bm.z_patch, bm.y_patch, bm.x_patch),
+                  'dim_img': (zsh, ysh, xsh),
+                  'batch_size': bm.batch_size,
+                  'n_channels': channels,
+                  'patch_normalization': bm.patch_normalization}
 
-    # predict
-    if nb_patches < 400:
+        # data generator
+        predict_generator = PredictDataGenerator(img, list_IDs, **params)
+
+        # predict probabilities
         probabilities = model.predict(predict_generator, verbose=0, steps=None)
+
+        # create final
+        final = 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):
+                    final[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch] += probabilities[nb]
+                    nb += 1
+
+        # calculate result
+        label = np.argmax(final, axis=-1).astype(np.uint8)
+
     else:
-        X = np.empty((batch_size, z_patch, y_patch, x_patch, csh), dtype=np.float32)
-        probabilities = np.zeros((nb_patches, z_patch, y_patch, x_patch, nb_labels), dtype=np.float32)
-
-        # get image patches
-        for step in range(nb_patches//batch_size):
-            for i, ID in enumerate(list_IDs[step*batch_size:(step+1)*batch_size]):
-
-                # get patch indices
-                k = ID // (ysh*xsh)
-                rest = ID % (ysh*xsh)
-                l = rest // xsh
-                m = rest % xsh
-
-                # get patch
-                tmp_X = img[k:k+z_patch,l:l+y_patch,m:m+x_patch]
-                if bm.patch_normalization:
-                    tmp_X = np.copy(tmp_X, order='C')
-                    for c in range(csh):
-                        tmp_X[:,:,:,c] -= np.mean(tmp_X[:,:,:,c])
-                        tmp_X[:,:,:,c] /= max(np.std(tmp_X[:,:,:,c]), 1e-6)
-                X[i] = tmp_X
-
-            probabilities[step*batch_size:(step+1)*batch_size] = model.predict(X, verbose=0, steps=None, batch_size=batch_size)
-
-    # create final
-    final = np.zeros((zsh, ysh, xsh, nb_labels), dtype=np.float32)
-    if bm.return_probs:
-        counter = np.zeros((zsh, ysh, xsh, nb_labels), dtype=np.float32)
-    nb = 0
-    for k in range(0, zsh-z_patch+1, stride_size):
-        for l in range(0, ysh-y_patch+1, stride_size):
-            for m in range(0, xsh-x_patch+1, stride_size):
-                final[k:k+z_patch, l:l+y_patch, m:m+x_patch] += probabilities[nb]
+        # 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:
+            final = np.zeros((zsh, ysh, xsh, nb_labels), dtype=np.float32)
+
+        # allocate result array
+        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):
+
+            # load blockwise
+            if load_blockwise:
+                img, _, _, _, _, _, _ = load_prediction_data(bm,
+                    channels, bm.normalize, normalization_parameters,
+                    region_of_interest, img_data, img_header, load_blockwise, z)
+                img, _, _, _ = append_ghost_areas(bm, img)
+
+            # list of IDs
+            list_IDs = []
+
+            # get Ids of patches
+            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):
+                    list_IDs.append(z*ysh*xsh+l*xsh+m)
+
+            # make length of list divisible by batch size
+            max_i = len(list_IDs)
+            rest = bm.batch_size - (len(list_IDs) % bm.batch_size)
+            list_IDs = list_IDs + list_IDs[:rest]
+
+            # number of patches
+            nb_patches = len(list_IDs)
+
+            # allocate tmp probabilities array
+            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):
+                for i, ID in enumerate(list_IDs[step*bm.batch_size:(step+1)*bm.batch_size]):
+
+                    # get patch indices
+                    k=0 if load_blockwise else ID // (ysh*xsh)
+                    rest = ID % (ysh*xsh)
+                    l = rest // xsh
+                    m = rest % xsh
+
+                    # get patch
+                    tmp_X = img[k:k+bm.z_patch,l:l+bm.y_patch,m:m+bm.x_patch]
+                    if bm.patch_normalization:
+                        tmp_X = np.copy(tmp_X, order='C')
+                        for c in range(channels):
+                            tmp_X[:,:,:,c] -= np.mean(tmp_X[:,:,:,c])
+                            tmp_X[:,:,:,c] /= max(np.std(tmp_X[:,:,:,c]), 1e-6)
+                    X[i] = tmp_X
+
+                # predict batch
+                Y = model.predict(X, verbose=0, steps=None, batch_size=bm.batch_size)
+
+                # loop over result patches
+                for i, ID in enumerate(list_IDs[step*bm.batch_size:(step+1)*bm.batch_size]):
+                    rest = ID % (ysh*xsh)
+                    l = rest // xsh
+                    m = rest % xsh
+                    if i < max_i:
+                        probs[:,l:l+bm.y_patch,m:m+bm.x_patch] += Y[i]
+
+            # 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:
-                    counter[k:k+z_patch, l:l+y_patch, m:m+x_patch] += 1
-                nb += 1
+                    final[z:z+bm.z_patch] = probs
+            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]
+
+    # 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 not no_scaling:
+        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[:]
@@ -1096,12 +1268,8 @@ def predict_semantic_segmentation(bm, img, path_to_model,
             probabilities = np.copy(tmp, order='C')
         results['probs'] = probabilities
 
-    # get final
-    label = np.argmax(final, axis=3)
-    label = label.astype(np.uint8)
-
     # rescale final to input size
-    if not no_scaling:
+    if bm.scaling:
         label = img_resize(label, z_shape, y_shape, x_shape, labels=True)
 
     # revert automatic cropping
@@ -1130,10 +1298,10 @@ def predict_semantic_segmentation(bm, img, path_to_model,
     # handle amira header
     if header is not None:
         if extension == '.am':
-            header = get_image_dimensions(header[0], label)
+            header = set_image_dimensions(header[0], label)
             if img_header is not None:
                 try:
-                    header = get_physical_size(header, img_header[0])
+                    header = set_physical_size(header, img_header[0])
                 except:
                     pass
             header = [header]
@@ -1151,7 +1319,7 @@ def predict_semantic_segmentation(bm, img, path_to_model,
 
     # save result
     if bm.path_to_image:
-        save_data(bm.path_to_final, label, header=header, compress=compress)
+        save_data(bm.path_to_final, label, header=header, compress=bm.compression)
 
         # paths to optional results
         filename, extension = os.path.splitext(bm.path_to_final)
@@ -1169,17 +1337,17 @@ def predict_semantic_segmentation(bm, img, path_to_model,
         cleaned_result = clean(label, bm.clean)
         results['cleaned'] = cleaned_result
         if bm.path_to_image:
-            save_data(path_to_cleaned, cleaned_result, header=header, compress=compress)
+            save_data(path_to_cleaned, cleaned_result, header=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=header, compress=compress)
+            save_data(path_to_filled, filled_result, header=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=header, compress=compress)
+            save_data(path_to_cleaned_filled, cleaned_filled_result, header=header, compress=bm.compression)
 
     # post-processing with active contour
     if bm.acwe:
@@ -1188,8 +1356,8 @@ def predict_semantic_segmentation(bm, img, path_to_model,
         results['acwe'] = acwe_result
         results['refined'] = refined_result
         if bm.path_to_image:
-            save_data(path_to_acwe, acwe_result, header=header, compress=compress)
-            save_data(path_to_refined, refined_result, header=header, compress=compress)
+            save_data(path_to_acwe, acwe_result, header=header, compress=bm.compression)
+            save_data(path_to_refined, refined_result, header=header, compress=bm.compression)
 
     return results, bm
 

biomedisa/features/remove_outlier.py

@@ -143,7 +143,7 @@ def fill(image, threshold=0.9):
     return image_i
 
 def main_helper(path_to_labels, img_id=None, friend_id=None, fill_holes=True,
-    clean_threshold=0.1, fill_threshold=0.9, remote=False, no_compression=False):
+    clean_threshold=0.1, fill_threshold=0.9, remote=False, compression=True):
 
     # django environment
     if img_id is not None:
@@ -151,12 +151,6 @@ def main_helper(path_to_labels, img_id=None, friend_id=None, fill_holes=True,
     else:
         django_env = False
 
-    # compression
-    if no_compression:
-        compression = False
-    else:
-        compression = True
-
     # final filenames
     filename, extension = os.path.splitext(path_to_labels)
     if extension == '.gz':
@@ -350,7 +344,7 @@ def init_remove_outlier(image_id, final_id, label_id, fill_holes=True):
             try:
                 main_helper(final.pic.path, img_id=image_id, friend_id=final.friend,
                     fill_holes=fill_holes, clean_threshold=label.delete_outliers, fill_threshold=label.fill_holes, remote=False,
-                    no_compression=(False if label.compression else True))
+                    compression=label.compression)
             except Exception as e:
                 print(traceback.format_exc())
 
@@ -377,7 +371,7 @@ if __name__ == '__main__':
                         help='Remove outliers, e.g. 0.5 means that objects smaller than 50 percent of the size of the largest object will be removed')
     parser.add_argument('-f', '--fill_threshold', type=float, default=0.9,
                         help='Fill holes, e.g. 0.5 means that all holes smaller than 50 percent of the entire label will be filled')
-    parser.add_argument('-nc', '--no_compression', action='store_true', default=False,
+    parser.add_argument('-nc', '--no-compression', dest='compression', action='store_false',
                         help='Disable compression of segmentation results')
     parser.add_argument('-iid','--img_id', type=str, default=None,
                         help='Image ID within django environment/browser version')

biomedisa/interpolation.py

@@ -42,7 +42,7 @@ class Biomedisa(object):
 
 def smart_interpolation(data, labelData, nbrw=10, sorw=4000, acwe=False, acwe_alpha=1.0, acwe_smooth=1, acwe_steps=3,
     path_to_data=None, path_to_labels=None, denoise=False, uncertainty=False, platform=None,
-    allaxis=False, ignore='none', only='all', smooth=0, no_compression=False, return_hits=False,
+    allaxis=False, ignore='none', only='all', smooth=0, compression=True, return_hits=False,
     img_id=None, label_id=None, remote=False, queue=0, clean=None, fill=None):
 
     freeze_support()
@@ -73,12 +73,6 @@ def smart_interpolation(data, labelData, nbrw=10, sorw=4000, acwe=False, acwe_al
         else:
             bm.django_env = False
 
-        # compression
-        if no_compression:
-            bm.compression = False
-        else:
-            bm.compression = True
-
         # disable file saving when called as a function
         if bm.data is not None:
             bm.path_to_data = None
@@ -149,19 +143,18 @@ def smart_interpolation(data, labelData, nbrw=10, sorw=4000, acwe=False, acwe_al
                 bm.path_to_acwe = filename + '.acwe' + bm.final_image_type
                 bm.path_to_uq = filename + '.uncertainty.tif'
 
-            # data type
-            if bm.data.dtype == 'uint8':
-                pass
-            elif bm.data.dtype == 'int8':
+            # data types
+            if bm.data.dtype == 'int8':
                 bm.data = bm.data.astype(np.int16)
                 bm.data += 128
                 bm.data = bm.data.astype(np.uint8)
-            else:
-                bm.data = bm.data.astype(float)
+            elif bm.data.dtype != 'uint8':
+                bm.data = bm.data.astype(np.float32)
                 bm.data -= np.amin(bm.data)
                 bm.data /= np.amax(bm.data)
                 bm.data *= 255.0
-                bm.data = bm.data.astype(np.float32)
+            if bm.labelData.dtype in ['uint32','int64','uint64']:
+                bm.labelData = bm.labelData.astype(np.int32)
 
             # denoise image data
             if bm.denoise:
@@ -332,7 +325,7 @@ if __name__ == '__main__':
                         help='Smoothing steps of active contour')
     parser.add_argument('--acwe_steps', metavar='STEPS', type=int, default=3,
                         help='Iterations of active contour')
-    parser.add_argument('-nc', '--no_compression', action='store_true', default=False,
+    parser.add_argument('-nc', '--no-compression', dest='compression', action='store_false',
                         help='Disable compression of segmentation results')
     parser.add_argument('-allx', '--allaxis', action='store_true', default=False,
                         help='If pre-segmentation is not exlusively in xy-plane')

biomedisa/mesh.py

@@ -29,6 +29,7 @@
 
 import os
 import numpy as np
+import biomedisa
 from biomedisa.features.biomedisa_helper import load_data, unique_file_path
 from biomedisa.features.django_env import create_pid_object
 from vtk.util.numpy_support import vtk_to_numpy, numpy_to_vtk
@@ -167,8 +168,7 @@ def save_mesh(path_to_result, labels, x_res=1, y_res=1, z_res=1,
         mesh_final.attr[start:stop,0] = i+1
     mesh_final.save(path_to_result)
 
-def get_voxel_spacing(header, data, extension):
-
+def get_voxel_spacing(header, extension):
     if extension == '.am':
         # read header as string
         b = header[0].tobytes()
@@ -176,21 +176,23 @@ def get_voxel_spacing(header, data, extension):
             s = b.decode("utf-8")
         except:
             s = b.decode("latin1")
-
         # get physical size from image header
+        lattice = re.search('define Lattice (.*)\n', s)
         bounding_box = re.search('BoundingBox (.*),\n', s)
-        if bounding_box:
+        if bounding_box and lattice:
+            # get number of voxels
+            lattice = lattice.group(1)
+            xsh, ysh, zsh = lattice.split(' ')
+            xsh, ysh, zsh = float(xsh), float(ysh), float(zsh)
+            # get bounding box
             bounding_box = bounding_box.group(1)
             i0, i1, i2, i3, i4, i5 = bounding_box.split(' ')
-
-            # voxel spacing
-            zsh, ysh, xsh = data.shape
+            # calculate voxel spacing
             xres = (float(i1)-float(i0)) / xsh
             yres = (float(i3)-float(i2)) / ysh
             zres = (float(i5)-float(i4)) / zsh
         else:
             xres, yres, zres = 1, 1, 1
-
     elif extension in ['.hdr', '.mhd', '.mha', '.nrrd', '.nii', '.nii.gz']:
         xres, yres, zres = header.GetSpacing()
     elif extension == '.zip':
@@ -203,7 +205,6 @@ def get_voxel_spacing(header, data, extension):
     else:
         print('Warning: could not get voxel spacing. Using x_spacing, y_spacing, z_spacing = 1, 1, 1 instead.')
         xres, yres, zres = 1, 1, 1
-
     return xres, yres, zres
 
 def init_create_mesh(id):
@@ -324,7 +325,7 @@ def init_create_mesh(id):
                         log=1, imageType=None, shortfilename='Invalid label data.')
                 else:
                     # get voxel spacing
-                    xres, yres, zres = get_voxel_spacing(header, data, extension)
+                    xres, yres, zres = get_voxel_spacing(header, extension)
                     print(f'Voxel spacing: x_spacing, y_spacing, z_spacing = {xres}, {yres}, {zres}')
 
                     # create stl file
@@ -386,7 +387,7 @@ if __name__ == "__main__":
 
         # get voxel spacing
         if not all([bm.x_res, bm.y_res, bm.z_res]):
-            x_res, y_res, z_res = get_voxel_spacing(header, bm.labels, extension)
+            x_res, y_res, z_res = get_voxel_spacing(header, extension)
             if not bm.x_res:
                 bm.x_res = x_res
             if not bm.y_res:

{biomedisa-24.5.23.dist-info → biomedisa-24.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biomedisa
-Version: 24.5.23
+Version: 24.7.1
 Summary: Segmentation of 3D volumetric image data
 Author: Philipp Lösel
 Author-email: philipp.loesel@anu.edu.au
@@ -33,18 +33,21 @@ License-File: LICENSE
 - [License](#license)
 
 ## Overview
-Biomedisa (https://biomedisa.info) is a free and easy-to-use open-source application for segmenting large volumetric images, e.g. CT and MRI scans, developed at [The Australian National University CTLab](https://ctlab.anu.edu.au/). Biomedisa's semi-automated segmentation is based on a smart interpolation of sparsely pre-segmented slices, taking into account the complete underlying image data. In addition, Biomedisa enables deep learning for the fully automated segmentation of series of similar samples. It can be used in combination with segmentation tools such as 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 or an Intel CPU
 
 ## Installation (command-line based)
 + [Ubuntu 22.04 + CUDA + GPU (recommended)](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_cli.md)
-+ [Ubuntu 22.04 + OpenCL + CPU (smart interpolation only and very slow)](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_opencl_cpu_cli.md)
++ [Ubuntu 22.04 + OpenCL + CPU (very slow)](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_opencl_cpu_cli.md)
 + [Windows 10 + CUDA + GPU (recommended)](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_cli.md)
 + [Windows 10 + OpenCL + GPU (easy to install but lacks features like allaxis, smoothing, uncertainty, optimized GPU memory usage)](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_opencl_gpu_cli.md)
 + [Windows 10 + OpenCL + CPU (very slow)](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_opencl_cpu_cli.md)
 
+## Installation (3D Slicer extension)
++ [Ubuntu 22.04 + CUDA + GPU](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_slicer.md)
+
 ## Installation (browser based)
 + [Ubuntu 22.04](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8.md)
 
@@ -52,6 +55,9 @@ Biomedisa (https://biomedisa.info) is a free and easy-to-use open-source applica
 + Download test data from our [gallery](https://biomedisa.info/gallery/)
 
 ## Revisions
+24.7.1
++ 3D Slicer extension
++ Prediction of large data block by block
 24.5.22
 + Pip is the preferred installation method
 + Commands, module names and imports have been changed to conform to the Pip standard
@@ -131,15 +137,14 @@ deep_learning(img_data, label_data, train=True, batch_size=12,
 ```
 
 #### Command-line based (training)
-Start training with a batch size of 12:
 ```
-python -m biomedisa.deeplearning C:\Users\%USERNAME%\Downloads\training_heart C:\Users\%USERNAME%\Downloads\training_heart_labels -t -bs=12
+python -m biomedisa.deeplearning C:\Users\%USERNAME%\Downloads\training_heart C:\Users\%USERNAME%\Downloads\training_heart_labels -t
 ```
 Monitor training progress using validation data:
 ```
 python -m biomedisa.deeplearning C:\Users\%USERNAME%\Downloads\training_heart C:\Users\%USERNAME%\Downloads\training_heart_labels -t -vi=C:\Users\%USERNAME%\Downloads\val_img -vl=C:\Users\%USERNAME%\Downloads\val_labels
 ```
-If running into ResourceExhaustedError due to out of memory (OOM), try to use a smaller batch size.
+If running into ResourceExhaustedError due to out of memory (OOM), try to use a smaller batch size (e.g. -bs=12).
 
 #### Python example (prediction)
 ```python
@@ -175,7 +180,7 @@ from biomedisa.mesh import get_voxel_spacing, save_mesh
 data, header, extension = load_data('final.Head5.am', return_extension=True)
 
 # get voxel spacing
-x_res, y_res, z_res = get_voxel_spacing(header, data, extension)
+x_res, y_res, z_res = get_voxel_spacing(header, extension)
 print(f'Voxel spacing: x_spacing, y_spacing, z_spacing = {x_res}, {y_res}, {z_res}')
 
 # save stl file

{biomedisa-24.5.23.dist-info → biomedisa-24.7.1.dist-info}/RECORD

@@ -1,26 +1,26 @@
 biomedisa/__init__.py,sha256=hw4mzEjGFXm-vxus2DBfKFW0nKoG0ibL5SH6ShfchrY,1526
 biomedisa/__main__.py,sha256=a1--8vhtztWEloHVtbM43FZLCfrFo4BELgdsgtWE8ls,536
-biomedisa/deeplearning.py,sha256=UG5baX58CrO8YXe9pU6_Bp2OOvbC74LQw4S33HqM2iA,27828
-biomedisa/interpolation.py,sha256=R8UbBWt7vOuiQCPSeNIpEY0_yfQUg1oBfhAjXi91Hl4,17253
-biomedisa/mesh.py,sha256=glvpTN0PPByb5j2IbLCdWQtc5O4VT-Pwu3en8EaYyTo,15819
-biomedisa/features/DataGenerator.py,sha256=bGys6UZ0bnKb_k1Y3Spo6MNPk_goSAmptdZnI39smaw,12770
+biomedisa/deeplearning.py,sha256=eVFoy3FsSb8h2hqFBdI8kz63tATLUvuMfSPzSa_wX5Q,27813
+biomedisa/interpolation.py,sha256=tehhMhm3WEVzUpfAemujMixJMK6BMNLQ6uw7Z9TR9Go,17163
+biomedisa/mesh.py,sha256=8-iuVsrfW5JovaMrAez7qSxv1LCU3eiqOdik0s0DV1w,16062
+biomedisa/features/DataGenerator.py,sha256=MYPSY9-ssMwPx9UOI_ZfE7_5rddOSn4aHbVQ0HtYQVA,12757
 biomedisa/features/DataGeneratorCrop.py,sha256=23R4Z-8tB1CsjYTYfhHGovlJpAny_q9OV9hq8kc2GJg,5454
 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
-biomedisa/features/active_contour.py,sha256=n5_vAD8jvQjU6fQ6A9hxjSmtkLLo_1fl0S5q1H2pmVg,18096
+biomedisa/features/active_contour.py,sha256=FnPuvYck_KL4xYRFqwzm4Grdm288EdlcLFt88E0OtqA,17938
 biomedisa/features/assd.py,sha256=q9NUQXEoA4Pi3d8b5fmys615CWu06Sm0N9-OGwJOFnw,6537
-biomedisa/features/biomedisa_helper.py,sha256=iLbt4RpCU3EK51uiMefkM0321AgBdeLgrT-X4d--YJY,32250
-biomedisa/features/create_slices.py,sha256=tLDJmuJFN8teTiCYvMauExfVzT2ZUF28VcPXpo4sOsE,13001
+biomedisa/features/biomedisa_helper.py,sha256=d5wCtiP8pRTUbXv-jrN-b7cNStm8T1B_FtQR2Msd5OY,32286
+biomedisa/features/create_slices.py,sha256=uSDH1OcEYc5BFPZHSy3UpS4P2DuoVnxOZ-l7wmyT_Po,13108
 biomedisa/features/crop_helper.py,sha256=si72n9Q-C7U0cXYOD9Ux2UqIbZdXbZSOARBYDeqRggI,24533
 biomedisa/features/curvop_numba.py,sha256=AjKQJcUBoURTB8pq1HmugQYpBwBELthhcEu51_r_xPI,7049
 biomedisa/features/django_env.py,sha256=pdiPcBpqu1BWuyvh-palIGVwHFaY-leQ4Gatlbm8hIg,8942
-biomedisa/features/keras_helper.py,sha256=muPwb_W7O63exzWACJ4oLdAc-AQitcxLeNwgHvxyhuE,50488
+biomedisa/features/keras_helper.py,sha256=0rgMLD3mvLuV9PFbsOwypH4fr3IhPkQveCtUiqTCZdc,57270
 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
 biomedisa/features/pycuda_test.py,sha256=UGAGIz_dgcCJkzjyCqnMlflp-WJPzpCtFQmE9C5DwIo,3275
-biomedisa/features/remove_outlier.py,sha256=XhbFPkazMmEUZiP0FERdCkrXaLhwO095x4wcn-B3SdU,16756
+biomedisa/features/remove_outlier.py,sha256=C2m-Wsw-n3q8Ft21SGNwEd3wDU_T1ghqQ5hldwU_rqI,16627
 biomedisa/features/split_volume.py,sha256=UgMpHhZPvH90xFo-mJ0Oc0tBXbrf8FQF0kzVySAlO8g,8917
 biomedisa/features/amira_to_np/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 biomedisa/features/amira_to_np/amira_data_stream.py,sha256=JrZTyKP01CKDFB5d9BlGtSFwBgoAo0AJeAmn3pADH88,32618
@@ -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.5.23.dist-info/LICENSE,sha256=sehayP6UhydNnmstfL4yFR3genMRdpuUh6uZVWJN1H0,14152
-biomedisa-24.5.23.dist-info/METADATA,sha256=XIEKdnTY54QTALYPtNambyN7NP7_e76S2Mo99Ubifv8,10475
-biomedisa-24.5.23.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-biomedisa-24.5.23.dist-info/top_level.txt,sha256=opsf1Eb4vCguPSxev4HHSeiUKCccT_C_RcUCdAYbHWQ,10
-biomedisa-24.5.23.dist-info/RECORD,,
+biomedisa-24.7.1.dist-info/LICENSE,sha256=sehayP6UhydNnmstfL4yFR3genMRdpuUh6uZVWJN1H0,14152
+biomedisa-24.7.1.dist-info/METADATA,sha256=4ziBlBpd6JbYp9YSmxs0ptZpm_XX3J4pERQAL6Kg118,10631
+biomedisa-24.7.1.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+biomedisa-24.7.1.dist-info/top_level.txt,sha256=opsf1Eb4vCguPSxev4HHSeiUKCccT_C_RcUCdAYbHWQ,10
+biomedisa-24.7.1.dist-info/RECORD,,

{biomedisa-24.5.23.dist-info → biomedisa-24.7.1.dist-info}/WHEEL

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