biomedisa 24.8.3__tar.gz → 24.8.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biomedisa
-Version: 24.8.3
+Version: 24.8.5
 Summary: Segmentation of 3D volumetric image data
 Author: Philipp Lösel
 Author-email: philipp.loesel@anu.edu.au

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

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

{biomedisa-24.8.3 → biomedisa-24.8.5}/src/biomedisa/deeplearning.py

@@ -100,6 +100,15 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
         bm.normalize = 0
         bm.patch_normalization = True
 
+    # region of interest
+    if any([bm.x_range, bm.y_range, bm.z_range]):
+        if not bm.x_range:
+            bm.x_range = [0,None]
+        if not bm.y_range:
+            bm.y_range = [0,None]
+        if not bm.z_range:
+            bm.z_range = [0,None]
+
     # django environment
     if bm.django_env:
 
@@ -148,7 +157,7 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
         raise Exception("'path_to_model' must be specified")
 
     # disable file saving when called as a function
-    if img_data is not None:
+    if bm.img_data is not None:
         bm.path_to_images = None
         bm.path_to_cropped_image = None
 
@@ -194,19 +203,10 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
         # train automatic cropping
         bm.cropping_weights, bm.cropping_config, bm.cropping_norm = None, None, None
         if bm.crop_data:
-            bm.cropping_weights, bm.cropping_config, bm.cropping_norm = ch.load_and_train(
-                        bm.normalize, bm.path_to_images, bm.path_to_labels, bm.path_to_model,
-                        bm.cropping_epochs, bm.batch_size, bm.validation_split,
-                        bm.flip_x, bm.flip_y, bm.flip_z, bm.rotate, bm.only, bm.ignore,
-                        bm.val_images, bm.val_labels, img_data, label_data,
-                        val_img_data, val_label_data)
+            bm.cropping_weights, bm.cropping_config, bm.cropping_norm = ch.load_and_train(bm)
 
         # train automatic segmentation
-        train_semantic_segmentation(bm, bm.path_to_images, bm.path_to_labels,
-                        bm.val_images, bm.val_labels,
-                        img_data, label_data,
-                        val_img_data, val_label_data,
-                        header, extension)
+        train_segmentation(bm)
 
     if bm.predict:
 
@@ -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 header is None and meta.get('header') is not None:
-            header = [np.array(meta.get('header'))]
-            extension = '.am'
+        if bm.header is None and meta.get('header') is not None:
+            bm.header = [np.array(meta.get('header'))]
+            bm.extension = '.am'
+
+        # crop data
         crop_data = True if 'cropping_weights' in hf else False
         hf.close()
 
@@ -284,20 +286,19 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
                     filename = 'final.' + filename
                     if bm.refinement:
                         filename += '.refined'
-                    bm.path_to_final = os.path.dirname(bm.path_to_image) + '/' + filename + extension
+                    bm.path_to_final = os.path.dirname(bm.path_to_image) + '/' + filename + 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)
 
                 # crop data
                 region_of_interest, cropped_volume = None, None
-                if crop_data:
-                    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)
+                if any([bm.x_range, bm.y_range, bm.z_range]):
+                    region_of_interest = [bm.z_range[0], bm.z_range[1], bm.y_range[0], bm.y_range[1], bm.x_range[0], bm.x_range[1]]
+                elif crop_data:
+                    region_of_interest, cropped_volume = ch.crop_data(bm)
 
                 # make prediction
-                results, bm = predict_semantic_segmentation(bm,
-                    header, img_header,
-                    region_of_interest, extension, img_data,
+                results, bm = predict_segmentation(bm, region_of_interest,
                     channels, normalization_parameters)
 
                 # results
@@ -331,11 +332,10 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
     if bm.django_env:
         from biomedisa_app.config import config
         from biomedisa.features.django_env import post_processing
-        validation=True if bm.validation_split or (bm.val_images is not None and bm.val_images[0] is not None) else False
         post_processing(bm.path_to_final, time_str, config['SERVER_ALIAS'], bm.remote, bm.queue,
             img_id=bm.img_id, label_id=bm.label_id, path_to_model=bm.path_to_model,
             path_to_cropped_image=(bm.path_to_cropped_image if crop_data else None),
-            train=bm.train, predict=bm.predict, validation=validation)
+            train=bm.train, predict=bm.predict)
 
         # write in log file
         path_to_time = biomedisa.BASE_DIR + '/log/time.txt'
