biomedisa 24.5.23__py3-none-any.whl → 24.8.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'))
+        bm.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,
+                    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')
@@ -483,9 +479,18 @@ if __name__ == '__main__':
                         help='Processing queue when using a remote server')
     parser.add_argument('-hf','--header_file', type=str, metavar='PATH', default=None,
                         help='Location of header file')
+    parser.add_argument('-ext','--extension', type=str, default='.tif',
+                        help='Save data for example as NRRD file using --extension=".nrrd"')
     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:
@@ -415,25 +416,33 @@ def pre_processing(bm):
     if bm.labelData is None:
         return _error_(bm, 'Invalid label data.')
 
+    # dimension errors
     if len(bm.labelData.shape) != 3:
-        return _error_(bm, 'Label must be three-dimensional.')
-
+        return _error_(bm, 'Label data must be three-dimensional.')
     if bm.data.shape != bm.labelData.shape:
-        return _error_(bm, 'Image and label must have the same x,y,z-dimensions.')
+        return _error_(bm, 'Image and label data must have the same x,y,z-dimensions.')
+
+    # label data type
+    if bm.labelData.dtype in ['float16','float32','float64']:
+        if bm.django_env:
+            return _error_(bm, 'Label data must be of integer type.')
+        print(f'Warning: Potential label loss during conversion from {bm.labelData.dtype} to int32.')
+        bm.labelData = bm.labelData.astype(np.int32)
 
     # get labels
     bm.allLabels = np.unique(bm.labelData)
     index = np.argwhere(bm.allLabels<0)
     bm.allLabels = np.delete(bm.allLabels, index)
 
-    if bm.django_env and np.any(bm.allLabels > 255):
-        return _error_(bm, 'No labels higher than 255 allowed.')
-
+    # labels greater than 255
     if np.any(bm.allLabels > 255):
-        bm.labelData[bm.labelData > 255] = 0
-        index = np.argwhere(bm.allLabels > 255)
-        bm.allLabels = np.delete(bm.allLabels, index)
-        print('Warning: Only labels <=255 are allowed. Labels higher than 255 will be removed.')
+        if bm.django_env:
+            return _error_(bm, 'No labels greater than 255 allowed.')
+        else:
+            bm.labelData[bm.labelData > 255] = 0
+            index = np.argwhere(bm.allLabels > 255)
+            bm.allLabels = np.delete(bm.allLabels, index)
+            print('Warning: Only labels <=255 are allowed. Labels greater than 255 will be removed.')
 
     # add background label if not existing
     if not np.any(bm.allLabels==0):
@@ -485,7 +494,8 @@ def save_data(path_to_final, final, header=None, final_image_type=None, compress
         np_to_nc(path_to_final, final, header)
     elif final_image_type in ['.hdr', '.mhd', '.mha', '.nrrd', '.nii', '.nii.gz']:
         simg = sitk.GetImageFromArray(final)
-        simg.CopyInformation(header)
+        if header is not None:
+            simg.CopyInformation(header)
         sitk.WriteImage(simg, path_to_final, useCompression=compress)
     elif final_image_type in ['.zip', 'directory', '']:
         with tempfile.TemporaryDirectory() as temp_dir:

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/crop_helper.py

@@ -542,7 +542,8 @@ 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, 0, 1])
+    cropping_config = np.array([channels, x_scale, y_scale, z_scale, normalize,
+        normalization_parameters[0,0], normalization_parameters[1,0]])
 
     return cropping_weights, cropping_config, normalization_parameters