biomedisa 24.8.11__tar.gz → 25.7.1__tar.gz

{biomedisa-24.8.11 → biomedisa-25.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: biomedisa
-Version: 24.8.11
+Version: 25.7.1
 Summary: Segmentation of 3D volumetric image data
 Author: Philipp Lösel
 Author-email: philipp.loesel@anu.edu.au
@@ -13,6 +13,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: license-file
 
 [![biomedisa](https://raw.githubusercontent.com/biomedisa/biomedisa/master/biomedisa_app/static/biomedisa_logo.svg)](https://biomedisa.info)
 -----------
@@ -36,13 +37,14 @@ 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
++ One or more NVIDIA, AMD, or Intel GPUs
 
 ## Installation (command-line based)
 + [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/windows_wsl.md)
++ [Windows (WSL) + Smart Interpolation + Deep Learning ("advanced")](https://github.com/biomedisa/biomedisa/blob/master/README/windows_wsl.md)
++ [Windows 10/11 + Smart Interpolation (NVIDIA, AMD, Intel) ("simple")](https://github.com/biomedisa/biomedisa/blob/master/README/windows_interpolation.md)
 
 ## Installation (3D Slicer extension)
 + [Ubuntu 22/24](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu_slicer.md)

{biomedisa-24.8.11 → biomedisa-25.7.1}/README.md

@@ -20,13 +20,14 @@
 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
++ One or more NVIDIA, AMD, or Intel GPUs
 
 ## Installation (command-line based)
 + [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/windows_wsl.md)
++ [Windows (WSL) + Smart Interpolation + Deep Learning ("advanced")](https://github.com/biomedisa/biomedisa/blob/master/README/windows_wsl.md)
++ [Windows 10/11 + Smart Interpolation (NVIDIA, AMD, Intel) ("simple")](https://github.com/biomedisa/biomedisa/blob/master/README/windows_interpolation.md)
 
 ## Installation (3D Slicer extension)
 + [Ubuntu 22/24](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu_slicer.md)

{biomedisa-24.8.11 → biomedisa-25.7.1}/pyproject.toml

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

{biomedisa-24.8.11 → biomedisa-25.7.1}/src/biomedisa/deeplearning.py

@@ -1,7 +1,7 @@
 #!/usr/bin/python3
 ##########################################################################
 ##                                                                      ##
-##  Copyright (c) 2019-2024 Philipp Lösel. All rights reserved.         ##
+##  Copyright (c) 2019-2025 Philipp Lösel. All rights reserved.         ##
 ##                                                                      ##
 ##  This file is part of the open source project biomedisa.             ##
 ##                                                                      ##
@@ -77,7 +77,8 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
     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,
-    separation=False, mask=None, refinement=False):
+    separation=False, mask=None, refinement=False, ignore_mask=False, mixed_precision=False,
+    slicer=False, path_to_data=None):
 
     # create biomedisa
     bm = Biomedisa()
@@ -91,6 +92,7 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
     key_copy = tuple(locals().keys())
     for arg in key_copy:
         bm.__dict__[arg] = locals()[arg]
+    bm.path_to_data = bm.path_to_images
 
     # normalization
     bm.normalize = 1 if bm.normalization else 0
@@ -214,10 +216,16 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
 
     if bm.predict:
 
-        # get meta data
-        hf = h5py.File(bm.path_to_model, 'r')
-        meta = hf.get('meta')
-        configuration = meta.get('configuration')
+        # load model
+        try:
+            hf = h5py.File(bm.path_to_model, 'r')
+            meta = hf.get('meta')
+            configuration = meta.get('configuration')
+            bm.allLabels = np.array(meta.get('labels'))
+        except:
+            raise RuntimeError("Invalid model.")
+
+        # get configuration
         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)
@@ -225,7 +233,6 @@ 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]])
-        bm.allLabels = np.array(meta.get('labels'))
         if 'patch_normalization' in meta:
             bm.patch_normalization = bool(meta['patch_normalization'][()])
         if 'scaling' in meta:
@@ -506,6 +513,12 @@ if __name__ == '__main__':
                         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')
+    parser.add_argument('-im','--ignore_mask', action='store_true', default=False,
+                        help='Use a binary mask in the second channel of the label file to define ignored (0) and considered (1) areas during training')
+    parser.add_argument('-mp','--mixed_precision', action='store_true', default=False,
+                        help='Use mixed precision in model')
+    parser.add_argument('--slicer', action='store_true', default=False,
+                        help='Required for starting Biomedisa from 3D Slicer')
     bm = parser.parse_args()
     bm.success = True
 
@@ -543,6 +556,12 @@ if __name__ == '__main__':
         bm.django_env = False
 
     kwargs = vars(bm)
+    bm.path_to_data = bm.path_to_images
+
+    # verify model
+    if bm.predict and os.path.splitext(bm.path)[1] != '.h5':
+        bm = _error_(bm, "Invalid model.")
+        raise RuntimeError("Invalid model.")
 
     # train or predict segmentation
     try:
@@ -561,5 +580,5 @@ if __name__ == '__main__':
         bm = _error_(bm, 'GPU out of memory. Reduce your batch size')
     except Exception as e:
         print(traceback.format_exc())
-        bm = _error_(bm, e)
+        bm = _error_(bm, str(e))
 

{biomedisa-24.8.11 → biomedisa-25.7.1}/src/biomedisa/features/DataGenerator.py

@@ -1,6 +1,6 @@
 ##########################################################################
 ##                                                                      ##
-##  Copyright (c) 2019-2024 Philipp Lösel. All rights reserved.         ##
+##  Copyright (c) 2019-2025 Philipp Lösel. All rights reserved.         ##
 ##                                                                      ##
 ##  This file is part of the open source project biomedisa.             ##
 ##                                                                      ##
@@ -26,11 +26,11 @@
 ##                                                                      ##
 ##########################################################################
 
+from biomedisa.features.biomedisa_helper import welford_mean_std
 import numpy as np
 import tensorflow as tf
 import numba
 import random
-import scipy
 
 def get_random_rotation_matrix(batch_size):
     angle_xy = np.random.uniform(0, 2. * np.pi, batch_size)
@@ -80,7 +80,6 @@ def rotate_img_patch(src,trg,k,l,m,cos_a,sin_a,z_patch,y_patch,x_patch,imageHeig
                 trg[z-k,y-l,x-m] = val
     return trg
 
-
 @numba.jit(nopython=True)#parallel=True
 def rotate_img_patch_3d(src,trg,k,l,m,rm_xx,rm_xy,rm_xz,rm_yx,rm_yy,rm_yz,rm_zx,rm_zy,rm_zz,z_patch,y_patch,x_patch,imageVertStride,imageDepth,imageHeight,imageWidth):
     #return rotate_label_patch_3d(src,trg,k,l,m,rm_xx,rm_xy,rm_xz,rm_yx,rm_yy,rm_yz,rm_zx,rm_zy,rm_zz,z_patch,y_patch,x_patch,imageVertStride,imageDepth,imageHeight,imageWidth)
@@ -175,34 +174,11 @@ def rotate_label_patch_3d(src,trg,k,l,m,rm_xx,rm_xy,rm_xz,rm_yx,rm_yy,rm_yz,rm_z
                 trg[z-k,y-l,x-m] = src[idx_src_z,idx_src_y,idx_src_x]
     return trg
 
-def random_rotation_3d(image, max_angle=180):
-    """ Randomly rotate an image by a random angle (-max_angle, max_angle).
-
-    Arguments:
-    max_angle: `float`. The maximum rotation angle.
-
-    Returns:
-    batch of rotated 3D images
-    """
-
-    # rotate along x-axis
-    angle = random.uniform(-max_angle, max_angle)
-    image2 = scipy.ndimage.rotate(image, angle, mode='nearest', axes=(0, 1), reshape=False)
-
-    # rotate along y-axis
-    angle = random.uniform(-max_angle, max_angle)
-    image3 = scipy.ndimage.rotate(image2, angle, mode='nearest', axes=(0, 2), reshape=False)
-
-    # rotate along z-axis
-    angle = random.uniform(-max_angle, max_angle)
-    image_rot = scipy.ndimage.rotate(image3, angle, mode='nearest', axes=(1, 2), reshape=False)
-
-    return image_rot
-
 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,False), patch_normalization=False, separation=False):
+    def __init__(self, img, label, list_IDs_fg, list_IDs_bg, shuffle, train, batch_size=32, dim=(32,32,32),
+                 dim_img=(32,32,32), n_classes=10, n_channels=1, augment=(False,False,False,False,0,False),
+                 patch_normalization=False, separation=False, ignore_mask=False):
         'Initialization'
         self.dim = dim
         self.dim_img = dim_img
@@ -216,10 +192,10 @@ class DataGenerator(tf.keras.utils.Sequence):
         self.shuffle = shuffle
         self.augment = augment
         self.train = train
-        self.classification = classification
         self.on_epoch_end()
         self.patch_normalization = patch_normalization
         self.separation = separation
+        self.ignore_mask = ignore_mask
 
     def __len__(self):
         'Denotes the number of batches per epoch'
@@ -276,12 +252,12 @@ class DataGenerator(tf.keras.utils.Sequence):
     def __data_generation(self, list_IDs_temp):
         'Generates data containing batch_size samples' # X : (n_samples, *dim, n_channels)
 
-        # Initialization
+        # number of label channels
+        label_channels = 2 if self.ignore_mask else 1
+
+        # allocate memory
         X = np.empty((self.batch_size, *self.dim, self.n_channels), dtype=np.float32)
-        if self.classification:
-            y = np.empty((self.batch_size, 1), dtype=np.int32)
-        else:
-            y = np.empty((self.batch_size, *self.dim, 1), dtype=np.int32)
+        y = np.empty((self.batch_size, *self.dim, label_channels), dtype=np.int32)
 
         # get augmentation parameter
         flip_x, flip_y, flip_z, swapaxes, rotate, rotate3d = self.augment
@@ -306,119 +282,92 @@ class DataGenerator(tf.keras.utils.Sequence):
             m = rest % self.dim_img[2]
 
             # get patch
-            if self.classification:
-                tmp_X = self.img[k:k+self.dim[0],l:l+self.dim[1],m:m+self.dim[2]]
-                tmp_y = self.label[k,l,m]
-
-                # augmentation
-                if self.train:
-
-                    # rotate in 3D
-                    if rotate:
-                        tmp_X = random_rotation_3d(tmp_X, max_angle=rotate)
-
-                    # flip patch along axes
-                    v = np.random.randint(n_aug+1)
-                    if np.any([flip_x, flip_y, flip_z]) and v>0:
-                        flip = flips[v-1]
-                        tmp_X = np.flip(tmp_X, flip)
-
-                    # swap axes
-                    if swapaxes:
-                        v = np.random.randint(4)
-                        if v==1:
-                            tmp_X = np.swapaxes(tmp_X,0,1)
-                        elif v==2:
-                            tmp_X = np.swapaxes(tmp_X,0,2)
-                        elif v==3:
-                            tmp_X = np.swapaxes(tmp_X,1,2)
-
-                # assign to batch
-                X[i,:,:,:,0] = tmp_X
-                y[i,0] = tmp_y
-
-            else:
-                # get patch
-                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:
-
-                    # rotate in xy plane
-                    if rotate:
-                        tmp_X = np.empty((*self.dim, self.n_channels), dtype=np.float32)
-                        tmp_y = np.empty(self.dim, dtype=np.int32)
-                        cos_a = cos_angle[i]
-                        sin_a = sin_angle[i]
-                        for c in range(self.n_channels):
-                            tmp_X[:,:,:,c] = rotate_img_patch(self.img[:,:,:,c],tmp_X[:,:,:,c],k,l,m,cos_a,sin_a,
-                                self.dim[0],self.dim[1],self.dim[2],
-                                self.dim_img[1],self.dim_img[2])
-                        tmp_y = rotate_label_patch(self.label,tmp_y,k,l,m,cos_a,sin_a,
+            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:
+
+                # rotate in xy plane
+                if rotate:
+                    tmp_X = np.empty((*self.dim, self.n_channels), dtype=np.float32)
+                    tmp_y = np.empty((*self.dim, label_channels), dtype=np.int32)
+                    cos_a = cos_angle[i]
+                    sin_a = sin_angle[i]
+                    for ch in range(self.n_channels):
+                        tmp_X[...,ch] = rotate_img_patch(self.img[...,ch],tmp_X[...,ch],k,l,m,cos_a,sin_a,
+                            self.dim[0],self.dim[1],self.dim[2],
+                            self.dim_img[1],self.dim_img[2])
+                    for ch in range(label_channels):
+                        tmp_y[...,ch] = rotate_label_patch(self.label[...,ch],tmp_y[...,ch],k,l,m,cos_a,sin_a,
                             self.dim[0],self.dim[1],self.dim[2],
                             self.dim_img[1],self.dim_img[2])
-                    
-                    # rotate through a random 3d angle, uniformly distributed on a sphere.
-                    if rotate3d:
-                        tmp_X = np.empty((*self.dim, self.n_channels), dtype=np.float32)
-                        tmp_y = np.empty(self.dim, dtype=np.int32)
-                        rm_xx = rot_mtx[i, 0, 0]
-                        rm_xy = rot_mtx[i, 0, 1]
-                        rm_xz = rot_mtx[i, 0, 2]
-                        rm_yx = rot_mtx[i, 1, 0]
-                        rm_yy = rot_mtx[i, 1, 1]
-                        rm_yz = rot_mtx[i, 1, 2]
-                        rm_zx = rot_mtx[i, 2, 0]
-                        rm_zy = rot_mtx[i, 2, 1]
-                        rm_zz = rot_mtx[i, 2, 2]
-                        for c in range(self.n_channels):
-                            tmp_X[:,:,:,c] = rotate_img_patch_3d(self.img[:,:,:,c],tmp_X[:,:,:,c],k,l,m,
-                                rm_xx,rm_xy,rm_xz,rm_yx,rm_yy,rm_yz,rm_zx,rm_zy,rm_zz,
-                                self.dim[0],self.dim[1],self.dim[2],
-                                256, self.dim_img[0],self.dim_img[1],self.dim_img[2])
-                        tmp_y = rotate_label_patch_3d(self.label,tmp_y,k,l,m,
+
+                # rotate through a random 3d angle, uniformly distributed on a sphere.
+                if rotate3d:
+                    tmp_X = np.empty((*self.dim, self.n_channels), dtype=np.float32)
+                    tmp_y = np.empty((*self.dim, label_channels), dtype=np.int32)
+                    rm_xx = rot_mtx[i, 0, 0]
+                    rm_xy = rot_mtx[i, 0, 1]
+                    rm_xz = rot_mtx[i, 0, 2]
+                    rm_yx = rot_mtx[i, 1, 0]
+                    rm_yy = rot_mtx[i, 1, 1]
+                    rm_yz = rot_mtx[i, 1, 2]
+                    rm_zx = rot_mtx[i, 2, 0]
+                    rm_zy = rot_mtx[i, 2, 1]
+                    rm_zz = rot_mtx[i, 2, 2]
+                    for ch in range(self.n_channels):
+                        tmp_X[...,ch] = rotate_img_patch_3d(self.img[...,ch],tmp_X[...,ch],k,l,m,
+                            rm_xx,rm_xy,rm_xz,rm_yx,rm_yy,rm_yz,rm_zx,rm_zy,rm_zz,
+                            self.dim[0],self.dim[1],self.dim[2],
+                            256, self.dim_img[0],self.dim_img[1],self.dim_img[2])
+                    for ch in range(label_channels):
+                        tmp_y[...,ch] = rotate_label_patch_3d(self.label[...,ch],tmp_y[...,ch],k,l,m,
                             rm_xx,rm_xy,rm_xz,rm_yx,rm_yy,rm_yz,rm_zx,rm_zy,rm_zz,
                             self.dim[0],self.dim[1],self.dim[2],
                             256, self.dim_img[0],self.dim_img[1],self.dim_img[2])
 
-                    # flip patch along axes
-                    v = np.random.randint(n_aug+1)
-                    if np.any([flip_x, flip_y, flip_z]) and v>0:
-                        flip = flips[v-1]
-                        tmp_X = np.flip(tmp_X, flip)
-                        tmp_y = np.flip(tmp_y, flip)
-
-                    # swap axes
-                    if swapaxes:
-                        v = np.random.randint(4)
-                        if v==1:
-                            tmp_X = np.swapaxes(tmp_X,0,1)
-                            tmp_y = np.swapaxes(tmp_y,0,1)
-                        elif v==2:
-                            tmp_X = np.swapaxes(tmp_X,0,2)
-                            tmp_y = np.swapaxes(tmp_y,0,2)
-                        elif v==3:
-                            tmp_X = np.swapaxes(tmp_X,1,2)
-                            tmp_y = np.swapaxes(tmp_y,1,2)
-
-                # patch normalization
-                if self.patch_normalization:
-                    tmp_X = tmp_X.copy().astype(np.float32)
-                    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)
-
-                # assign to batch
-                X[i] = tmp_X
-                y[i,:,:,:,0] = tmp_y
-
-        return X, tf.keras.utils.to_categorical(y, num_classes=self.n_classes)
+                # flip patch along axes
+                v = np.random.randint(n_aug+1)
+                if np.any([flip_x, flip_y, flip_z]) and v>0:
+                    flip = flips[v-1]
+                    tmp_X = np.flip(tmp_X, flip)
+                    tmp_y = np.flip(tmp_y, flip)
+
+                # swap axes
+                if swapaxes:
+                    v = np.random.randint(4)
+                    if v==1:
+                        tmp_X = np.swapaxes(tmp_X,0,1)
+                        tmp_y = np.swapaxes(tmp_y,0,1)
+                    elif v==2:
+                        tmp_X = np.swapaxes(tmp_X,0,2)
+                        tmp_y = np.swapaxes(tmp_y,0,2)
+                    elif v==3:
+                        tmp_X = np.swapaxes(tmp_X,1,2)
+                        tmp_y = np.swapaxes(tmp_y,1,2)
+
+            # patch normalization
+            if self.patch_normalization:
+                tmp_X = tmp_X.copy().astype(np.float32)
+                for ch in range(self.n_channels):
+                    mean, std = welford_mean_std(tmp_X[...,ch])
+                    tmp_X[...,ch] -= mean
+                    tmp_X[...,ch] /= max(std, 1e-6)
+
+            # assign to batch
+            X[i] = tmp_X
+            y[i] = tmp_y
+
+        if self.ignore_mask:
+            return X, y
+        else:
+            return X, tf.keras.utils.to_categorical(y, num_classes=self.n_classes)
 

{biomedisa-24.8.11 → biomedisa-25.7.1}/src/biomedisa/features/PredictDataGenerator.py

@@ -1,6 +1,6 @@
 ##########################################################################
 ##                                                                      ##
-##  Copyright (c) 2019-2024 Philipp Lösel. All rights reserved.         ##
+##  Copyright (c) 2019-2025 Philipp Lösel. All rights reserved.         ##
 ##                                                                      ##
 ##  This file is part of the open source project biomedisa.             ##
 ##                                                                      ##
@@ -26,6 +26,7 @@
 ##                                                                      ##
 ##########################################################################
 
+from biomedisa.features.biomedisa_helper import welford_mean_std
 import numpy as np
 import tensorflow as tf
 
@@ -77,10 +78,11 @@ class PredictDataGenerator(tf.keras.utils.Sequence):
             # get patch
             tmp_X = self.img[k:k+self.dim[0],l:l+self.dim[1],m:m+self.dim[2]]
             if self.patch_normalization:
-                tmp_X = np.copy(tmp_X, order='C')
-                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)
+                tmp_X = tmp_X.copy().astype(np.float32)
+                for ch in range(self.n_channels):
+                    mean, std = welford_mean_std(tmp_X[...,ch])
+                    tmp_X[...,ch] -= mean
+                    tmp_X[...,ch] /= max(std, 1e-6)
             X[i] = tmp_X
 
         return X

{biomedisa-24.8.11 → biomedisa-25.7.1}/src/biomedisa/features/biomedisa_helper.py

@@ -32,6 +32,7 @@ from biomedisa.features.amira_to_np.amira_helper import amira_to_np, np_to_amira
 from biomedisa.features.nc_reader import nc_to_np, np_to_nc
 from tifffile import imread, imwrite
 from medpy.io import load, save
+from skimage import io
 import SimpleITK as sitk
 from PIL import Image
 import numpy as np
@@ -52,25 +53,41 @@ def silent_remove(filename):
     except OSError:
         pass
 
+# calculate mean and standard deviation using Welford's algorithm
+@numba.jit(nopython=True)
+def welford_mean_std(arr):
+    mean, m2, count = 0.0, 0.0, 0
+    for x in arr.ravel():
+        count += 1
+        delta = x - mean
+        mean += delta / count
+        delta2 = x - mean
+        m2 += delta * delta2  # Running sum of squared differences
+    std_dev = np.sqrt(m2 / count) if count > 1 else 0.0  # Population std deviation
+    return mean, std_dev
+
 # determine all values and their count from an array
 def unique(arr, return_counts=False):
-    try:
-        arr = arr.ravel()
-        counts = np.zeros(np.amax(arr)+1, dtype=int)
-        @numba.jit(nopython=True)
-        def __unique__(arr, size, counts):
-            for k in range(size):
-                counts[arr[k]] += 1
-            return counts
-        counts = __unique__(arr, arr.size, counts)
-        labels = np.where(counts)[0]
-        if return_counts:
-            return labels, counts[labels]
-        else:
-            return labels
-    except Exception as e:
-        print(f"Error: {e}")
-        return None
+    if np.issubdtype(arr.dtype, np.integer) and np.all(arr >= 0):
+        try:
+            arr = arr.ravel()
+            counts = np.zeros(np.amax(arr)+1, dtype=int)
+            @numba.jit(nopython=True)
+            def __unique__(arr, size, counts):
+                for k in range(size):
+                    counts[arr[k]] += 1
+                return counts
+            counts = __unique__(arr, arr.size, counts)
+            labels = np.where(counts)[0]
+            if return_counts:
+                return labels, counts[labels]
+            else:
+                return labels
+        except Exception as e:
+            print(f"Error: {e}")
+            return None
+    else:
+        return np.unique(arr, return_counts=return_counts)
 
 # create a unique filename
 def unique_file_path(path, dir_path=biomedisa.BASE_DIR+'/private_storage/'):
@@ -260,6 +277,10 @@ def recursive_file_permissions(path_to_dir):
         except:
             pass
 
+def natural_key(string):
+    # Split the string into parts of digits and non-digits
+    return [int(s) if s.isdigit() else s.lower() for s in re.split(r'(\d+)', string)]
+
 def load_data(path_to_data, process='None', return_extension=False):
 
     if not os.path.exists(path_to_data):
@@ -341,7 +362,7 @@ def load_data(path_to_data, process='None', return_extension=False):
                         file_names = []
                         img_slices = []
                         header = []
-                        files.sort()
+                        files.sort(key=natural_key)
                         for file_name in files:
                             if os.path.isfile(file_name):
                                 try:
@@ -349,8 +370,16 @@ def load_data(path_to_data, process='None', return_extension=False):
                                     file_names.append(file_name)
                                     img_slices.append(img)
                                     header.append(img_header)
-                                except:
-                                    pass
+                                except RuntimeError as e:
+                                    # Check for 64-bit TIFF error
+                                    if "Unable to read tiff file" in str(e) and "64-bit samples" in str(e):
+                                        try:
+                                            img = io.imread(file_name)
+                                            file_names.append(file_name)
+                                            img_slices.append(img)
+                                            header.append(None)
+                                        except:
+                                            pass
 
                         # get data size
                         img = img_slices[0]
@@ -408,14 +437,21 @@ def load_data(path_to_data, process='None', return_extension=False):
     else:
         return data, header
 
-def _error_(bm, message):
+def _error_(bm, message, level=1):
     if bm.django_env:
         from biomedisa.features.django_env import create_error_object
         create_error_object(message, bm.remote, bm.queue, bm.img_id)
         with open(bm.path_to_logfile, 'a') as logfile:
             print('%s %s %s %s' %(time.ctime(), bm.username, bm.shortfilename, message), file=logfile)
-    print('Error:', message)
-    bm.success = False
+    elif bm.slicer and bm.path_to_data:
+        error_path = os.path.dirname(bm.path_to_data) + '/biomedisa-error.txt'
+        with open(error_path, 'w') as file:
+            file.write(message)
+    if level==0:
+        print('Warning:', message)
+    elif level==1:
+        print('Error:', message)
+        bm.success = False
     return bm
 
 def pre_processing(bm):
@@ -613,7 +649,10 @@ def _get_platform(bm):
     if cl and bm.platform is None:
         for vendor in ['NVIDIA', 'Intel', 'AMD', 'Apple']:
             for dev, device_type in [('GPU',cl.device_type.GPU),('CPU',cl.device_type.CPU)]:
-                all_platforms = cl.get_platforms()
+                try:
+                    all_platforms = cl.get_platforms()
+                except:
+                    all_platforms = []
                 my_devices = []
                 for p in all_platforms:
                     if p.get_devices(device_type=device_type) and vendor in p.name:
@@ -634,7 +673,10 @@ def _get_platform(bm):
     elif cl and len(bm.platform.split('_')) == 3:
         plat, vendor, dev = bm.platform.split('_')
         device_type=cl.device_type.GPU if dev=='GPU' else cl.device_type.CPU
-        all_platforms = cl.get_platforms()
+        try:
+            all_platforms = cl.get_platforms()
+        except:
+            all_platforms = []
         my_devices = []
         for p in all_platforms:
             if p.get_devices(device_type=device_type) and vendor in p.name: