biomedisa 24.8.1__tar.gz → 24.8.2__tar.gz

{biomedisa-24.8.1 → biomedisa-24.8.2}/PKG-INFO

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

{biomedisa-24.8.1 → biomedisa-24.8.2}/pyproject.toml

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

{biomedisa-24.8.1 → biomedisa-24.8.2}/src/biomedisa/deeplearning.py

@@ -76,7 +76,8 @@ def deep_learning(img_data, label_data=None, val_img_data=None, val_label_data=N
     path=None, success=True, return_probs=False, patch_normalization=False,
     z_patch=64, y_patch=64, x_patch=64, path_to_logfile=None, img_id=None, label_id=None,
     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):
+    acwe=False, acwe_alpha=1.0, acwe_smooth=1, acwe_steps=3, clean=None, fill=None,
+    separation=False, mask=None, refinement=False):
 
     # create biomedisa
     bm = Biomedisa()
@@ -479,6 +480,12 @@ if __name__ == '__main__':
                         help='Processing queue when using a remote server')
     parser.add_argument('-hf','--header_file', type=str, metavar='PATH', default=None,
                         help='Location of header file')
+    parser.add_argument('-s','--separation', action='store_true', default=False,
+                        help='Instance segmentation of objects such as cells or rock particles')
+    parser.add_argument('-m','--mask', type=str, metavar='PATH', default=None,
+                        help='Location of mask')
+    parser.add_argument('-rf','--refinement', action='store_true', default=False,
+                        help='Refine segmentation on full size data')
     parser.add_argument('-ext','--extension', type=str, default='.tif',
                         help='Save data for example as NRRD file using --extension=".nrrd"')
     bm = parser.parse_args()

{biomedisa-24.8.1 → biomedisa-24.8.2}/src/biomedisa/features/DataGenerator.py

@@ -107,7 +107,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):
+                 dim_img=(32,32,32), n_classes=10, n_channels=1, augment=(False,False,False,False,0), patch_normalization=False, separation=False):
         'Initialization'
         self.dim = dim
         self.dim_img = dim_img
@@ -124,6 +124,7 @@ class DataGenerator(tf.keras.utils.Sequence):
         self.classification = classification
         self.on_epoch_end()
         self.patch_normalization = patch_normalization
+        self.separation = separation
 
     def __len__(self):
         'Denotes the number of batches per epoch'
@@ -247,6 +248,13 @@ class DataGenerator(tf.keras.utils.Sequence):
                 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:
 

{biomedisa-24.8.1 → biomedisa-24.8.2}/src/biomedisa/features/keras_helper.py

@@ -355,7 +355,7 @@ def read_img_list(img_list, label_list, temp_img_dir, temp_label_dir):
             label_names.append(label_name)
     return img_names, label_names
 
