BUG labels measurement not updated in examples

Author: SebastianoF

LABelsToolkit/agents/measurer.py

@@ -98,9 +98,8 @@ def dist(self, segm_1_filename, segm_2_filename, labels_list=None, labels_names=
             labels_list1, labels_names1 = labels_query('all', im_segm1.get_data())
             labels_list2, labels_names2 = labels_query('all', im_segm2.get_data())
             labels_list  = list(set(labels_list1) & set(labels_list2))
-            labels_names = list(set(labels_names1) & set(labels_names2))
             labels_list.sort(key=int)
-            labels_names.sort(key=int)
+            labels_names = None
 
         if labels_names is None:
             labels_names = labels_list

LABelsToolkit/tools/caliber/volumes_and_values.py

@@ -85,180 +85,56 @@ def get_values_below_labels_list(im_seg, im_anat, labels_list):
 #  ---- Second part ----
 
 
-
 def get_volumes_per_label(im_segm, labels, labels_names, tot_volume_prior=None, verbose=0):
     """
+    Get a separate volume for each label in a data-frame
     :param im_segm:
     :param labels:
     :param labels_names: index of labels in the final dataframes.
     :param tot_volume_prior:
     :param verbose:
     :return:
     """
-    num_voxels = get_total_num_nonzero_voxels(im_segm)
-    vol_mm3 = num_voxels * one_voxel_volume(im_segm)
+    num_non_zero_voxels = get_total_num_nonzero_voxels(im_segm)
+    vol_non_zero_voxels_mm3 = num_non_zero_voxels * one_voxel_volume(im_segm)
     if tot_volume_prior is None:
-        tot_volume_prior = 1
-    if tot_volume_prior == 'tot':
-        tot_volume_prior = vol_mm3
-
+        tot_volume_prior = vol_non_zero_voxels_mm3
     if labels_names == 'tot':
 
         data_frame = pa.DataFrame({'Labels': pa.Series(labels, index=[labels_names]),
-                                   'Num voxels': pa.Series(num_voxels, index=[labels_names]),
-                                   'Volume': pa.Series(vol_mm3, index=[labels_names]),
-                                   'Vol over Tot': pa.Series(vol_mm3 / tot_volume_prior, index=[labels_names])})
-
-    else:
-        all_places = np.zeros_like(im_segm.get_data(), dtype=np.bool)
-        for label_k in labels:
-            if isinstance(label_k, int):
-                all_places += im_segm.get_data() == label_k
-            else:
-                for label_k_j in label_k:
-                    all_places += im_segm.get_data() == label_k_j
-
-        flat_volume_voxel = np.nan_to_num( (all_places.astype(np.float64)).flatten() )
-
-        non_zero_voxels = np.count_nonzero(flat_volume_voxel)
-        volumes = non_zero_voxels * one_voxel_volume(im_segm)
-        if tot_volume_prior is None:
-            num_voxels = get_total_num_nonzero_voxels(im_segm)
-            tot_volume_prior = num_voxels * one_voxel_volume(im_segm)
-
-        vol_over_tot = volumes / float(tot_volume_prior)
-
-        data_frame = pa.DataFrame({'Labels': pa.Series(labels, index=labels_names),
-                                   'Num voxels': pa.Series(non_zero_voxels, index=labels_names),
-                                   'Volume': pa.Series(volumes, index=labels_names),
-                                   'Vol over Tot': pa.Series(vol_over_tot, index=labels_names)})
-    if verbose > 0:
-        print(data_frame)
-
-    return data_frame
+                                   'Num voxels': pa.Series(num_non_zero_voxels, index=[labels_names]),
+                                   'Volume': pa.Series(vol_non_zero_voxels_mm3, index=[labels_names]),
+                                   'Vol over Tot': pa.Series(vol_non_zero_voxels_mm3 / tot_volume_prior, index=[labels_names])})
 