@@ -459,9 +459,9 @@ if __name__ == '__main__':
     parser.add_argument('-xr','--x_range', nargs="+", type=int, default=None,
                         help='Manually crop x-axis of image data for prediction, e.g. -xr 100 200')
     parser.add_argument('-yr','--y_range', nargs="+", type=int, default=None,
-                        help='Manually crop y-axis of image data for prediction, e.g. -xr 100 200')
+                        help='Manually crop y-axis of image data for prediction, e.g. -yr 100 200')
     parser.add_argument('-zr','--z_range', nargs="+", type=int, default=None,
-                        help='Manually crop z-axis of image data for prediction, e.g. -xr 100 200')
+                        help='Manually crop z-axis of image data for prediction, e.g. -zr 100 200')
     parser.add_argument('-rp','--return_probs', action='store_true', default=False,
                         help='Return prediction probabilities for each label')
     parser.add_argument('-pn','--patch_normalization', action='store_true', default=False,

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

@@ -393,7 +393,7 @@ def load_data_to_crop(path_to_img, channels, x_scale, y_scale, z_scale,
     return img_rgb, z_shape, y_shape, x_shape, img_data
 
 def crop_volume(img, path_to_model, path_to_final, z_shape, y_shape, x_shape, batch_size,
-        debug_cropping, save_cropped, img_data, x_range, y_range, z_range, x_puffer=25, y_puffer=25, z_puffer=25):
+        debug_cropping, save_cropped, img_data, x_puffer=25, y_puffer=25, z_puffer=25):
 
     # img shape
     zsh, ysh, xsh, channels = img.shape
@@ -467,24 +467,13 @@ def crop_volume(img, path_to_model, path_to_final, z_shape, y_shape, x_shape, ba
         elif np.all(probabilities[k-4:k+5] == np.array([0,1,1,1,1,1,1,1,0])):
             probabilities[k-4:k+5] = 0
 
-    # create final
-    if z_range is not None:
-        z_lower, z_upper = z_range
-    else:
-        z_lower = max(0,np.argmax(probabilities[:z_shape]) - z_puffer)
-        z_upper = min(z_shape,z_shape - np.argmax(np.flip(probabilities[:z_shape])) + z_puffer +1)
-
-    if y_range is not None:
-        y_lower, y_upper = y_range
-    else:
-        y_lower = max(0,np.argmax(probabilities[z_shape:z_shape+y_shape]) - y_puffer)
-        y_upper = min(y_shape,y_shape - np.argmax(np.flip(probabilities[z_shape:z_shape+y_shape])) + y_puffer +1)
-
-    if x_range is not None:
-        x_lower, x_upper = x_range
-    else:
-        x_lower = max(0,np.argmax(probabilities[z_shape+y_shape:]) - x_puffer)
-        x_upper = min(x_shape,x_shape - np.argmax(np.flip(probabilities[z_shape+y_shape:])) + x_puffer +1)
+    # cropping range
+    z_lower = max(0,np.argmax(probabilities[:z_shape]) - z_puffer)
+    z_upper = min(z_shape,z_shape - np.argmax(np.flip(probabilities[:z_shape])) + z_puffer +1)
+    y_lower = max(0,np.argmax(probabilities[z_shape:z_shape+y_shape]) - y_puffer)
+    y_upper = min(y_shape,y_shape - np.argmax(np.flip(probabilities[z_shape:z_shape+y_shape])) + y_puffer +1)
+    x_lower = max(0,np.argmax(probabilities[z_shape+y_shape:]) - x_puffer)
+    x_upper = min(x_shape,x_shape - np.argmax(np.flip(probabilities[z_shape+y_shape:])) + x_puffer +1)
 
     # plot result
     if debug_cropping and path_to_final:
@@ -508,33 +497,28 @@ def crop_volume(img, path_to_model, path_to_final, z_shape, y_shape, x_shape, ba
 # main functions
 #=====================
 
-def load_and_train(normalize,path_to_img,path_to_labels,path_to_model,
-                epochs,batch_size,validation_split,
-                flip_x,flip_y,flip_z,rotate,labels_to_compute,labels_to_remove,
-                path_val_img=[None],path_val_labels=[None],
-                img=None, label=None, img_val=None, label_val=None,
-                x_scale=256, y_scale=256, z_scale=256):
+def load_and_train(bm, x_scale=256, y_scale=256, z_scale=256):
 
     # load training data
-    img, label, normalization_parameters, channels = load_cropping_training_data(normalize,
-                        path_to_img, path_to_labels, x_scale, y_scale, z_scale, labels_to_compute, labels_to_remove,
-                        img, label)
+    img, label, normalization_parameters, channels = load_cropping_training_data(bm.normalize,
+        bm.path_to_images, bm.path_to_labels, x_scale, y_scale, z_scale, bm.only, bm.ignore,
+        bm.img_data, bm.label_data)
 
     # load validation data
-    if any(path_val_img) or img_val is not None:
-        img_val, label_val, _, _ = load_cropping_training_data(normalize,
-                            path_val_img, path_val_labels, x_scale, y_scale, z_scale,
-                            labels_to_compute, labels_to_remove,
-                            img_val, label_val, normalization_parameters, channels)
+    img_val, label_val = None, None
+    if any(bm.val_images) or bm.val_img_data is not None:
+        img_val, label_val, _, _ = load_cropping_training_data(bm.normalize,
+            bm.val_images, bm.val_labels, x_scale, y_scale, z_scale,
+            bm.only, bm.ignore, bm.val_img_data, bm.val_label_data, normalization_parameters, channels)
 
     # train cropping
-    train_cropping(img, label, path_to_model, epochs,
-                    batch_size, validation_split,
-                    flip_x, flip_y, flip_z, rotate,
-                    img_val, label_val)
+    train_cropping(img, label, bm.path_to_model, bm.cropping_epochs,
+        bm.batch_size, bm.validation_split,
+        bm.flip_x, bm.flip_y, bm.flip_z, bm.rotate,
+        img_val, label_val)
 
     # load weights
-    model = load_model(str(path_to_model))
+    model = load_model(str(bm.path_to_model))
     cropping_weights = []
     for layer in model.layers:
         if layer.get_weights() != []:
@@ -542,17 +526,15 @@ def load_and_train(normalize,path_to_img,path_to_labels,path_to_model,
                 cropping_weights.append(arr)
 
     # configuration data
-    cropping_config = np.array([channels, x_scale, y_scale, z_scale, normalize,
+    cropping_config = np.array([channels, x_scale, y_scale, z_scale, bm.normalize,
         normalization_parameters[0,0], normalization_parameters[1,0]])
 
     return cropping_weights, cropping_config, normalization_parameters
 
-def crop_data(path_to_data, path_to_model, path_to_cropped_image, batch_size,
-    debug_cropping=False, save_cropped=True, img_data=None,
-    x_range=None, y_range=None, z_range=None):
+def crop_data(bm):
 
     # get meta data
-    hf = h5py.File(path_to_model, 'r')
+    hf = h5py.File(bm.path_to_model, 'r')
     meta = hf.get('cropping_meta')
     configuration = meta.get('configuration')
     channels, x_scale, y_scale, z_scale, normalize, mu, sig = np.array(configuration)[:]
@@ -567,13 +549,12 @@ def crop_data(path_to_data, path_to_model, path_to_cropped_image, batch_size,
     hf.close()
 
     # load data
-    img, z_shape, y_shape, x_shape, img_data = load_data_to_crop(path_to_data, channels,
-                    x_scale, y_scale, z_scale, normalize, normalization_parameters, img_data)
+    img, z_shape, y_shape, x_shape, bm.img_data = load_data_to_crop(bm.path_to_image, channels,
+        x_scale, y_scale, z_scale, normalize, normalization_parameters, bm.img_data)
 
     # make prediction
-    z_lower, z_upper, y_lower, y_upper, x_lower, x_upper, cropped_volume = crop_volume(img, path_to_model,
-        path_to_cropped_image, z_shape, y_shape, x_shape, batch_size, debug_cropping, save_cropped, img_data,
-        x_range, y_range, z_range)
+    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)
 
     # region of interest
     region_of_interest = np.array([z_lower, z_upper, y_lower, y_upper, x_lower, x_upper])

{biomedisa-24.8.3 → biomedisa-24.8.5}/src/biomedisa/features/django_env.py

@@ -69,7 +69,7 @@ def create_pid_object(pid, remote=False, queue=None, img_id=None, path_to_model=
         image.pid = pid
         image.save()
 
-def post_processing(path_to_final, time_str, server_name, remote, queue, dice=1.0, path_to_model=None, path_to_uq=None, path_to_smooth=None, path_to_cropped_image=None, uncertainty=False, smooth=False, img_id=None, label_id=None, train=False, predict=False, validation=False):
+def post_processing(path_to_final, time_str, server_name, remote, queue, dice=1.0, path_to_model=None, path_to_uq=None, path_to_smooth=None, path_to_cropped_image=None, uncertainty=False, smooth=False, img_id=None, label_id=None, train=False, predict=False):
 
     # remote server
     if remote:
@@ -97,14 +97,9 @@ def post_processing(path_to_final, time_str, server_name, remote, queue, dice=1.
             filename = 'images/' + image.user.username + '/' + shortfilename
             Upload.objects.create(pic=filename, user=image.user, project=image.project, imageType=4, shortfilename=shortfilename)
 
-            if validation:
-                # create acc object
-                shortfilename = os.path.basename(path_to_model.replace('.h5','_acc.png'))
-                filename = 'images/' + image.user.username + '/' + shortfilename
-                Upload.objects.create(pic=filename, user=image.user, project=image.project, imageType=6, shortfilename=shortfilename)
-
-                # create loss object
-                shortfilename = os.path.basename(path_to_model.replace('.h5','_loss.png'))
+            # create monitoring objects
+            for suffix in ['_acc.png', '_loss.png', '.csv']:
+                shortfilename = os.path.basename(path_to_model.replace('.h5', suffix))
                 filename = 'images/' + image.user.username + '/' + shortfilename
                 Upload.objects.create(pic=filename, user=image.user, project=image.project, imageType=6, shortfilename=shortfilename)
 

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

@@ -61,45 +61,65 @@ import time
 import h5py
 import atexit
 import tempfile
+import csv
 
 class InputError(Exception):
     def __init__(self, message=None):
         self.message = message
 
-def save_history(history, path_to_model, val_dice, train_dice):
-    # summarize history for accuracy
+def save_csv(path, history):
+    # remove empty keys
+    to_delete = []
+    for key in history.keys():
+        if len(history[key])==0:
+            to_delete.append(key)
+    for key in to_delete:
+        del history[key]
+    # open a file in write mode
+    with open(path, 'w', newline='') as file:
+        writer = csv.DictWriter(file, fieldnames=history.keys())
+        # write header
+        writer.writeheader()
+        # write data rows (use zip to iterate over values)
+        for row in zip(*history.values()):
+            writer.writerow(dict(zip(history.keys(), row)))
+
+def save_history(history, path_to_model):
+    # standard accuracy history
     plt.plot(history['accuracy'])
-    plt.plot(history['val_accuracy'])
-    if val_dice and train_dice:
+    legend = ['Accuracy (train)']
+    if 'val_accuracy' in history and len(history['val_accuracy'])>0:
+        plt.plot(history['val_accuracy'])
+        legend.append('Accuracy (test)')
+    # dice history
+    if 'dice' in history and len(history['dice'])>0:
         plt.plot(history['dice'])
+        legend.append('Dice score (train)')
+    if 'val_dice' in history and len(history['val_dice'])>0:
         plt.plot(history['val_dice'])
-        plt.legend(['Accuracy (train)', 'Accuracy (test)', 'Dice score (train)', 'Dice score (test)'], loc='upper left')
-    elif train_dice:
-        plt.plot(history['dice'])
-        plt.legend(['Accuracy (train)', 'Accuracy (test)', 'Dice score (train)'], loc='upper left')
-    elif val_dice:
-        plt.plot(history['val_dice'])
-        plt.legend(['Accuracy (train)', 'Accuracy (test)', 'Dice score (test)'], loc='upper left')
-    else:
-        plt.legend(['Accuracy (train)', 'Accuracy (test)'], loc='upper left')
+        legend.append('Dice score (test)')
     plt.title('model accuracy')
     plt.ylabel('accuracy')
     plt.xlabel('epoch')
+    plt.legend(legend, loc='upper left')
     plt.tight_layout()  # To prevent overlapping of subplots
     plt.savefig(path_to_model.replace('.h5','_acc.png'), dpi=300, bbox_inches='tight')
     plt.clf()
-    # summarize history for loss
+    # loss history
     plt.plot(history['loss'])
-    plt.plot(history['val_loss'])
+    legend = ['train']
+    if 'val_loss' in history and len(history['val_loss'])>0:
+        plt.plot(history['val_loss'])
+        legend.append('test')
     plt.title('model loss')
     plt.ylabel('loss')
     plt.xlabel('epoch')
-    plt.legend(['train', 'test'], loc='upper left')
+    plt.legend(legend, loc='upper left')
     plt.tight_layout()  # To prevent overlapping of subplots
     plt.savefig(path_to_model.replace('.h5','_loss.png'), dpi=300, bbox_inches='tight')
     plt.clf()
-    # save history dictonary
-    np.save(path_to_model.replace('.h5','.npy'), history)
+    # save history as csv
+    save_csv(path_to_model.replace('.h5','.csv'), history)
 
 def predict_blocksize(labelData, x_puffer=25, y_puffer=25, z_puffer=25):
     zsh, ysh, xsh = labelData.shape
@@ -355,8 +375,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(bm, 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,
+def load_training_data(bm, img_list, label_list, channels, img_in=None, label_in=None,
         normalization_parameters=None, allLabels=None, header=None, extension='.tif',
         x_puffer=25, y_puffer=25, z_puffer=25):
 
@@ -381,20 +400,26 @@ def load_training_data(bm, normalize, img_list, label_list, channels, x_scale, y
                 label = label_in
                 label_names = ['label_1']
             label_dim = label.shape
-            label = set_labels_to_zero(label, labels_to_compute, labels_to_remove)
-            if scaling:
+            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:
+                    InputError.message = 'Training on region of interest is only supported for one volume.'
+                    raise InputError()
+                argmin_z, argmax_z, argmin_y, argmax_y, argmin_x, argmax_x = \
+                    bm.z_range[0], bm.z_range[1], bm.y_range[0], bm.y_range[1], bm.x_range[0], bm.x_range[1]
+                label = label[argmin_z:argmax_z,argmin_y:argmax_y,argmin_x:argmax_x].copy()
+            elif bm.crop_data:
+                argmin_z,argmax_z,argmin_y,argmax_y,argmin_x,argmax_x = predict_blocksize(label, x_puffer, y_puffer, z_puffer)
+                label = label[argmin_z:argmax_z,argmin_y:argmax_y,argmin_x:argmax_x].copy()
+            if bm.scaling:
                 label_values, counts = np.unique(label, return_counts=True)
                 print(f'{os.path.basename(label_names[0])}:', 'Labels:', label_values[1:], 'Sizes:', counts[1:])
-            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 scaling:
-                label = img_resize(label, z_scale, y_scale, x_scale, labels=True)
+                label = img_resize(label, bm.z_scale, bm.y_scale, bm.x_scale, labels=True)
 
             # 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 -hf or --header_file="path_to_training_label{extension}" for prediction to save your result as "{extension}"')
+                    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.')
@@ -429,13 +454,13 @@ def load_training_data(bm, normalize, img_list, label_list, channels, x_scale, y
                 raise InputError()
 
             # crop data
-            if crop_data:
-                img = np.copy(img[argmin_z:argmax_z,argmin_y:argmax_y,argmin_x:argmax_x], order='C')
+            if any([bm.x_range, bm.y_range, bm.z_range]) or bm.crop_data:
+                img = img[argmin_z:argmax_z,argmin_y:argmax_y,argmin_x:argmax_x].copy()
 
             # scale/resize image data
             img = img.astype(np.float32)
-            if 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):
@@ -445,7 +470,7 @@ def load_training_data(bm, normalize, img_list, label_list, channels, x_scale, y
                     normalization_parameters = np.zeros((2,channels))
                     normalization_parameters[0,c] = np.mean(img[:,:,:,c])
                     normalization_parameters[1,c] = np.std(img[:,:,:,c])
-                elif normalize:
+                elif bm.normalize:
                     mean, std = np.mean(img[:,:,:,c]), np.std(img[:,:,:,c])
                     img[:,:,:,c] = (img[:,:,:,c] - mean) / std
                     img[:,:,:,c] = img[:,:,:,c] * normalization_parameters[1,c] + normalization_parameters[0,c]
@@ -465,15 +490,14 @@ def load_training_data(bm, normalize, img_list, label_list, channels, x_scale, y
                     else:
                         a = label_in[k]
                     label_dim = a.shape
-                    a = set_labels_to_zero(a, labels_to_compute, labels_to_remove)
-                    if scaling:
-                        label_values, counts = np.unique(a, return_counts=True)
-                        print(f'{os.path.basename(label_names[k])}:', 'Labels:', label_values[1:], 'Sizes:', counts[1:])
-                    if crop_data:
+                    a = set_labels_to_zero(a, bm.only, bm.ignore)
+                    if bm.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 scaling:
-                        a = img_resize(a, z_scale, y_scale, x_scale, labels=True)
+                    if bm.scaling:
+                        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)
 
                     # append image
@@ -493,15 +517,15 @@ def load_training_data(bm, normalize, img_list, label_list, channels, x_scale, y
                     if a.shape[3] != channels:
                         InputError.message = f'Number of channels must be {channels} for "{os.path.basename(img_names[k])}"'
                         raise InputError()
-                    if crop_data:
+                    if bm.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 scaling:
-                        a = img_resize(a, z_scale, y_scale, x_scale)
+                    if bm.scaling:
+                        a = img_resize(a, bm.z_scale, bm.y_scale, bm.x_scale)
                     for c in range(channels):
                         a[:,:,:,c] -= np.amin(a[:,:,:,c])
                         a[:,:,:,c] /= np.amax(a[:,:,:,c])
-                        if normalize:
+                        if bm.normalize:
                             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]
@@ -632,6 +656,9 @@ class Metrics(Callback):
             n_batches = int(np.floor(len_IDs / self.batch_size))
             np.random.shuffle(self.list_IDs)
 
+            # initialize validation loss
+            val_loss = 0
+
             for batch in range(n_batches):
                 # Generate indexes of the batch
                 list_IDs_batch = self.list_IDs[batch*self.batch_size:(batch+1)*self.batch_size]
@@ -667,9 +694,12 @@ class Metrics(Callback):
                     m = rest % self.dim_img[2]
                     result[k:k+self.dim_patch[0],l:l+self.dim_patch[1],m:m+self.dim_patch[2]] += y_predict[i]
 
-            # calculate categorical crossentropy
-            if not self.train:
-                crossentropy = categorical_crossentropy(self.label, softmax(result))
+                    # calculate validation loss
+                    if not self.train:
+                        val_loss += categorical_crossentropy(self.label[k:k+self.dim_patch[0],l:l+self.dim_patch[1],m:m+self.dim_patch[2]], y_predict[i])
+
+            # mean validation loss
+            val_loss /= (n_batches*self.batch_size)
 
             # get result
             result = np.argmax(result, axis=-1)
@@ -703,10 +733,10 @@ class Metrics(Callback):
                     self.history['dice'].append(round(logs['dice'],4))
                 self.history['val_accuracy'].append(round(accuracy,4))
                 self.history['val_dice'].append(round(dice,4))
-                self.history['val_loss'].append(round(crossentropy,4))
+                self.history['val_loss'].append(round(val_loss,4))
 
                 # tensorflow monitoring variables
-                logs['val_loss'] = crossentropy
+                logs['val_loss'] = val_loss
                 logs['val_accuracy'] = accuracy
                 logs['val_dice'] = dice
                 logs['best_acc'] = max(self.history['accuracy'])
@@ -716,7 +746,7 @@ class Metrics(Callback):
                 logs['best_val_dice'] = max(self.history['val_dice'])
 
                 # plot history in figure and save as numpy array
-                save_history(self.history, self.path_to_model, True, self.train_dice)
+                save_history(self.history, self.path_to_model)
 
                 # print accuracies
                 print('\nValidation history:')
@@ -772,17 +802,11 @@ def dice_coef_loss(nb_labels):
         return loss
     return loss_fn
 
-def train_semantic_segmentation(bm,
-    img_list, label_list,
-    val_img_list, val_label_list,
-    img=None, label=None,
-    img_val=None, label_val=None,
-    header=None, extension='.tif'):
+def train_segmentation(bm):
 
     # training data
-    img, label, allLabels, normalization_parameters, header, extension, bm.channels = load_training_data(bm, bm.normalize,
-                    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)
+    bm.img_data, bm.label_data, allLabels, normalization_parameters, bm.header, bm.extension, bm.channels = load_training_data(bm,
+        bm.path_to_images, bm.path_to_labels, None, bm.img_data, bm.label_data, None, None, bm.header, bm.extension)
 
     # configuration data
     configuration_data = np.array([bm.channels,
@@ -790,21 +814,20 @@ def train_semantic_segmentation(bm,
         normalization_parameters[0,0], normalization_parameters[1,0]])
 
     # img shape
-    zsh, ysh, xsh, _ = img.shape
+    zsh, ysh, xsh, _ = bm.img_data.shape
 
     # validation data
-    if any(val_img_list) or img_val is not None:
-        img_val, label_val, _, _, _, _, _ = load_training_data(bm, bm.normalize,
-                    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)
+    if any(bm.val_images) or bm.val_img_data is not None:
+        bm.val_img_data, bm.val_label_data, _, _, _, _, _ = load_training_data(bm,
+            bm.val_images, bm.val_labels, bm.channels, bm.val_img_data, bm.val_label_data, normalization_parameters, allLabels)
 
     elif bm.validation_split:
         split = round(zsh * bm.validation_split)
-        img_val = np.copy(img[split:], order='C')
-        label_val = np.copy(label[split:], order='C')
-        img = np.copy(img[:split], order='C')
-        label = np.copy(label[:split], order='C')
-        zsh, ysh, xsh, _ = img.shape
+        bm.val_img_data = bm.img_data[split:].copy()
+        bm.val_label_data = bm.label_data[split:].copy()
+        bm.img_data = bm.img_data[:split].copy()
+        bm.label_data = bm.label_data[:split].copy()
+        zsh, ysh, xsh, _ = bm.img_data.shape
 
     # list of IDs
     list_IDs_fg, list_IDs_bg = [], []
@@ -814,7 +837,7 @@ def train_semantic_segmentation(bm,
         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(label[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]):
+                    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)
@@ -823,17 +846,17 @@ def train_semantic_segmentation(bm,
             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 = label[k+bm.z_patch//2,l+bm.y_patch//2,m+bm.x_patch//2]
-                        patch = label[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+                        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)
                     else:
                         list_IDs_fg.append(k*ysh*xsh+l*xsh+m)
 
-    if img_val is not None:
+    if bm.val_img_data is not None:
 
         # img_val shape
-        zsh_val, ysh_val, xsh_val, _ = img_val.shape
+        zsh_val, ysh_val, xsh_val, _ = bm.val_img_data.shape
 
         # list of validation IDs
         list_IDs_val_fg, list_IDs_val_bg = [], []
@@ -843,7 +866,7 @@ def train_semantic_segmentation(bm,
             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(label_val[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]):
+                        if np.any(bm.val_label_data[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]):
                             list_IDs_val_fg.append(k*ysh_val*xsh_val+l*xsh_val+m)
                         else:
                             list_IDs_val_bg.append(k*ysh_val*xsh_val+l*xsh_val+m)
@@ -852,8 +875,8 @@ def train_semantic_segmentation(bm,
                 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 = label_val[k+bm.z_patch//2,l+bm.y_patch//2,m+bm.x_patch//2]
-                            patch = label_val[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+                            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:
@@ -877,18 +900,18 @@ def train_semantic_segmentation(bm,
 
     # data generator
     validation_generator = None
-    training_generator = DataGenerator(img, label, list_IDs_fg, list_IDs_bg, True, True, False, **params)
-    if img_val is not None:
+    training_generator = DataGenerator(bm.img_data, bm.label_data, list_IDs_fg, list_IDs_bg, True, True, False, **params)
+    if bm.val_img_data is not None:
         if bm.val_dice:
-            val_metrics = Metrics(bm, img_val, label_val, list_IDs_val_fg, (zsh_val, ysh_val, xsh_val), nb_labels, False)
+            val_metrics = Metrics(bm, bm.val_img_data, bm.val_label_data, list_IDs_val_fg, (zsh_val, ysh_val, xsh_val), nb_labels, False)
         else:
             params['dim_img'] = (zsh_val, ysh_val, xsh_val)
             params['augment'] = (False, False, False, False, 0)
-            validation_generator = DataGenerator(img_val, label_val, list_IDs_val_fg, list_IDs_val_bg, True, False, False, **params)
+            validation_generator = DataGenerator(bm.val_img_data, bm.val_label_data, list_IDs_val_fg, list_IDs_val_bg, True, False, False, **params)
 
     # monitor dice score on training data
     if bm.train_dice:
-        train_metrics = Metrics(bm, img, label, list_IDs_fg, (zsh, ysh, xsh), nb_labels, True)
+        train_metrics = Metrics(bm, bm.img_data, bm.label_data, list_IDs_fg, (zsh, ysh, xsh), nb_labels, True)
 
     # create a MirroredStrategy
     cdo = tf.distribute.ReductionToOneDevice()
@@ -931,11 +954,11 @@ 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,
+        bm.extension, bm.header, bm.crop_data, bm.cropping_weights, bm.cropping_config,
         normalization_parameters, bm.cropping_norm, bm.patch_normalization, bm.scaling)
 
     # model checkpoint
-    if img_val is not None:
+    if bm.val_img_data is not None:
         if bm.val_dice:
             callbacks = [val_metrics, meta_data]
         else:
@@ -967,8 +990,8 @@ def train_semantic_segmentation(bm,
               workers=bm.workers)
 
     # save monitoring figure on train end
-    if img_val is not None and not bm.val_dice:
-        save_history(history.history, bm.path_to_model, False, bm.train_dice)
+    if bm.val_img_data is None or not bm.val_dice:
+        save_history(history.history, bm.path_to_model)
 
 def load_prediction_data(bm, channels, normalize, normalization_parameters,
     region_of_interest, img, img_header, load_blockwise=False, z=None):
@@ -982,6 +1005,8 @@ def load_prediction_data(bm, channels, normalize, normalization_parameters,
             if img.shape[0] < bm.z_patch:
                 rest = bm.z_patch - img.shape[0]
                 tmp = imread(bm.path_to_image, key=range(len(tif.pages)-rest,len(tif.pages)))
+                if len(tmp.shape)==2:
+                    tmp = tmp.reshape(1,tmp.shape[0],tmp.shape[1])
                 img = np.append(img, tmp[::-1], axis=0)
         else:
             img, img_header = load_data(bm.path_to_image, 'first_queue')
@@ -1072,10 +1097,7 @@ def gradient(volData):
     grad[grad>0]=1
     return grad
 
-def predict_semantic_segmentation(bm,
-    header, img_header,
-    region_of_interest, extension, img_data,
-    channels, normalization_parameters):
+def predict_segmentation(bm, region_of_interest, channels, normalization_parameters):
 
     # initialize results
     results = {}
@@ -1161,8 +1183,8 @@ def predict_semantic_segmentation(bm,
     if not load_blockwise:
 
         # 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)
+        img, bm.img_header, z_shape, y_shape, x_shape, region_of_interest, bm.img_data = load_prediction_data(
+            bm, channels, bm.normalize, normalization_parameters, region_of_interest, bm.img_data, bm.img_header)
 
         # append ghost areas
         img, z_rest, y_rest, x_rest = append_ghost_areas(bm, img)
@@ -1229,11 +1251,11 @@ def predict_semantic_segmentation(bm,
         z_indices = range(0, zsh-bm.z_patch+1, bm.stride_size)
         for j, z in enumerate(z_indices):
 
-            # load blockwise
+            # load blockwise from TIFF
             if load_blockwise:
                 img, _, _, _, _, _, _ = load_prediction_data(bm,
                     channels, bm.normalize, normalization_parameters,
-                    region_of_interest, img_data, img_header, load_blockwise, z)
+                    region_of_interest, bm.img_data, bm.img_header, load_blockwise, z)
                 img, _, _, _ = append_ghost_areas(bm, img)
 
             # list of IDs
@@ -1373,79 +1395,79 @@ def predict_semantic_segmentation(bm,
 
     # load header from file
     if bm.header_file and os.path.exists(bm.header_file):
-        _, header = load_data(bm.header_file)
+        _, bm.header = load_data(bm.header_file)
         # update file extension
-        if header is not None and bm.path_to_image:
-            extension = os.path.splitext(bm.header_file)[1]
-            if extension == '.gz':
-                extension = '.nii.gz'
-            bm.path_to_final = os.path.splitext(bm.path_to_final)[0] + 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 header is not None:
-        if extension == '.am':
-            header = set_image_dimensions(header[0], label)
-            if img_header is not None:
+    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:
-                    header = set_physical_size(header, img_header[0])
+                    bm.header = set_physical_size(bm.header, bm.img_header[0])
                 except:
                     pass
-            header = [header]
+            bm.header = [bm.header]
         else:
             # build new header
-            if img_header is None:
+            if bm.img_header is None:
                 zsh, ysh, xsh = label.shape
-                img_header = sitk.Image(xsh, ysh, zsh, header.GetPixelID())
+                bm.img_header = sitk.Image(xsh, ysh, zsh, bm.header.GetPixelID())
             # copy metadata
-            for key in header.GetMetaDataKeys():
+            for key in bm.header.GetMetaDataKeys():
                 if not (re.match(r'Segment\d+_Extent$', key) or key=='Segmentation_ConversionParameters'):
-                    img_header.SetMetaData(key, header.GetMetaData(key))
-            header = img_header
-    results['header'] = header
+                    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=header, compress=bm.compression)
+        save_data(bm.path_to_final, label, header=bm.header, compress=bm.compression)
 
         # paths to optional results
-        filename, extension = os.path.splitext(bm.path_to_final)
-        if extension == '.gz':
-            extension = '.nii.gz'
+        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' + extension
-        path_to_filled = filename + '.filled' + extension
-        path_to_cleaned_filled = filename + '.cleaned.filled' + extension
-        path_to_refined = filename + '.refined' + extension
-        path_to_acwe = filename + '.acwe' + extension
+        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=header, compress=bm.compression)
+            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=header, compress=bm.compression)
+            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=header, compress=bm.compression)
+            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(img_data, label, bm.acwe_alpha, bm.acwe_smooth, bm.acwe_steps)
-        refined_result = activeContour(img_data, label, simple=True)
+        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=header, compress=bm.compression)
-            save_data(path_to_refined, refined_result, header=header, compress=bm.compression)
+            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
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biomedisa
-Version: 24.8.3
+Version: 24.8.5
 Summary: Segmentation of 3D volumetric image data
 Author: Philipp Lösel
 Author-email: philipp.loesel@anu.edu.au