biomedisa 24.8.10__tar.gz → 24.8.11__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: biomedisa
-Version: 24.8.10
+Version: 24.8.11
 Summary: Segmentation of 3D volumetric image data
 Author: Philipp Lösel
 Author-email: philipp.loesel@anu.edu.au

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

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

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

@@ -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,
@@ -436,6 +436,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,
@@ -507,6 +509,11 @@ if __name__ == '__main__':
     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

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

@@ -32,6 +32,25 @@ 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):
     for y in range(l,l+y_patch):
@@ -61,6 +80,57 @@ 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,6 +150,31 @@ 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
 
+@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
+
 def random_rotation_3d(image, max_angle=180):
     """ Randomly rotate an image by a random angle (-max_angle, max_angle).
 
@@ -107,7 +202,7 @@ def random_rotation_3d(image, max_angle=180):
 class DataGenerator(tf.keras.utils.Sequence):
     'Generates data for Keras'
     def __init__(self, img, label, list_IDs_fg, list_IDs_bg, shuffle, train, classification, batch_size=32, dim=(32,32,32),
-                 dim_img=(32,32,32), n_classes=10, n_channels=1, augment=(False,False,False,False,0), patch_normalization=False, separation=False):
+                 dim_img=(32,32,32), n_classes=10, n_channels=1, augment=(False,False,False,False,0,False), patch_normalization=False, separation=False):
         'Initialization'
         self.dim = dim
         self.dim_img = dim_img
@@ -189,7 +284,7 @@ class DataGenerator(tf.keras.utils.Sequence):
             y = np.empty((self.batch_size, *self.dim, 1), 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 +293,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):
@@ -268,6 +365,29 @@ class DataGenerator(tf.keras.utils.Sequence):
                         tmp_y = rotate_label_patch(self.label,tmp_y,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,
+                            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)

{biomedisa-24.8.10 → biomedisa-24.8.11}/src/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,26 @@ def silent_remove(filename):
     except OSError:
         pass
 
+# 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 +125,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 +140,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 +177,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 +213,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
@@ -430,7 +450,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 +573,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
@@ -844,9 +864,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-24.8.10 → biomedisa-24.8.11}/src/biomedisa/features/keras_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.             ##
 ##                                                                      ##
@@ -41,7 +41,7 @@ from tensorflow.keras.utils import to_categorical
 from tensorflow.keras.callbacks import Callback, ModelCheckpoint, EarlyStopping
 from biomedisa.features.DataGenerator import DataGenerator
 from biomedisa.features.PredictDataGenerator import PredictDataGenerator
-from biomedisa.features.biomedisa_helper import (
+from biomedisa.features.biomedisa_helper import (unique,
     img_resize, load_data, save_data, set_labels_to_zero, id_generator, unique_file_path)
 from biomedisa.features.remove_outlier import clean, fill
 from biomedisa.features.active_contour import activeContour
@@ -319,9 +319,8 @@ def make_unet(input_shape, nb_labels, filters='32-64-128-256-512', resnet=False)
     return model
 
 def get_labels(arr, allLabels):
-    np_unique = np.unique(arr)
     final = np.zeros_like(arr)
-    for k in np_unique:
+    for k in unique(arr):
         final[arr == k] = allLabels[k]
     return final
 
@@ -412,7 +411,7 @@ def load_training_data(bm, img_list, label_list, channels, img_in=None, label_in
                 argmin_z,argmax_z,argmin_y,argmax_y,argmin_x,argmax_x = predict_blocksize(label, x_puffer, y_puffer, z_puffer)
                 label = label[argmin_z:argmax_z,argmin_y:argmax_y,argmin_x:argmax_x].copy()
             if bm.scaling:
-                label_values, counts = np.unique(label, return_counts=True)
+                label_values, counts = unique(label, return_counts=True)
                 print(f'{os.path.basename(label_names[0])}:', 'Labels:', label_values[1:], 'Sizes:', counts[1:])
                 label = img_resize(label, bm.z_scale, bm.y_scale, bm.x_scale, labels=True)
 
@@ -514,7 +513,7 @@ def load_training_data(bm, img_list, label_list, channels, img_in=None, label_in
                         argmin_z,argmax_z,argmin_y,argmax_y,argmin_x,argmax_x = predict_blocksize(a, x_puffer, y_puffer, z_puffer)
                         a = np.copy(a[argmin_z:argmax_z,argmin_y:argmax_y,argmin_x:argmax_x], order='C')
                     if bm.scaling:
-                        label_values, counts = np.unique(a, return_counts=True)
+                        label_values, counts = unique(a, return_counts=True)
                         print(f'{os.path.basename(label_names[k])}:', 'Labels:', label_values[1:], 'Sizes:', counts[1:])
                         a = img_resize(a, bm.z_scale, bm.y_scale, bm.x_scale, labels=True)
                         label = np.append(label, a, axis=0)
@@ -587,7 +586,7 @@ def load_training_data(bm, img_list, label_list, channels, img_in=None, label_in
     else:
         # get labels
         if allLabels is None:
-            allLabels = np.unique(label)
+            allLabels = unique(label)
             index = np.argwhere(allLabels<0)
             allLabels = np.delete(allLabels, index)
 
@@ -987,7 +986,7 @@ def train_segmentation(bm):
               'dim_img': (zsh, ysh, xsh),
               'n_classes': nb_labels,
               'n_channels': bm.channels,
-              'augment': (bm.flip_x, bm.flip_y, bm.flip_z, bm.swapaxes, bm.rotate),
+              'augment': (bm.flip_x, bm.flip_y, bm.flip_z, bm.swapaxes, bm.rotate, bm.rotate3d),
               'patch_normalization': bm.patch_normalization,
               'separation': bm.separation}
 
@@ -999,7 +998,7 @@ def train_segmentation(bm):
             val_metrics = Metrics(bm, bm.val_img_data, bm.val_label_data, list_IDs_val_fg, (zsh_val, ysh_val, xsh_val), nb_labels, False)
         else:
             params['dim_img'] = (zsh_val, ysh_val, xsh_val)
-            params['augment'] = (False, False, False, False, 0)
+            params['augment'] = (False, False, False, False, 0, False)
             validation_generator = DataGenerator(bm.val_img_data, bm.val_label_data, list_IDs_val_fg, list_IDs_val_bg, True, False, False, **params)
 
     # monitor dice score on training data

{biomedisa-24.8.10 → biomedisa-24.8.11}/src/biomedisa/features/remove_outlier.py

@@ -30,7 +30,7 @@
 import os
 import biomedisa
 from biomedisa.features.biomedisa_helper import (load_data, save_data,
-    unique_file_path, silent_remove)
+    unique_file_path, silent_remove, unique)
 import numpy as np
 from scipy import ndimage
 import argparse
@@ -60,7 +60,7 @@ def reduce_blocksize(data):
 
 def clean(image, threshold=0.1):
     image_i = np.copy(image, order='C')
-    allLabels = np.unique(image_i)
+    allLabels = unique(image_i)
     mask = np.empty_like(image_i)
     s = [[[0,0,0], [0,1,0], [0,0,0]], [[0,1,0], [1,1,1], [0,1,0]], [[0,0,0], [0,1,0], [0,0,0]]]
     for k in allLabels[1:]:
@@ -99,7 +99,7 @@ def clean(image, threshold=0.1):
 
 def fill(image, threshold=0.9):
     image_i = np.copy(image, order='C')
-    allLabels = np.unique(image_i)
+    allLabels = unique(image_i)
     mask = np.empty_like(image_i)
     s = [[[0,0,0], [0,1,0], [0,0,0]], [[0,1,0], [1,1,1], [0,1,0]], [[0,0,0], [0,1,0], [0,0,0]]]
     for k in allLabels[1:]:

{biomedisa-24.8.10 → biomedisa-24.8.11}/src/biomedisa/features/split_volume.py

@@ -132,17 +132,18 @@ if __name__ == '__main__':
                     labelData = labelData[datamin_z:datamax_z,datamin_y:datamax_y,datamin_x:datamax_x].copy()
 
                 # interpolation
-                results = smart_interpolation(data, labelData, uncertainty=args.uncertainty, allaxis=args.allaxis, smooth=args.smooth)
-
-                # append results
-                final[blockmin_z:blockmax_z,blockmin_y:blockmax_y,blockmin_x:blockmax_x] \
-                    = results['regular'][blockmin_z-datamin_z:blockmax_z-datamin_z,blockmin_y-datamin_y:blockmax_y-datamin_y,blockmin_x-datamin_x:blockmax_x-datamin_x]
-                if 'smooth' in results and results['smooth'] is not None:
-                    final_smooth[blockmin_z:blockmax_z,blockmin_y:blockmax_y,blockmin_x:blockmax_x] \
-                        = results['smooth'][blockmin_z-datamin_z:blockmax_z-datamin_z,blockmin_y-datamin_y:blockmax_y-datamin_y,blockmin_x-datamin_x:blockmax_x-datamin_x]
-                if 'uncertainty' in results and results['uncertainty'] is not None:
-                    final_uncertainty[blockmin_z:blockmax_z,blockmin_y:blockmax_y,blockmin_x:blockmax_x] \
-                        = results['uncertainty'][blockmin_z-datamin_z:blockmax_z-datamin_z,blockmin_y-datamin_y:blockmax_y-datamin_y,blockmin_x-datamin_x:blockmax_x-datamin_x]
+                if np.any(labelData):
+                    results = smart_interpolation(data, labelData, uncertainty=args.uncertainty, allaxis=args.allaxis, smooth=args.smooth)
+
+                    # append results
+                    final[blockmin_z:blockmax_z,blockmin_y:blockmax_y,blockmin_x:blockmax_x] \
+                        = results['regular'][blockmin_z-datamin_z:blockmax_z-datamin_z,blockmin_y-datamin_y:blockmax_y-datamin_y,blockmin_x-datamin_x:blockmax_x-datamin_x]
+                    if 'smooth' in results and results['smooth'] is not None:
+                        final_smooth[blockmin_z:blockmax_z,blockmin_y:blockmax_y,blockmin_x:blockmax_x] \
+                            = results['smooth'][blockmin_z-datamin_z:blockmax_z-datamin_z,blockmin_y-datamin_y:blockmax_y-datamin_y,blockmin_x-datamin_x:blockmax_x-datamin_x]
+                    if 'uncertainty' in results and results['uncertainty'] is not None:
+                        final_uncertainty[blockmin_z:blockmax_z,blockmin_y:blockmax_y,blockmin_x:blockmax_x] \
+                            = results['uncertainty'][blockmin_z-datamin_z:blockmax_z-datamin_z,blockmin_y-datamin_y:blockmax_y-datamin_y,blockmin_x-datamin_x:blockmax_x-datamin_x]
 
     # path to regular result
     filename, extension = os.path.splitext(os.path.basename(args.path_to_data))

{biomedisa-24.8.10 → biomedisa-24.8.11}/src/biomedisa/interpolation.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.             ##
 ##                                                                      ##
@@ -165,13 +165,8 @@ def smart_interpolation(data, labelData, nbrw=10, sorw=4000, acwe=False, acwe_al
             bm.imageSize = int(bm.data.nbytes * 10e-7)
 
             # add boundaries
-            zsh, ysh, xsh = bm.data.shape
-            tmp = np.zeros((1+zsh+1, 1+ysh+1, 1+xsh+1), dtype=bm.labelData.dtype)
-            tmp[1:-1, 1:-1, 1:-1] = bm.labelData
-            bm.labelData = tmp.copy(order='C')
-            tmp = np.zeros((1+zsh+1, 1+ysh+1, 1+xsh+1), dtype=bm.data.dtype)
-            tmp[1:-1, 1:-1, 1:-1] = bm.data
-            bm.data = tmp.copy(order='C')
+            bm.data = np.pad(bm.data, pad_width=1, mode='constant', constant_values=0)
+            bm.labelData = np.pad(bm.labelData, pad_width=1, mode='constant', constant_values=0)
             bm.zsh, bm.ysh, bm.xsh = bm.data.shape
 
             # check if labeled slices are adjacent

{biomedisa-24.8.10 → biomedisa-24.8.11}/src/biomedisa/mesh.py

@@ -30,7 +30,7 @@
 import os
 import numpy as np
 import biomedisa
-from biomedisa.features.biomedisa_helper import load_data, unique_file_path
+from biomedisa.features.biomedisa_helper import load_data, unique_file_path, unique
 from biomedisa.features.django_env import create_pid_object
 from vtk.util.numpy_support import vtk_to_numpy, numpy_to_vtk
 from stl import mesh
@@ -107,7 +107,7 @@ def save_mesh(path_to_result, labels, x_res=1, y_res=1, z_res=1,
 
     # get labels
     zsh, ysh, xsh = labels.shape
-    allLabels = np.unique(labels)
+    allLabels = unique(labels)
     b = np.empty_like(labels)
     arr = np.empty((0,3,3))
     nTotalCells = [0]

{biomedisa-24.8.10 → biomedisa-24.8.11}/src/biomedisa.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: biomedisa
-Version: 24.8.10
+Version: 24.8.11
 Summary: Segmentation of 3D volumetric image data
 Author: Philipp Lösel
 Author-email: philipp.loesel@anu.edu.au