-
-#  ---- DUMP ----
-'''
-
-def se_values_below_labels(im_seg, im_anat, labels_list, labels_names=None):
-    """
-
-    :param im_seg: image segmentation
-    :param im_anat: image anatomy
-    :param labels_list: integer, list of labels [l1, l2, ..., ln], or list of list of labels if labels needs to be
-    considered together.
-    e.g. labels_list = [1,2,[3,4]] -> values below label 1, values below label 2, values below label 3 and 4.
-    :return: list of numpy arrays, each element is the flat array of the values below the labels
-    """
-    values = []
-    for label_k in labels_list:
-        # TODO: optimise with np.where after testing
-        if isinstance(label_k, int):
-            all_places += im_seg.get_data() == label_k
-        else:
-            all_places = np.zeros_like(im_seg.get_data(), dtype=np.bool)
-            for label_k_j in label_k:
-                all_places += im_seg.get_data() == label_k_j
-
-        masked_scalar_data = np.nan_to_num(
-            (all_places.astype(np.float64) * im_anat.get_data().astype(np.float64)).flatten())
-        # remove zero elements from the array:
-        non_zero_masked_scalar_data = masked_scalar_data[np.where(masked_scalar_data > 1e-6)]  # 1e-6
-
-        if non_zero_masked_scalar_data.size == 0:  # if not non_zero_masked_scalar_data is an empty array.
-            non_zero_masked_scalar_data = 0.
-
-        values.append(non_zero_masked_scalar_data)
-    if labels_names is None:
-        return values
     else:
-        return pa.Series(values, index=labels_names)
-
-
-def from_values_below_labels_to_mu_std(values_below_labels, labels, labels_names, verbose=0):
-    """
+        non_zero_voxels_list = []
+        volumes_list = []
+        vol_over_tot_list = []
 
-    :param values_below_labels: output of values_below_labels
-    :param labels:
-    :param labels_names:
-    :param verbose:
-    :return:
-    """
-    data_frame = pa.DataFrame({'Labels'              : pa.Series(labels, index=labels_names),
-                               'Average below label' : pa.Series([np.mean(v) for v in values_below_labels], index=labels_names),
-                               'Std below label'     : pa.Series([np.std(v) for v in values_below_labels], index=labels_names)})
-
-    if verbose > 0:
-        print(data_frame)
-
-    return data_frame
-
-
-def get_volumes_per_label(im_segm, labels, labels_names, tot_volume_prior=None, verbose=0):
-    """
-    :param im_segm:
-    :param labels:
-    :param labels_names: index of labels in the final dataframes.
-    :param tot_volume_prior:
-    :param verbose:
-    :return:
-    """
-    num_voxels, vol_mm3 = get_total_volume(im_segm)
-    if tot_volume_prior is None:
-        tot_volume_prior = 1
-    if tot_volume_prior == 'tot':
-        tot_volume_prior = vol_mm3
-
-    if labels_names == 'tot':
-
-        data_frame = pa.DataFrame({'Labels': pa.Series(labels, index=[labels_names]),
-                                   'Num voxels': pa.Series(num_voxels, index=[labels_names]),
-                                   'Volume': pa.Series(vol_mm3, index=[labels_names]),
-                                   'Vol over Tot': pa.Series(vol_mm3 / tot_volume_prior, index=[labels_names])})
-
-    else:
-        all_places = np.zeros_like(im_segm.get_data(), dtype=np.bool)
         for label_k in labels:
+            all_places = np.zeros_like(im_segm.get_data(), dtype=np.bool)
             if isinstance(label_k, int):
                 all_places += im_segm.get_data() == label_k
             else:
                 for label_k_j in label_k:
                     all_places += im_segm.get_data() == label_k_j
 
-        flat_volume_voxel = np.nan_to_num( (all_places.astype(np.float64)).flatten() )
+            flat_volume_voxel = np.nan_to_num((all_places.astype(np.float64)).flatten() )
 
-        non_zero_voxels = np.count_nonzero(flat_volume_voxel)
-        volumes = non_zero_voxels * one_voxel_volume(im_segm)
-        if tot_volume_prior is None:
-            tot_volume_prior = get_total_volume(im_segm, labels_to_exclude=[0])[1]
+            non_zero_voxels = np.count_nonzero(flat_volume_voxel)
+            volumes = non_zero_voxels * one_voxel_volume(im_segm)
 
-        vol_over_tot = volumes / float(tot_volume_prior)
+            vol_over_tot = volumes / float(tot_volume_prior)
+
+            non_zero_voxels_list.append(non_zero_voxels)
+            volumes_list.append(volumes)
+            vol_over_tot_list.append(vol_over_tot)
 
         data_frame = pa.DataFrame({'Labels': pa.Series(labels, index=labels_names),
-                                   'Num voxels': pa.Series(non_zero_voxels, index=labels_names),
-                                   'Volume': pa.Series(volumes, index=labels_names),
-                                   'Vol over Tot': pa.Series(vol_over_tot, index=labels_names)})
+                                   'Num voxels': pa.Series(non_zero_voxels_list, index=labels_names),
+                                   'Volume': pa.Series(volumes_list, index=labels_names),
+                                   'Vol over Tot': pa.Series(vol_over_tot_list, index=labels_names)})
     if verbose > 0:
         print(data_frame)
 
     return data_frame
-
-
-def get_mu_std_below_labels(im_segm, im_anatomical, labels, labels_names, verbose=0):
-    """
-
-    :param im_anatomical:
-    :param im_segm:
-    :param labels: can be an integer, or a list.
-     If it is a list, it can contain sublists.
-     If labels are in the sublist, volumes will be computed for all the labels in the list.
-    e.g. [1,2,[3,4]] -> volume of label 1, volume of label 2, volume of label 3 and 4.
-    :param labels_names:
-    :param verbose:
-    :return:
-    """
-    values_below_labels = get_values_below_labels(im_segm, im_anatomical, labels)
-    df = from_values_below_labels_to_mu_std(values_below_labels, labels, labels_names, verbose=verbose)
-    return df
-'''

