biomedisa 24.8.6__tar.gz → 24.8.8__tar.gz

{biomedisa-24.8.6 → biomedisa-24.8.8}/PKG-INFO

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

{biomedisa-24.8.6 → biomedisa-24.8.8}/README.md

@@ -3,6 +3,7 @@
 - [Overview](#overview)
 - [Hardware Requirements](#hardware-requirements)
 - [Installation (command-line based)](#installation-command-line-based)
+- [Installation (3D Slicer extension)](#installation-3d-slicer-extension)
 - [Installation (browser based)](#installation-browser-based)
 - [Download Data](#download-data)
 - [Revisions](#revisions)
@@ -17,14 +18,15 @@
 - [License](#license)
 
 ## Overview
-Biomedisa (https://biomedisa.info) is a free and easy-to-use open-source application for segmenting large 3D volumetric images such as CT and MRI scans, developed at [The Australian National University CTLab](https://ctlab.anu.edu.au/). Biomedisa's smart interpolation of sparsely pre-segmented slices enables accurate semi-automated segmentation by considering the complete underlying image data. Additionally, Biomedisa enables deep learning for fully automated segmentation across similar samples and structures. It is compatible with segmentation tools like Amira/Avizo, ImageJ/Fiji and 3D Slicer. If you are using Biomedisa or the data for your research please cite: Lösel, P.D. et al. [Introducing Biomedisa as an open-source online platform for biomedical image segmentation.](https://www.nature.com/articles/s41467-020-19303-w) *Nat. Commun.* **11**, 5577 (2020).
+Biomedisa (https://biomedisa.info) is a free and easy-to-use open-source application for segmenting large 3D volumetric images such as CT and MRI scans, developed at [The Australian National University CTLab](https://ctlab.anu.edu.au/). Biomedisa's smart interpolation of sparsely pre-segmented slices enables accurate semi-automated segmentation by considering the complete underlying image data. Additionally, Biomedisa enables deep learning for fully automated segmentation across similar samples and structures. It is compatible with segmentation tools like Amira/Avizo, ImageJ/Fiji, and 3D Slicer. If you are using Biomedisa or the data for your research please cite: Lösel, P.D. et al. [Introducing Biomedisa as an open-source online platform for biomedical image segmentation.](https://www.nature.com/articles/s41467-020-19303-w) *Nat. Commun.* **11**, 5577 (2020).
 
 ## Hardware Requirements
-+ One or more NVIDIA GPUs with compute capability 3.0 or higher.
++ One or more NVIDIA GPUs.
 
 ## Installation (command-line based)
-+ [Ubuntu 22.04 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_interpolation_cli.md)
-+ [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_cli.md)
++ [Ubuntu 22/24 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu_interpolation_cli.md)
++ [Ubuntu 22/24 + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu_deeplearning_cli.md)
++ [Ubuntu 22/24 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu_cli.md)
 + [Windows 10/11 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_cli.md)
 + [Windows (WSL) + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows_wsl.md)
 
@@ -149,7 +151,7 @@ save_data('final.Head5.am', results['regular'], results['header'])
 
 #### Command-line based (prediction)
 ```
-python -m biomedisa.deeplearning C:\Users\%USERNAME%\Downloads\testing_axial_crop_pat13.nii.gz C:\Users\%USERNAME%\Downloads\heart.h5 -p
+python -m biomedisa.deeplearning C:\Users\%USERNAME%\Downloads\testing_axial_crop_pat13.nii.gz C:\Users\%USERNAME%\Downloads\heart.h5
 ```
 
 ## Mesh Generator

{biomedisa-24.8.6 → biomedisa-24.8.8}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "biomedisa"
-version = "24.8.6"
+version = "24.8.8"
 authors = [
   { name="Philipp Lösel"}, {email="philipp.loesel@anu.edu.au" },
 ]
 description = "Segmentation of 3D volumetric image data"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: European Union Public Licence 1.2 (EUPL 1.2)",

{biomedisa-24.8.6 → biomedisa-24.8.8}/src/biomedisa/deeplearning.py

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

{biomedisa-24.8.6 → biomedisa-24.8.8}/src/biomedisa/features/keras_helper.py

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

{biomedisa-24.8.6 → biomedisa-24.8.8}/src/biomedisa.egg-info/PKG-INFO

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