biomedisa 24.7.1__tar.gz → 24.8.2__tar.gz

{biomedisa-24.7.1 → biomedisa-24.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biomedisa
-Version: 24.7.1
+Version: 24.8.2
 Summary: Segmentation of 3D volumetric image data
 Author: Philipp Lösel
 Author-email: philipp.loesel@anu.edu.au
@@ -36,17 +36,17 @@ License-File: LICENSE
 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
++ One or more NVIDIA GPUs with compute capability 3.0 or higher.
 
 ## 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 (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)
++ [Ubuntu 22.04 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_interpolation_cli.md)
++ [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_cli.md)
++ [Windows 10 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_cli.md)
++ [Windows (WSL) + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows_wsl.md)
 
 ## Installation (3D Slicer extension)
-+ [Ubuntu 22.04 + CUDA + GPU](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_slicer.md)
++ [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_slicer.md)
++ [Windows 10 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_slicer.md)
 
 ## Installation (browser based)
 + [Ubuntu 22.04](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8.md)
@@ -58,6 +58,7 @@ Biomedisa (https://biomedisa.info) is a free and easy-to-use open-source applica
 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

{biomedisa-24.7.1 → biomedisa-24.8.2}/README.md

@@ -20,17 +20,17 @@
 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
++ One or more NVIDIA GPUs with compute capability 3.0 or higher.
 
 ## 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 (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)
++ [Ubuntu 22.04 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_interpolation_cli.md)
++ [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_cli.md)
++ [Windows 10 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_cli.md)
++ [Windows (WSL) + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows_wsl.md)
 
 ## Installation (3D Slicer extension)
-+ [Ubuntu 22.04 + CUDA + GPU](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_slicer.md)
++ [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_slicer.md)
++ [Windows 10 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_slicer.md)
 
 ## Installation (browser based)
 + [Ubuntu 22.04](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8.md)
@@ -42,6 +42,7 @@ Biomedisa (https://biomedisa.info) is a free and easy-to-use open-source applica
 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

{biomedisa-24.7.1 → biomedisa-24.8.2}/pyproject.toml

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

{biomedisa-24.7.1 → biomedisa-24.8.2}/src/biomedisa/deeplearning.py

@@ -76,7 +76,8 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
     path=None, success=True, return_probs=False, patch_normalization=False,
     z_patch=64, y_patch=64, x_patch=64, path_to_logfile=None, img_id=None, label_id=None,
     remote=False, queue=0, username=None, shortfilename=None, dice_loss=False,
-    acwe=False, acwe_alpha=1.0, acwe_smooth=1, acwe_steps=3, clean=None, fill=None):
+    acwe=False, acwe_alpha=1.0, acwe_smooth=1, acwe_steps=3, clean=None, fill=None,
+    separation=False, mask=None, refinement=False):
 
     # create biomedisa
     bm = Biomedisa()
@@ -220,7 +221,7 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
             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:
@@ -293,7 +294,7 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
 
                 # make prediction
                 results, bm = predict_semantic_segmentation(bm,
-                    header, img_header, allLabels,
+                    header, img_header,
                     region_of_interest, extension, img_data,
                     channels, normalization_parameters)
 
@@ -479,6 +480,14 @@ 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('-s','--separation', action='store_true', default=False,
+                        help='Instance segmentation of objects such as cells or rock particles')
+    parser.add_argument('-m','--mask', type=str, metavar='PATH', default=None,
+                        help='Location of mask')
+    parser.add_argument('-rf','--refinement', action='store_true', default=False,
+                        help='Refine segmentation on full size data')
+    parser.add_argument('-ext','--extension', type=str, default='.tif',
+                        help='Save data for example as NRRD file using --extension=".nrrd"')
     bm = parser.parse_args()
     bm.success = True
 

{biomedisa-24.7.1 → biomedisa-24.8.2}/src/biomedisa/features/DataGenerator.py

@@ -107,7 +107,7 @@ def random_rotation_3d(image, max_angle=180):
 class DataGenerator(tf.keras.utils.Sequence):
     'Generates data for Keras'
     def __init__(self, img, label, list_IDs_fg, list_IDs_bg, shuffle, train, classification, batch_size=32, dim=(32,32,32),
-                 dim_img=(32,32,32), n_classes=10, n_channels=1, augment=(False,False,False,False,0), patch_normalization=False):
+                 dim_img=(32,32,32), n_classes=10, n_channels=1, augment=(False,False,False,False,0), patch_normalization=False, separation=False):
         'Initialization'
         self.dim = dim
         self.dim_img = dim_img