-def load_training_data(normalize, img_list, label_list, channels, x_scale, y_scale, z_scale, scaling,
+def load_training_data(bm, normalize, img_list, label_list, channels, x_scale, y_scale, z_scale, scaling,
         crop_data, labels_to_compute, labels_to_remove, img_in=None, label_in=None,
         normalization_parameters=None, allLabels=None, header=None, extension='.tif',
         x_puffer=25, y_puffer=25, z_puffer=25):
@@ -382,8 +382,9 @@ def load_training_data(normalize, img_list, label_list, channels, x_scale, y_sca
                 label_names = ['label_1']
             label_dim = label.shape
             label = set_labels_to_zero(label, labels_to_compute, labels_to_remove)
-            label_values, counts = np.unique(label, return_counts=True)
-            print(f'{os.path.basename(label_names[0])}:', 'Labels:', label_values[1:], 'Sizes:', counts[1:])
+            if scaling:
+                label_values, counts = np.unique(label, return_counts=True)
+                print(f'{os.path.basename(label_names[0])}:', 'Labels:', label_values[1:], 'Sizes:', counts[1:])
             if crop_data:
                 argmin_z,argmax_z,argmin_y,argmax_y,argmin_x,argmax_x = predict_blocksize(label, x_puffer, y_puffer, z_puffer)
                 label = np.copy(label[argmin_z:argmax_z,argmin_y:argmax_y,argmin_x:argmax_x], order='C')
@@ -465,8 +466,9 @@ def load_training_data(normalize, img_list, label_list, channels, x_scale, y_sca
                         a = label_in[k]
                     label_dim = a.shape
                     a = set_labels_to_zero(a, labels_to_compute, labels_to_remove)
-                    label_values, counts = np.unique(a, return_counts=True)
-                    print(f'{os.path.basename(label_names[k])}:', 'Labels:', label_values[1:], 'Sizes:', counts[1:])
+                    if scaling:
+                        label_values, counts = np.unique(a, return_counts=True)
+                        print(f'{os.path.basename(label_names[k])}:', 'Labels:', label_values[1:], 'Sizes:', counts[1:])
                     if crop_data:
                         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')
@@ -509,13 +511,16 @@ def load_training_data(normalize, img_list, label_list, channels, x_scale, y_sca
     img[img<0] = 0
     img[img>1] = 1
 
-    # get labels
-    if allLabels is None:
-        allLabels = np.unique(label)
+    if bm.separation:
+        allLabels = np.array([0,1])
+    else:
+        # get labels
+        if allLabels is None:
+            allLabels = np.unique(label)
 
-    # labels must be in ascending order
-    for k, l in enumerate(allLabels):
-        label[label==l] = k
+        # labels must be in ascending order
+        for k, l in enumerate(allLabels):
+            label[label==l] = k
 
     return img, label, allLabels, normalization_parameters, header, extension, channels
 
@@ -775,7 +780,7 @@ def train_semantic_segmentation(bm,
     header=None, extension='.tif'):
 
     # training data
-    img, label, allLabels, normalization_parameters, header, extension, bm.channels = load_training_data(bm.normalize,
+    img, label, allLabels, normalization_parameters, header, extension, bm.channels = load_training_data(bm, bm.normalize,
                     img_list, label_list, None, bm.x_scale, bm.y_scale, bm.z_scale, bm.scaling, bm.crop_data,
                     bm.only, bm.ignore, img, label, None, None, header, extension)
 
@@ -789,7 +794,7 @@ def train_semantic_segmentation(bm,
 
     # validation data
     if any(val_img_list) or img_val is not None:
-        img_val, label_val, _, _, _, _, _ = load_training_data(bm.normalize,
+        img_val, label_val, _, _, _, _, _ = load_training_data(bm, bm.normalize,
                     val_img_list, val_label_list, bm.channels, bm.x_scale, bm.y_scale, bm.z_scale, bm.scaling, bm.crop_data,
                     bm.only, bm.ignore, img_val, label_val, normalization_parameters, allLabels)
 
@@ -817,7 +822,13 @@ def train_semantic_segmentation(bm,
         for k in range(0, zsh-bm.z_patch+1, bm.stride_size):
             for l in range(0, ysh-bm.y_patch+1, bm.stride_size):
                 for m in range(0, xsh-bm.x_patch+1, bm.stride_size):
-                    list_IDs_fg.append(k*ysh*xsh+l*xsh+m)
+                    if bm.separation:
+                        centerLabel = label[k+bm.z_patch//2,l+bm.y_patch//2,m+bm.x_patch//2]
+                        patch = label[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+                        if centerLabel>0 and np.any(patch!=centerLabel):
+                            list_IDs_fg.append(k*ysh*xsh+l*xsh+m)
+                    else:
+                        list_IDs_fg.append(k*ysh*xsh+l*xsh+m)
 
     if img_val is not None:
 
@@ -840,7 +851,13 @@ def train_semantic_segmentation(bm,
             for k in range(0, zsh_val-bm.z_patch+1, bm.validation_stride_size):
                 for l in range(0, ysh_val-bm.y_patch+1, bm.validation_stride_size):
                     for m in range(0, xsh_val-bm.x_patch+1, bm.validation_stride_size):
-                        list_IDs_val_fg.append(k*ysh_val*xsh_val+l*xsh_val+m)
+                        if bm.separation:
+                            centerLabel = label_val[k+bm.z_patch//2,l+bm.y_patch//2,m+bm.x_patch//2]
+                            patch = label_val[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+                            if centerLabel>0 and np.any(patch!=centerLabel):
+                                list_IDs_val_fg.append(k*ysh_val*xsh_val+l*xsh_val+m)
+                        else:
+                            list_IDs_val_fg.append(k*ysh_val*xsh_val+l*xsh_val+m)
 
     # number of labels
     nb_labels = len(allLabels)
@@ -855,7 +872,8 @@ def train_semantic_segmentation(bm,
               'n_classes': nb_labels,
               'n_channels': bm.channels,
               'augment': (bm.flip_x, bm.flip_y, bm.flip_z, bm.swapaxes, bm.rotate),
-              'patch_normalization': bm.patch_normalization}
+              'patch_normalization': bm.patch_normalization,
+              'separation': bm.separation}
 
     # data generator
     validation_generator = None
@@ -1037,6 +1055,23 @@ def append_ghost_areas(bm, img):
         img = np.append(img, img[:,:,-x_rest:][:,:,::-1], axis=2)
     return img, z_rest, y_rest, x_rest
 
+def gradient(volData):
+    grad = np.zeros(volData.shape, dtype=np.uint8)
+    tmp = np.abs(volData[:-1] - volData[1:])
+    tmp[tmp>0]=1
+    grad[:-1] += tmp
+    grad[1:] += tmp
+    tmp = np.abs(volData[:,:-1] - volData[:,1:])
+    tmp[tmp>0]=1
+    grad[:,:-1] += tmp
+    grad[:,1:] += tmp
+    tmp = np.abs(volData[:,:,:-1] - volData[:,:,1:])
+    tmp[tmp>0]=1
+    grad[:,:,:-1] += tmp
+    grad[:,:,1:] += tmp
+    grad[grad>0]=1
+    return grad
+
 def predict_semantic_segmentation(bm,
     header, img_header,
     region_of_interest, extension, img_data,
@@ -1072,6 +1107,13 @@ def predict_semantic_segmentation(bm,
         zsh = len(tif.pages)
         ysh, xsh = tif.pages[0].shape
 
+        # load mask
+        if bm.separation or bm.refinement:
+            mask, _ = load_data(bm.mask)
+            mask = mask.reshape(zsh, ysh, xsh, 1)
+            mask, _, _, _ = append_ghost_areas(bm, mask)
+            mask = mask.reshape(mask.shape[:-1])
+
         # determine new image size after appending ghost areas to make image dimensions divisible by patch size
         z_rest = bm.z_patch - (zsh % bm.z_patch)
         if z_rest == bm.z_patch:
@@ -1094,9 +1136,20 @@ def predict_semantic_segmentation(bm,
         for k in range(0, zsh-bm.z_patch+1, bm.stride_size):
             for l in range(0, ysh-bm.y_patch+1, bm.stride_size):
                 for m in range(0, xsh-bm.x_patch+1, bm.stride_size):
-                    list_IDs.append(k*ysh*xsh+l*xsh+m)
+                    if bm.separation:
+                        centerLabel = mask[k+bm.z_patch//2,l+bm.y_patch//2,m+bm.x_patch//2]
+                        patch = mask[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+                        if centerLabel>0 and np.any(patch!=centerLabel):
+                            list_IDs.append(k*ysh*xsh+l*xsh+m)
+                    elif bm.refinement:
+                        patch = mask[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+                        if np.any(patch==0) and np.any(patch!=0):
+                            list_IDs.append(k*ysh*xsh+l*xsh+m)
+                    else:
+                        list_IDs.append(k*ysh*xsh+l*xsh+m)
 
         # make length of list divisible by batch size
+        max_i = len(list_IDs)
         rest = bm.batch_size - (len(list_IDs) % bm.batch_size)
         list_IDs = list_IDs + list_IDs[:rest]
 
@@ -1184,27 +1237,37 @@ def predict_semantic_segmentation(bm,
                 img, _, _, _ = append_ghost_areas(bm, img)
 
             # list of IDs
-            list_IDs = []
+            list_IDs_block = []
 
             # get Ids of patches
             for l in range(0, ysh-bm.y_patch+1, bm.stride_size):
                 for m in range(0, xsh-bm.x_patch+1, bm.stride_size):
-                    list_IDs.append(z*ysh*xsh+l*xsh+m)
+                    if bm.separation:
+                        centerLabel = mask[z+bm.z_patch//2,l+bm.y_patch//2,m+bm.x_patch//2]
+                        patch = mask[z:z+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+                        if centerLabel>0 and np.any(patch!=centerLabel):
+                            list_IDs_block.append(z*ysh*xsh+l*xsh+m)
+                    elif bm.refinement:
+                        patch = mask[z:z+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+                        if np.any(patch==0) and np.any(patch!=0):
+                            list_IDs_block.append(z*ysh*xsh+l*xsh+m)
+                    else:
+                        list_IDs_block.append(z*ysh*xsh+l*xsh+m)
 
             # make length of list divisible by batch size
-            max_i = len(list_IDs)
-            rest = bm.batch_size - (len(list_IDs) % bm.batch_size)
-            list_IDs = list_IDs + list_IDs[:rest]
+            max_i_block = len(list_IDs_block)
+            rest = bm.batch_size - (len(list_IDs_block) % bm.batch_size)
+            list_IDs_block = list_IDs_block + list_IDs_block[:rest]
 
             # number of patches
-            nb_patches = len(list_IDs)
+            nb_patches = len(list_IDs_block)
 
             # allocate tmp probabilities array
             probs = np.zeros((bm.z_patch, ysh, xsh, nb_labels), dtype=np.float32)
 
             # get one batch of image patches
             for step in range(nb_patches//bm.batch_size):
-                for i, ID in enumerate(list_IDs[step*bm.batch_size:(step+1)*bm.batch_size]):
+                for i, ID in enumerate(list_IDs_block[step*bm.batch_size:(step+1)*bm.batch_size]):
 
                     # get patch indices
                     k=0 if load_blockwise else ID // (ysh*xsh)
@@ -1225,29 +1288,46 @@ def predict_semantic_segmentation(bm,
                 Y = model.predict(X, verbose=0, steps=None, batch_size=bm.batch_size)
 
                 # loop over result patches
-                for i, ID in enumerate(list_IDs[step*bm.batch_size:(step+1)*bm.batch_size]):
+                for i, ID in enumerate(list_IDs_block[step*bm.batch_size:(step+1)*bm.batch_size]):
                     rest = ID % (ysh*xsh)
                     l = rest // xsh
                     m = rest % xsh
-                    if step*bm.batch_size+i < max_i:
-                        probs[:,l:l+bm.y_patch,m:m+bm.x_patch] += Y[i]
-
-            # overlap in z direction
-            if bm.stride_size < bm.z_patch:
-                if j>0:
-                    probs[:bm.stride_size] += overlap
-                overlap = probs[bm.stride_size:].copy()
-
-            # calculate result
-            if z==z_indices[-1]:
-                label[z:z+bm.z_patch] = np.argmax(probs, axis=-1).astype(np.uint8)
-                if bm.return_probs:
-                    final[z:z+bm.z_patch] = probs
-            else:
-                block_zsh = min(bm.stride_size, bm.z_patch)
-                label[z:z+block_zsh] = np.argmax(probs[:block_zsh], axis=-1).astype(np.uint8)
-                if bm.return_probs:
-                    final[z:z+block_zsh] = probs[:block_zsh]
+                    if step*bm.batch_size+i < max_i_block:
+                        if bm.separation:
+                            patch = np.argmax(Y[i], axis=-1).astype(np.uint8)
+                            label[z:z+bm.z_patch,l:l+bm.y_patch,m:m+bm.x_patch] += gradient(patch)
+                        else:
+                            probs[:,l:l+bm.y_patch,m:m+bm.x_patch] += Y[i]
+
+            if not bm.separation:
+                # overlap in z direction
+                if bm.stride_size < bm.z_patch:
+                    if j>0:
+                        probs[:bm.stride_size] += overlap
+                    overlap = probs[bm.stride_size:].copy()
+
+                # calculate result
+                if z==z_indices[-1]:
+                    label[z:z+bm.z_patch] = np.argmax(probs, axis=-1).astype(np.uint8)
+                    if bm.return_probs:
+                        final[z:z+bm.z_patch] = probs
+                else:
+                    block_zsh = min(bm.stride_size, bm.z_patch)
+                    label[z:z+block_zsh] = np.argmax(probs[:block_zsh], axis=-1).astype(np.uint8)
+                    if bm.return_probs:
+                        final[z:z+block_zsh] = probs[:block_zsh]
+
+    # refine mask data with result
+    if bm.refinement:
+        # loop over boundary patches
+        for i, ID in enumerate(list_IDs):
+            if i < max_i:
+                k = ID // (ysh*xsh)
+                rest = ID % (ysh*xsh)
+                l = rest // xsh
+                m = rest % xsh
+                mask[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch] = label[k:k+bm.z_patch, l:l+bm.y_patch, m:m+bm.x_patch]
+        label = mask
 
     # remove appendix
     if bm.return_probs:
@@ -1287,7 +1367,8 @@ def predict_semantic_segmentation(bm,
         label = np.copy(tmp, order='C')
 
     # get result
-    label = get_labels(label, bm.allLabels)
+    if not bm.separation:
+        label = get_labels(label, bm.allLabels)
     results['regular'] = label
 
     # load header from file

{biomedisa-24.8.1 → biomedisa-24.8.2}/src/biomedisa.egg-info/PKG-INFO

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