def test_labels_query_all_or_tot_input():
v = np.arange(10).reshape(5, 2)
lab, lab_names = labels_query('all', v, remove_zero=False)
assert_array_equal(lab, np.arange(10))
lab, lab_names = labels_query('tot', v, remove_zero=False)
assert_array_equal(lab, np.arange(10))
lab, lab_names = labels_query('tot', v, remove_zero=True)
assert_array_equal(lab, np.arange(10)[1:])
def dist(self,
segm_1_filename,
segm_2_filename,
labels_list=None,
labels_names=None,
metrics=(dice_score, covariance_distance, hausdorff_distance,
normalised_symmetric_contour_distance),
where_to_save=None):
pfi_segm1 = connect_path_tail_head(self.pfo_in, segm_1_filename)
pfi_segm2 = connect_path_tail_head(self.pfo_in, segm_2_filename)
assert os.path.exists(pfi_segm1), pfi_segm1
assert os.path.exists(pfi_segm2), pfi_segm2
if self.verbose > 0:
print(
"Distances between segmentations: \n -> {0} \n -> {1} \n...started!"
.format(pfi_segm1, pfi_segm2))
im_segm1 = nib.load(pfi_segm1)
im_segm2 = nib.load(pfi_segm2)
if labels_list is None:
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_list.sort(key=int)
labels_names = None
if labels_names is None:
labels_names = labels_list
dict_distances_per_label = {}
for d in metrics:
if self.verbose > 0:
print('{} computation started'.format(d.func_name))
pa_se = d(
im_segm1, im_segm2, labels_list, labels_names, self.return_mm3
) # TODO get as function with variable number of arguments
dict_distances_per_label.update({d.func_name: pa_se})
df_distances_per_label = pa.DataFrame(
dict_distances_per_label, columns=dict_distances_per_label.keys())
# df_distances_per_label.loc['mean'] = df_distances_per_label.mean()
# df_distances_per_label.loc['std'] = df_distances_per_label.std()
if self.verbose > 0:
print(df_distances_per_label)
if where_to_save is not None:
pfi_output_table = connect_path_tail_head(self.pfo_out,
where_to_save)
df_distances_per_label.to_pickle(pfi_output_table)
return df_distances_per_label
def normalise_below_label(self,
filename_image_in,
filename_image_out,
filename_segm,
labels,
stats=np.median):
"""
:param filename_image_in: path to image input
:param filename_image_out: path to image output
:param filename_segm: path to segmentation
:param labels: list of labels below which the voxels are collected
:param stats: a statistics (by default the median).
:return: a new image with the intensites normalised according to the proposed statistics computed on the
intensities below the provided labels.
"""
pfi_in, pfi_out = get_pfi_in_pfi_out(filename_image_in,
filename_image_out, self.pfo_in,
self.pfo_out)
pfi_segm = connect_path_tail_head(self.pfo_in, filename_segm)
im_input = nib.load(pfi_in)
im_segm = nib.load(pfi_segm)
labels_list, labels_names = labels_query(labels, im_segm.get_data())
im_out = normalise_below_labels(im_input,
labels_list,
labels,
stats=stats,
exclude_first_label=True)
nib.save(im_out, pfi_out)
def volume(self,
segmentation_filename,
labels=None,
tot_volume_prior=None,
where_to_save=None):
"""
:param segmentation_filename: filename of the segmentation S.
:param labels: list of labels, multi-labels (as sublists, e.g. left right will be considered one label)
:param tot_volume_prior: as an intra-cranial volume factor.
:param where_to_save:
:return:
"""
pfi_segm = connect_path_tail_head(self.pfo_in, segmentation_filename)
assert os.path.exists(pfi_segm), pfi_segm
im_segm = nib.load(pfi_segm)
labels_list, labels_names = labels_query(labels, im_segm.get_data())
df_volumes_per_label = get_volumes_per_label(
im_segm,
labels=labels_list,
labels_names=labels_names,
tot_volume_prior=tot_volume_prior,
verbose=self.verbose)
if self.verbose > 0:
print(df_volumes_per_label)
if where_to_save is not None:
pfi_output_table = connect_path_tail_head(self.pfo_out,
where_to_save)
df_volumes_per_label.to_pickle(pfi_output_table)
return df_volumes_per_label
def values_below_labels(self,
segmentation_filename,
anatomy_filename,
labels=None):
"""
:param segmentation_filename:
:param anatomy_filename:
:param labels:
:return: pandas series with label names and corresponding vectors of labels values
"""
pfi_anat = connect_path_tail_head(self.pfo_in, anatomy_filename)
pfi_segm = connect_path_tail_head(self.pfo_in, segmentation_filename)
assert os.path.exists(pfi_anat)
assert os.path.exists(pfi_segm)
im_anat = nib.load(pfi_anat)
im_segm = nib.load(pfi_segm)
labels_list, labels_names = labels_query(
labels, segmentation_array=im_segm.get_data())
labels_values = get_values_below_labels_list(im_segm, im_anat,
labels_list)
return pa.Series(labels_values, index=labels_names)
def test_labels_query_list_input2():
lab, lab_names = labels_query([1, 2, 3, [4, 5, 6]])
assert_array_equal(lift_list(lab), lift_list([1, 2, 3, [4, 5, 6]]))
assert_array_equal(lab_names, ['1', '2', '3', '[4, 5, 6]'])
def test_labels_query_list_input1():
lab, lab_names = labels_query([1, 2, 3])
assert_array_equal(lab, [1, 2, 3])
assert_array_equal(lab_names, ['1', '2', '3'])
def test_labels_query_int_input():
lab, lab_names = labels_query(1)
assert_array_equal(lab, [1])
assert_array_equal(lab_names, ['1'])