@@ -124,6 +124,7 @@ class DataGenerator(tf.keras.utils.Sequence):
         self.classification = classification
         self.on_epoch_end()
         self.patch_normalization = patch_normalization
+        self.separation = separation
 
     def __len__(self):
         'Denotes the number of batches per epoch'
@@ -247,6 +248,13 @@ class DataGenerator(tf.keras.utils.Sequence):
                 tmp_X = self.img[k:k+self.dim[0],l:l+self.dim[1],m:m+self.dim[2]]
                 tmp_y = self.label[k:k+self.dim[0],l:l+self.dim[1],m:m+self.dim[2]]
 
+                # center label gets value 1
+                if self.separation:
+                    centerLabel = tmp_y[self.dim[0]//2,self.dim[1]//2,self.dim[2]//2]
+                    tmp_y = tmp_y.copy()
+                    tmp_y[tmp_y!=centerLabel]=0
+                    tmp_y[tmp_y==centerLabel]=1
+
                 # augmentation
                 if self.train:
 

{biomedisa-24.7.1 → biomedisa-24.8.2}/src/biomedisa/features/biomedisa_helper.py

@@ -416,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):
@@ -486,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-24.7.1 → biomedisa-24.8.2}/src/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
 

{biomedisa-24.7.1 → biomedisa-24.8.2}/src/biomedisa/features/keras_helper.py

@@ -355,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, scaling,
+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,
         normalization_parameters=None, allLabels=None, header=None, extension='.tif',
         x_puffer=25, y_puffer=25, z_puffer=25):
@@ -382,8 +382,9 @@ def load_training_data(normalize, img_list, label_list, channels, x_scale, y_sca
                 label_names = ['label_1']
             label_dim = label.shape
             label = set_labels_to_zero(label, labels_to_compute, labels_to_remove)
-            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 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')
@@ -465,8 +466,9 @@ def load_training_data(normalize, img_list, label_list, channels, x_scale, y_sca
                         a = label_in[k]
                     label_dim = a.shape
                     a = set_labels_to_zero(a, labels_to_compute, labels_to_remove)
-                    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 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:
                         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')
@@ -509,13 +511,16 @@ def load_training_data(normalize, img_list, label_list, channels, x_scale, y_sca
     img[img<0] = 0
     img[img>1] = 1
 
-    # get labels
-    if allLabels is None:
-        allLabels = np.unique(label)
+    if bm.separation:
+        allLabels = np.array([0,1])
+    else:
+        # get labels
+        if allLabels is None:
+            allLabels = np.unique(label)
 
-    # labels must be in ascending order
-    for k, l in enumerate(allLabels):
-        label[label==l] = k
+        # labels must be in ascending order
+        for k, l in enumerate(allLabels):
+            label[label==l] = k
 
     return img, label, allLabels, normalization_parameters, header, extension, channels
 
@@ -775,19 +780,21 @@ def train_semantic_segmentation(bm,
     header=None, extension='.tif'):
 
     # training data
-    img, label, allLabels, normalization_parameters, header, extension, bm.channels = load_training_data(bm.normalize,
+    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)
 
     # configuration data
-    configuration_data = np.array([bm.channels, bm.x_scale, bm.y_scale, bm.z_scale, bm.normalize, 0, 1])
+    configuration_data = np.array([bm.channels,
+        bm.x_scale, bm.y_scale, bm.z_scale, bm.normalize,
+        normalization_parameters[0,0], normalization_parameters[1,0]])
 
     # img shape
     zsh, ysh, xsh, _ = img.shape
 
     # validation data
     if any(val_img_list) or img_val is not None:
-        img_val, label_val, _, _, _, _, _ = load_training_data(bm.normalize,
+        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)
 
@@ -815,7 +822,13 @@ 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):
-                    list_IDs_fg.append(k*ysh*xsh+l*xsh+m)
+                    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]
+                        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:
 
@@ -838,7 +851,13 @@ 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):
-                        list_IDs_val_fg.append(k*ysh_val*xsh_val+l*xsh_val+m)
+                        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]
+                            if centerLabel>0 and np.any(patch!=centerLabel):
+                                list_IDs_val_fg.append(k*ysh_val*xsh_val+l*xsh_val+m)
+                        else:
+                            list_IDs_val_fg.append(k*ysh_val*xsh_val+l*xsh_val+m)
 
     # number of labels
     nb_labels = len(allLabels)
