biomedisa 24.8.10__py3-none-any.whl → 25.6.1__py3-none-any.whl

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.             ##
 ##                                                                      ##
@@ -67,7 +67,7 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
     balance=False, crop_data=False, flip_x=False, flip_y=False, flip_z=False,
     swapaxes=False, train_dice=False, val_dice=True, compression=True, ignore='none', only='all',
     network_filters='32-64-128-256-512', resnet=False, debug_cropping=False,
-    save_cropped=False, epochs=100, normalization=True, rotate=0.0, validation_split=0.0,
+    save_cropped=False, epochs=100, normalization=True, rotate=0.0, rotate3d=0.0, validation_split=0.0,
     learning_rate=0.01, stride_size=32, validation_stride_size=32, validation_freq=1,
     batch_size=None, x_scale=256, y_scale=256, z_scale=256, scaling=True, early_stopping=0,
     pretrained_model=None, fine_tune=False, workers=1, cropping_epochs=50,
@@ -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:
@@ -436,6 +443,8 @@ if __name__ == '__main__':
                         help='Disable normalization of 3D image volumes')
     parser.add_argument('-r','--rotate', type=float, default=0.0,
                         help='Randomly rotate during training')
+    parser.add_argument('--rotate3d', action='store_true', default=False,
+                        help='Randomly rotate through three dimensions during training. Uniformly distributed over the sphere.')
     parser.add_argument('-vs','--validation_split', type=float, default=0.0,
                         help='Percentage of data used for training')
     parser.add_argument('-lr','--learning_rate', type=float, default=0.01,
@@ -504,9 +513,20 @@ 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
 
+    if bm.rotate3d and not bm.scaling:
+        raise RuntimeError("You cannot do true 3d rotation without rescaling the data yet.")
+        # To fix this, have the loading function pass in a list of where the images end,
+        # and use that to figure out the z-centres in biomedisa.features.DataGenerator.rotate_*_3d
+
     # prediction or training
     if not any([bm.train, bm.predict]):
         bm.predict = False
@@ -536,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:
@@ -554,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/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,30 @@
 ##                                                                      ##
 ##########################################################################
 
+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)
+    Householder_1 = np.random.uniform(0, 2. * np.pi, batch_size)
+    Householder_2 = np.random.uniform(0, 1., batch_size)
+    # Matrix for xy rotation
+    RR = np.zeros([batch_size, 3, 3])
+    RR[:, 0, 0] = np.cos(angle_xy[:])
+    RR[:, 0, 1] = np.sin(angle_xy[:])
+    RR[:, 1, 0] = np.cos(angle_xy[:])
+    RR[:, 1, 1] = -np.sin(angle_xy[:])
+    RR[:, 2, 2] = 1.
+    # Householder matrix
+    vv = np.zeros([batch_size, 3, 1])
+    vv[:, 0, 0] = np.cos(Householder_1[:]) * np.sqrt(Householder_2[:])
+    vv[:, 1, 0] = np.sin(Householder_1[:]) * np.sqrt(Householder_2[:])
+    vv[:, 2, 0] = np.sqrt(1. - Householder_2[:])
+    HH = np.eye(3)[np.newaxis, :, :] - 2. * np.matmul(vv, vv.transpose(0, 2, 1))
+    return -np.matmul(HH, RR)
 
 @numba.jit(nopython=True)#parallel=True
 def rotate_img_patch(src,trg,k,l,m,cos_a,sin_a,z_patch,y_patch,x_patch,imageHeight,imageWidth):
