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

biomedisa/features/biomedisa_helper.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.             ##
 ##                                                                      ##
@@ -52,6 +52,39 @@ 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
+
 # create a unique filename
 def unique_file_path(path, dir_path=biomedisa.BASE_DIR+'/private_storage/'):
 
@@ -105,7 +138,7 @@ def unique_file_path(path, dir_path=biomedisa.BASE_DIR+'/private_storage/'):
 def Dice_score(ground_truth, result, average_dice=False):
     if average_dice:
         dice = 0
-        allLabels = np.unique(ground_truth)
+        allLabels = unique(ground_truth)
         for l in allLabels[1:]:
             dice += 2 * np.logical_and(ground_truth==l, result==l).sum() / float((ground_truth==l).sum() + (result==l).sum())
         dice /= float(len(allLabels)-1)
@@ -120,7 +153,7 @@ def ASSD(ground_truth, result):
         number_of_elements = 0
         distances = 0
         hausdorff = 0
-        for label in np.unique(ground_truth)[1:]:
+        for label in unique(ground_truth)[1:]:
             d, n, h = ASSD_one_label(ground_truth, result, label)
             number_of_elements += n
             distances += d
@@ -157,7 +190,7 @@ def img_resize(a, z_shape, y_shape, x_shape, interpolation=None, labels=False):
 
     if labels:
         data = np.zeros((z_shape, y_shape, x_shape), dtype=a.dtype)
-        for k in np.unique(a):
+        for k in unique(a):
             if k!=0:
                 tmp = np.zeros(a.shape, dtype=np.uint8)
                 tmp[a==k] = 1
@@ -193,7 +226,7 @@ def set_labels_to_zero(label, labels_to_compute, labels_to_remove):
     # compute only specific labels (set rest to zero)
     labels_to_compute = labels_to_compute.split(',')
     if not any([x in ['all', 'All', 'ALL'] for x in labels_to_compute]):
-        allLabels = np.unique(label)
+        allLabels = unique(label)
         labels_to_del = [k for k in allLabels if str(k) not in labels_to_compute and k > 0]
         for k in labels_to_del:
             label[label == k] = 0
@@ -388,14 +421,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):
@@ -430,7 +470,7 @@ def pre_processing(bm):
         bm.labelData = bm.labelData.astype(np.int32)
 
     # get labels
-    bm.allLabels = np.unique(bm.labelData)
+    bm.allLabels = unique(bm.labelData)
     index = np.argwhere(bm.allLabels<0)
     bm.allLabels = np.delete(bm.allLabels, index)
 
@@ -553,7 +593,7 @@ def color_to_gray(labelData):
     return labelData
 
 def delbackground(labels):
-    allLabels, labelcounts = np.unique(labels, return_counts=True)
+    allLabels, labelcounts = unique(labels, return_counts=True)
     index = np.argmax(labelcounts)
     labels[labels==allLabels[index]] = 0
     return labels
@@ -593,7 +633,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:
@@ -614,7 +657,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:
@@ -844,9 +890,8 @@ def _split_indices(indices, ngpus):
     return parts
 
 def get_labels(pre_final, labels):
-    numos = np.unique(pre_final)
     final = np.zeros_like(pre_final)
-    for k in numos[1:]:
+    for k in unique(pre_final)[1:]:
         final[pre_final == k] = labels[k]
     return final
 

biomedisa/features/crop_helper.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.             ##
 ##                                                                      ##
@@ -28,7 +28,8 @@
 
 import os
 from biomedisa.features.keras_helper import read_img_list
-from biomedisa.features.biomedisa_helper import img_resize, load_data, save_data, set_labels_to_zero
+from biomedisa.features.biomedisa_helper import (img_resize,
+    load_data, save_data, set_labels_to_zero, welford_mean_std)
 from tensorflow.python.framework.errors_impl import ResourceExhaustedError
 from tensorflow.keras.applications import DenseNet121, densenet
 from tensorflow.keras.optimizers import Adam
@@ -161,7 +162,7 @@ def load_cropping_training_data(normalize, img_list, label_list, x_scale, y_scal
             # normalize first validation image
             if normalize and np.any(normalization_parameters):
                 for c in range(channels):
-                    mean, std = np.mean(img[:,:,:,c]), np.std(img[:,:,:,c])
+                    mean, std = welford_mean_std(img[:,:,:,c])
                     img[:,:,:,c] = (img[:,:,:,c] - mean) / std
                     img[:,:,:,c] = img[:,:,:,c] * normalization_parameters[1,c] + normalization_parameters[0,c]
 
@@ -170,8 +171,7 @@ def load_cropping_training_data(normalize, img_list, label_list, x_scale, y_scal
                 normalization_parameters = np.zeros((2,channels))
                 if normalize:
                     for c in range(channels):
-                        normalization_parameters[0,c] = np.mean(img[:,:,:,c])
-                        normalization_parameters[1,c] = np.std(img[:,:,:,c])
+                        normalization_parameters[:,c] = welford_mean_std(img[:,:,:,c])
 
             # loop over list of images
             if any(img_list) or type(img_in) is list:
@@ -223,7 +223,7 @@ def load_cropping_training_data(normalize, img_list, label_list, x_scale, y_scal
                         next_img[:,:,:,c] -= np.amin(next_img[:,:,:,c])
                         next_img[:,:,:,c] /= np.amax(next_img[:,:,:,c])
                         if normalize:
-                            mean, std = np.mean(next_img[:,:,:,c]), np.std(next_img[:,:,:,c])
+                            mean, std = welford_mean_std(next_img[:,:,:,c])
                             next_img[:,:,:,c] = (next_img[:,:,:,c] - mean) / std
                             next_img[:,:,:,c] = next_img[:,:,:,c] * normalization_parameters[1,c] + normalization_parameters[0,c]
                     img = np.append(img, next_img, axis=0)
@@ -391,7 +391,7 @@ def load_data_to_crop(path_to_img, channels, x_scale, y_scale, z_scale,
         img[:,:,:,c] -= np.amin(img[:,:,:,c])
         img[:,:,:,c] /= np.amax(img[:,:,:,c])
         if normalize:
-            mean, std = np.mean(img[:,:,:,c]), np.std(img[:,:,:,c])
+            mean, std = welford_mean_std(img[:,:,:,c])
             img[:,:,:,c] = (img[:,:,:,c] - mean) / std
             img[:,:,:,c] = img[:,:,:,c] * normalization_parameters[1,c] + normalization_parameters[0,c]
     img[img<0] = 0