@@ -853,7 +872,8 @@ def train_semantic_segmentation(bm,
               'n_classes': nb_labels,
               'n_channels': bm.channels,
               'augment': (bm.flip_x, bm.flip_y, bm.flip_z, bm.swapaxes, bm.rotate),
-              'patch_normalization': bm.patch_normalization}
+              'patch_normalization': bm.patch_normalization,
+              'separation': bm.separation}
 
     # data generator
     validation_generator = None
@@ -959,6 +979,10 @@ def load_prediction_data(bm, channels, normalize, normalization_parameters,
             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)))
+            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)))
+                img = np.append(img, tmp[::-1], axis=0)
         else:
             img, img_header = load_data(bm.path_to_image, 'first_queue')
 
@@ -1031,8 +1055,25 @@ def append_ghost_areas(bm, img):
         img = np.append(img, img[:,:,-x_rest:][:,:,::-1], axis=2)
     return img, z_rest, y_rest, x_rest
 
+def gradient(volData):
+    grad = np.zeros(volData.shape, dtype=np.uint8)
+    tmp = np.abs(volData[:-1] - volData[1:])
+    tmp[tmp>0]=1
+    grad[:-1] += tmp
+    grad[1:] += tmp
+    tmp = np.abs(volData[:,:-1] - volData[:,1:])
+    tmp[tmp>0]=1
+    grad[:,:-1] += tmp
+    grad[:,1:] += tmp
+    tmp = np.abs(volData[:,:,:-1] - volData[:,:,1:])
+    tmp[tmp>0]=1
+    grad[:,:,:-1] += tmp
+    grad[:,:,1:] += tmp
+    grad[grad>0]=1
+    return grad
+
 def predict_semantic_segmentation(bm,
-    header, img_header, allLabels,
+    header, img_header,
     region_of_interest, extension, img_data,
     channels, normalization_parameters):
 