@@ -61,6 +80,56 @@ 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)
+    for z in range(k,k+z_patch):
+        zCentreRotation = imageVertStride * (z // imageVertStride) + imageVertStride/2
+        zA = z - zCentreRotation
+        for y in range(l,l+y_patch):
+            yA = y - imageHeight/2
+            for x in range(m,m+x_patch):
+                xA = x - imageWidth/2
+                xR = xA * rm_xx + yA * rm_xy + zA * rm_xz
+                yR = xA * rm_yx + yA * rm_yy + zA * rm_yz
+                zR = xA * rm_zx + yA * rm_zy + zA * rm_zz
+                src_x = xR + imageWidth/2
+                src_y = yR + imageHeight/2
+                src_z = zR + zCentreRotation
+                # bilinear interpolation
+                src_x0 = float(int(src_x))
+                src_x1 = src_x0 + 1
+                src_y0 = float(int(src_y))
+                src_y1 = src_y0 + 1
+                src_z0 = float(int(src_z))
+                src_z1 = src_z0 + 1
+                sx = src_x - src_x0
+                sy = src_y - src_y0
+                sz = src_z - src_z0
+                idx_src_x0 = int(min(max(0,src_x0),imageWidth-1))
+                idx_src_x1 = int(min(max(0,src_x1),imageWidth-1))
+                idx_src_y0 = int(min(max(0,src_y0),imageHeight-1))
+                idx_src_y1 = int(min(max(0,src_y1),imageHeight-1))
+                idx_src_z0 = int(min(max(0,src_z0),imageDepth-1))
+                idx_src_z1 = int(min(max(0,src_z1),imageDepth-1))
+                
+                val  = (1-sy) * (1-sx) * (1-sz) * float(src[idx_src_z0,idx_src_y0,idx_src_x0])
+                val += (sy) * (1-sx) * (1-sz) * float(src[idx_src_z0,idx_src_y1,idx_src_x0])
+                val += (1-sy) * (sx) * (1-sz) * float(src[idx_src_z0,idx_src_y0,idx_src_x1])
+                val += (sy) * (sx) * (1-sz) * float(src[idx_src_z0,idx_src_y1,idx_src_x1])
+                val += (1-sy) * (1-sx) * (sz) * float(src[idx_src_z1,idx_src_y0,idx_src_x0])
+                val += (sy) * (1-sx) * (sz) * float(src[idx_src_z1,idx_src_y1,idx_src_x0])
+                val += (1-sy) * (sx) * (sz) * float(src[idx_src_z1,idx_src_y0,idx_src_x1])
+                val += (sy) * (sx) * (sz) * float(src[idx_src_z1,idx_src_y1,idx_src_x1])
+                trg[z-k,y-l,x-m] = val
+    return trg
+
+# This exists so I could test it. It's not called because sometimes numba is funny about nested
+# nopython functions.
+@numba.jit(nopython=True)#parallel=True
+def centre_of_z_rotation(z, imageVertStride):
+    return imageVertStride * (z // imageVertStride) + imageVertStride/2
+
 @numba.jit(nopython=True)#parallel=True
 def rotate_label_patch(src,trg,k,l,m,cos_a,sin_a,z_patch,y_patch,x_patch,imageHeight,imageWidth):
     for y in range(l,l+y_patch):
@@ -80,34 +149,36 @@ def rotate_label_patch(src,trg,k,l,m,cos_a,sin_a,z_patch,y_patch,x_patch,imageHe
                 trg[z-k,y-l,x-m] = 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
+@numba.jit(nopython=True)#parallel=True
+def 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):
+    for z in range(k,k+z_patch):
+        zCentreRotation = imageVertStride * (z // imageVertStride) + imageVertStride/2
+        zA = z - zCentreRotation
+        for y in range(l,l+y_patch):
+            yA = y - imageHeight/2
+            for x in range(m,m+x_patch):
+                xA = x - imageWidth/2
+                xR = xA * rm_xx + yA * rm_xy + zA * rm_xz
+                yR = xA * rm_yx + yA * rm_yy + zA * rm_yz
+                zR = xA * rm_zx + yA * rm_zy + zA * rm_zz
+                src_x = xR + imageWidth/2
+                src_y = yR + imageHeight/2
+                src_z = zR + zCentreRotation
+                # nearest neighbour
+                src_x = round(src_x)
+                src_y = round(src_y)
+                src_z = round(src_z)
+                idx_src_x = int(min(max(0,src_x),imageWidth-1))
+                idx_src_y = int(min(max(0,src_y),imageHeight-1))
+                idx_src_z = int(min(max(0,src_z),imageDepth-1))
+                trg[z-k,y-l,x-m] = src[idx_src_z,idx_src_y,idx_src_x]
+    return trg
 
 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, 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
@@ -121,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'
@@ -181,15 +252,15 @@ 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 = self.augment
+        flip_x, flip_y, flip_z, swapaxes, rotate, rotate3d = self.augment
         n_aug = np.sum([flip_z, flip_y, flip_x])
         flips =  np.where([flip_z, flip_y, flip_x])[0]
 
@@ -198,6 +269,8 @@ class DataGenerator(tf.keras.utils.Sequence):
             angle = np.random.uniform(-1,1,self.batch_size) * 3.1416/180*rotate
             cos_angle = np.cos(angle)
             sin_angle = np.sin(angle)
+        if rotate3d:
+            rot_mtx = get_random_rotation_matrix(self.batch_size)
 
         # Generate data
         for i, ID in enumerate(list_IDs_temp):
@@ -209,96 +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])
 
-                    # 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)
+                # 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 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/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