LABelsToolkit/tools/phantoms_generator/generate_phantom_multi_atlas.py

@@ -7,9 +7,10 @@
 
 from LABelsToolkit.tools.aux_methods.utils import print_and_run
 from LABelsToolkit.tools.phantoms_generator.shapes_for_phantoms import sphere_shape
-from LABelsToolkit.tools.visualiser.see_volume import see_array
 from LABelsToolkit.tools.phantoms_generator.shapes_for_headlike_phantoms import headlike_phantom
 
+from LABelsToolkit.tools.visualiser.see_volume import see_array
+
 
 def generate_atlas_at_folder(pfo_where_to_save_atlas, atlas_name='test', randomness_shape=0.3, randomness_noise=0.4):
 
@@ -49,14 +50,14 @@ def generate_atlas_at_folder(pfo_where_to_save_atlas, atlas_name='test', randomn
     mod_inv_noise = mod_inv + noise_array
 
     # -- add hypo-intensities artefacts:
-    num_artefacts_per_type = int(10 * randomness_noise / 2)
+    num_spots = int(10 * randomness_noise / 2)
     noise_hypo = np.zeros_like(noise_array).astype(np.int32)
-    for j in range(num_artefacts_per_type):
-        random_radius = 0.05 * randomness_noise * np.min(omega) *np.random.randn()  # 5% of the min direction
+    for j in range(num_spots):
+        radius_centre = 0.05 * randomness_noise * np.min(omega)
+        random_radius = np.random.uniform(radius_centre - radius_centre/2, radius_centre + radius_centre/2)  # 5% of the min direction
         random_centre = [np.random.uniform(0 + random_radius, j - random_radius) for j in omega]
 
         noise_hypo = noise_hypo + sphere_shape(omega, random_centre, random_radius, foreground_intensity=1, dtype=np.int32)
-    see_array(noise_hypo, block=True)
 
     noise_hypo = 1 - 1 * (noise_hypo.astype(np.bool))
     # filter the results:
@@ -66,8 +67,6 @@ def generate_atlas_at_folder(pfo_where_to_save_atlas, atlas_name='test', randomn
     # D) Get the Registration Mask (based on):
     reg_mask = noise_hypo * roi_mask
 
-    see_array([mod_gt, segm_gt, roi_mask.astype(np.int32), reg_mask.astype(np.int32), mod_gt_noise, mod_inv_noise])
-
     # E) save all in the data structure
     im_segm_gt  = nib.Nifti1Image(segm_gt, affine=np.eye(4))
     im_mod_gt   = nib.Nifti1Image(mod_gt, affine=np.eye(4))
@@ -97,30 +96,15 @@ def generate_multi_atlas_at_folder(pfo_where_to_create_the_multi_atlas, number_o
     :param randomness_noise: randomness in the simulated noise signal and artefacts. Must be between 0 and 1.
     :return:
     """
-    print_and_run('mkdir -p {}'.format(pfo_where_to_create_the_multi_atlas))
-
+    print_and_run('mkdir {}'.format(pfo_where_to_create_the_multi_atlas))
     for sj in range(number_of_subjects):
-
-        # A) Generate folder structure
-        sj_name = multi_atlas_root_name + str(sj).zfill(len(str(number_of_subjects)) + 1)
-
+        sj_name = multi_atlas_root_name + str(sj + 1).zfill(len(str(number_of_subjects)) + 1)
         print('Creating atlas {0} ({1}/{2})'.format(sj_name, sj+1, number_of_subjects))
+        print_and_run('mkdir {}'.format(jph(pfo_where_to_create_the_multi_atlas, sj_name)))
         generate_atlas_at_folder(jph(pfo_where_to_create_the_multi_atlas, sj_name), atlas_name=sj_name,
                                  randomness_shape=randomness_shape, randomness_noise=randomness_noise)
 
-
-
 if __name__ == '__main__':
-    omega = (80, 90, 80)
-    # noise1 = np.random.choice(range(10), size=omega).astype(np.float64)
-    # noise2 = fil.gaussian_filter(noise1, 5)
-    # print np.mean(noise2)
-    # print np.std(noise2)
-    # noise3 = noise2 / (np.mean(noise2) + 2 * np.std(noise2))
-    # see_array([noise1, noise2, noise3])
-
-    # noise_array = np.random.uniform(-10, 10, size=omega).astype(np.float64)
-    # noise_array = 0.2 * 0.4 * fil.gaussian_filter(noise_array, 3)
-    # see_array(noise_array)
-    #
-    generate_atlas_at_folder('/Users/sebastiano/Desktop/z_test_phantom_atlas', randomness_noise=1)
+    # test
+    generate_multi_atlas_at_folder('/Users/sebastiano/Desktop/z_test_phantom_atlas', number_of_subjects=3,
+                                   randomness_noise=1, randomness_shape=1)

examples/caliber_usage_distances_example.py

@@ -1,7 +1,7 @@
 import os
 from os.path import join as jph
 
-from LABelsToolkit.main import LABelsToolkit as LM
+from LABelsToolkit.main import LABelsToolkit as LT
 from LABelsToolkit.tools.caliber.distances import dice_score, covariance_distance, hausdorff_distance
 from LABelsToolkit.tools.defs import root_dir
 
@@ -14,7 +14,7 @@
     where_to_save = None
 
     # Instantiate a Labels Manager class
-    m = LM()
+    m = LT()
     m.measure.return_mm3 = False
 
     # get the measure

examples/caliber_usage_example.py

@@ -1,5 +1,6 @@
 import os
 from os.path import join as jph
+import numpy as np
 
 from LABelsToolkit.main import LABelsToolkit as LT
 from LABelsToolkit.tools.defs import root_dir
@@ -25,43 +26,35 @@
 
     # Get volumes per label:
     print('The 4 cubes of sides 11, 17, 19 and 9 are labelled 1, 2, 3 and 4 resp.:')
-    print('Volume measured label 1        = {}'.format( m.measure.volume(pfi_im, labels=1)['Volume'].values) )
+    print('Volume measured label 1        = {}'.format(m.measure.volume(pfi_im, labels=1)['Volume'].values))
     print('11**3                          = {}'.format(11 ** 3))
-    print('Volume measured label 2        = {}'.format( m.measure.volume(pfi_im, labels=2)['Volume'].values) )
+    print('Volume measured label 2        = {}'.format(m.measure.volume(pfi_im, labels=2)['Volume'].values))
     print('17**3                          = {}'.format(17 ** 3))
-    print('Volume measured label 3        = {}'.format( m.measure.volume(pfi_im, labels=3)['Volume'].values) )
+    print('Volume measured label 3        = {}'.format(m.measure.volume(pfi_im, labels=3)['Volume'].values))
     print('19**3                          = {}'.format(19 ** 3))
-    print('Volume measured label 4        = {}'.format( m.measure.volume(pfi_im, labels=4)['Volume'].values) )
+    print('Volume measured label 4        = {}'.format(m.measure.volume(pfi_im, labels=4)['Volume'].values))
     print('9**3                           = {}'.format(9 ** 3))
-    print('Volume measured labels ([1, 3]) = {}'.format( m.measure.volume(pfi_im,
-                                                                          labels=[[1, 3]])['Volume'].values) )
-    print('11* 3 +  19**3                  = {}'.format(11**3 + 19**3))
+    print('Volume measured labels ([1, 3]) = {}'.format(m.measure.volume(pfi_im, labels=[[1, 3]])['Volume'].values))
+    print('11**3 +  19**3                  = {}'.format(11**3 + 19**3))
     print('\nTo sum up: \n')
     print('Volume measured labels ([1, 2, 3, 4, [1, 3]]) = \n{}\n'.format(
-        m.measure.volume(pfi_im, labels=[1,2, 3, 4, [1, 3]])
-        ))
+        m.measure.volume(pfi_im, labels=[1, 2, 3, 4, [1, 3], [1, 2, 3, 4]])))
+    print('Total volume = {} \n'.format(m.measure.get_total_volume(pfi_im)))
+
 
     print('------------')
 
     # Get volumes under each label, given the image weight, corresponding to the label itself:
-    print('average below label 1 = {}'.format( m.measure.volume(pfi_im, anatomy_filename=pfi_im, labels=1)['Average below label'].values) )
-    print('11**3 * 1  / 11**3    = {}'.format(11 ** 3 * 1/ float(11**3) ))
-    print('average below label 2 = {}'.format( m.measure.volume(pfi_im, anatomy_filename=pfi_im, labels=2)['Average below label'].values) )
-    print('17**3  * 2 / 17 ** 3  = {}'.format(17 ** 3 * 2 / float(17 ** 3)))
-    print('average below label 3 = {}'.format( m.measure.volume(pfi_im, anatomy_filename=pfi_im, labels=3)['Average below label'].values) )
-    print('19**3 * 3/ 19 ** 3    = {}'.format(19 ** 3 * 3 / float(19 ** 3)))
-    print('average below label 4 = {}'.format( m.measure.volume(pfi_im, anatomy_filename=pfi_im, labels=4)['Average below label'].values) )
-    print('9**3 * 4 / 9 ** 3     = {}'.format(9 ** 3 * 4 / float(9 ** 3)))
-    print('average below labels [1,3]                = {}'.format(
-        m.measure.volume(pfi_im, anatomy_filename=pfi_im, labels=[1,3])['Average below label'].values)
-    )
-    print('11**3 * 1  / 11**3,  19**3 * 3/ 19 ** 3   = {}'.format([11 ** 3 * 1 / float(11 ** 3),
-                                                                    19 ** 3 * 3 / float(19 ** 3)]))
-    print('average below labels [[1, 3]]   = {}'.format(
-        m.measure.volume(pfi_im, anatomy_filename=pfi_im, labels=[[1,3]])['Average below label'].values)
-    )
-    print('( 11**3 * 1 +19**3 * 3 ) / (11**3 + 19 ** 3) = {0}'.format( (11**3 * 1 +19**3 * 3) / float(11**3 + 19 ** 3)))
-    print('\n\nTo sum up: \n')
-    print('average below labels [1, 2, 3, 4, [1, 3]] = \n{}'.format(
-        m.measure.volume(pfi_im, anatomy_filename=pfi_im, labels=[1, 2, 3, 4, [1, 3]] ))
-    )
+    vals_below_labels = m.measure.values_below_labels(pfi_im, pfi_im, labels=[1, 2, 3, 4, 5, [1, 3]])
+
+    print('average below labels [1, 2, 3, 4, [1, 3]] = \n{}'.format(vals_below_labels))
+
+    print('mu, std below label 1 = {} {}'.format(np.mean(vals_below_labels['1']), np.std(vals_below_labels['1'])))
+    print('mu, std below label 2 = {} {}'.format(np.mean(vals_below_labels['2']), np.std(vals_below_labels['2'])))
+    print('mu, std below label 3 = {} {}'.format(np.mean(vals_below_labels['3']), np.std(vals_below_labels['3'])))
+    print('mu, std below label 4 = {} {}'.format(np.mean(vals_below_labels['4']), np.std(vals_below_labels['4'])))
+    # print('mu, std below label 5 = {} {}'.format(np.mean(vals_below_labels['5']), np.std(vals_below_labels['5'])))
+    print('mu, std below label [1, 3] = {} {}'.format(np.mean(vals_below_labels['[1, 3]']), np.std(vals_below_labels['[1, 3]'])))
+
+    print('\nValues as they are reported: {}'.format(vals_below_labels))
+

examples/icv_estimation_example.py

@@ -1 +1 @@
-# Wip
+# TODO