@@ -1040,7 +1081,8 @@ def predict_semantic_segmentation(bm,
     results = {}
 
     # number of labels
-    nb_labels = len(allLabels)
+    nb_labels = len(bm.allLabels)
+    results['allLabels'] = bm.allLabels
 
     # load model
     if bm.dice_loss:
@@ -1065,6 +1107,13 @@ def predict_semantic_segmentation(bm,
         zsh = len(tif.pages)
         ysh, xsh = tif.pages[0].shape
 
+        # load mask
+        if bm.separation or bm.refinement:
+            mask, _ = load_data(bm.mask)
+            mask = mask.reshape(zsh, ysh, xsh, 1)
+            mask, _, _, _ = append_ghost_areas(bm, mask)
+            mask = mask.reshape(mask.shape[:-1])
+
         # 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:
@@ -1087,9 +1136,20 @@ def predict_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):
-                    list_IDs.append(k*ysh*xsh+l*xsh+m)
+                    if bm.separation:
+                        centerLabel = mask[k+bm.z_patch//2,l+bm.y_patch//2,m+bm.x_patch//2]
+                        patch = mask[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.append(k*ysh*xsh+l*xsh+m)
+                    elif bm.refinement:
+                        patch = mask[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+                        if np.any(patch==0) and np.any(patch!=0):
+                            list_IDs.append(k*ysh*xsh+l*xsh+m)
+                    else:
+                        list_IDs.append(k*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]
 
@@ -1177,27 +1237,37 @@ def predict_semantic_segmentation(bm,
                 img, _, _, _ = append_ghost_areas(bm, img)
 
             # list of IDs
-            list_IDs = []
+            list_IDs_block = []
 
             # 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)
+                    if bm.separation:
+                        centerLabel = mask[z+bm.z_patch//2,l+bm.y_patch//2,m+bm.x_patch//2]
+                        patch = mask[z:z+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+                        if centerLabel>0 and np.any(patch!=centerLabel):
+                            list_IDs_block.append(z*ysh*xsh+l*xsh+m)
+                    elif bm.refinement:
+                        patch = mask[z:z+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+                        if np.any(patch==0) and np.any(patch!=0):
+                            list_IDs_block.append(z*ysh*xsh+l*xsh+m)
+                    else:
+                        list_IDs_block.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]
+            max_i_block = len(list_IDs_block)
+            rest = bm.batch_size - (len(list_IDs_block) % bm.batch_size)
+            list_IDs_block = list_IDs_block + list_IDs_block[:rest]
 
             # number of patches
-            nb_patches = len(list_IDs)
+            nb_patches = len(list_IDs_block)
 
             # 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]):
+                for i, ID in enumerate(list_IDs_block[step*bm.batch_size:(step+1)*bm.batch_size]):
 
                     # get patch indices
                     k=0 if load_blockwise else ID // (ysh*xsh)
@@ -1218,29 +1288,46 @@ def predict_semantic_segmentation(bm,
                 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]):
+                for i, ID in enumerate(list_IDs_block[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:
-                    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]
+                    if step*bm.batch_size+i < max_i_block:
+                        if bm.separation:
+                            patch = np.argmax(Y[i], axis=-1).astype(np.uint8)
+                            label[z:z+bm.z_patch,l:l+bm.y_patch,m:m+bm.x_patch] += gradient(patch)
+                        else:
+                            probs[:,l:l+bm.y_patch,m:m+bm.x_patch] += Y[i]
+
+            if not bm.separation:
+                # overlap in z direction
+                if bm.stride_size < bm.z_patch:
+                    if j>0:
+                        probs[:bm.stride_size] += overlap
+                    overlap = probs[bm.stride_size:].copy()
+
+                # calculate result
+                if z==z_indices[-1]:
+                    label[z:z+bm.z_patch] = np.argmax(probs, axis=-1).astype(np.uint8)
+                    if bm.return_probs:
+                        final[z:z+bm.z_patch] = probs
+                else:
+                    block_zsh = min(bm.stride_size, bm.z_patch)
+                    label[z:z+block_zsh] = np.argmax(probs[:block_zsh], axis=-1).astype(np.uint8)
+                    if bm.return_probs:
+                        final[z:z+block_zsh] = probs[:block_zsh]
+
+    # refine mask data with result
+    if bm.refinement:
+        # loop over boundary patches
+        for i, ID in enumerate(list_IDs):
+            if i < max_i:
+                k = ID // (ysh*xsh)
+                rest = ID % (ysh*xsh)
+                l = rest // xsh
+                m = rest % xsh
+                mask[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch] = label[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+        label = mask
 
     # remove appendix
     if bm.return_probs:
@@ -1280,7 +1367,8 @@ def predict_semantic_segmentation(bm,
         label = np.copy(tmp, order='C')
 
     # get result
-    label = get_labels(label, allLabels)
+    if not bm.separation:
+        label = get_labels(label, bm.allLabels)
     results['regular'] = label
 
     # load header from file

{biomedisa-24.7.1 → biomedisa-24.8.2}/src/biomedisa/interpolation.py

@@ -154,6 +154,7 @@ def smart_interpolation(data, labelData, nbrw=10, sorw=4000, acwe=False, acwe_al
                 bm.data /= np.amax(bm.data)
                 bm.data *= 255.0
             if bm.labelData.dtype in ['uint32','int64','uint64']:
+                print(f'Warning: Potential label loss during conversion from {bm.labelData.dtype} to int32.')
                 bm.labelData = bm.labelData.astype(np.int32)
 
             # denoise image data

{biomedisa-24.7.1 → biomedisa-24.8.2}/src/biomedisa.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biomedisa
-Version: 24.7.1
+Version: 24.8.2
 Summary: Segmentation of 3D volumetric image data
 Author: Philipp Lösel
 Author-email: philipp.loesel@anu.edu.au
@@ -36,17 +36,17 @@ License-File: LICENSE
 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
++ One or more NVIDIA GPUs with compute capability 3.0 or higher.
 
 ## 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 (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)
++ [Ubuntu 22.04 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_interpolation_cli.md)
++ [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_cli.md)
++ [Windows 10 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_cli.md)
++ [Windows (WSL) + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows_wsl.md)
 
 ## Installation (3D Slicer extension)
-+ [Ubuntu 22.04 + CUDA + GPU](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_slicer.md)
++ [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_slicer.md)
++ [Windows 10 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_slicer.md)
 
 ## Installation (browser based)
 + [Ubuntu 22.04](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8.md)
@@ -58,6 +58,7 @@ Biomedisa (https://biomedisa.info) is a free and easy-to-use open-source applica
 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