def _save_current_image(self, image_out, resize_to):
if self.input_image is None:
return
window_shape = resize_to
while image_out.ndim < 5:
image_out = image_out[..., np.newaxis, :]
if self.window_border and any([b > 0 for b in self.window_border]):
np_border = self.window_border
while len(np_border) < 5:
np_border = np_border + (0, )
np_border = [(b, ) for b in np_border]
image_out = np.pad(image_out, np_border, mode='edge')
image_shape = image_out.shape
zoom_ratio = \
[float(p) / float(d) for p, d in zip(window_shape, image_shape)]
image_shape = list(image_shape[:3]) + [1, image_shape[-1]]
image_out = np.reshape(image_out, image_shape)
image_out = zoom_3d(image=image_out,
ratio=zoom_ratio,
interp_order=self.output_interp_order)
for layer in reversed(self.reader.preprocessors):
if isinstance(layer, PadLayer):
image_out, _ = layer.inverse_op(image_out)
if isinstance(layer, DiscreteLabelNormalisationLayer):
image_out, _ = layer.inverse_op(image_out)
subject_name = self.reader.get_subject_id(self.image_id)
filename = "{}{}.nii.gz".format(subject_name, self.postfix)
source_image_obj = self.input_image[self.name]
misc_io.save_data_array(self.output_path, filename, image_out,
source_image_obj, self.output_interp_order)
self.log_inferred(subject_name, filename)
return
def _save_current_image(self, idx, filename, image):
if image is None:
return
uniq_name = "{}_{}{}.nii.gz".format(idx, filename, self.prefix)
misc_io.save_data_array(self.output_path, uniq_name, image, None)
with open(self.inferred_csv, 'a') as csv_file:
filename = os.path.join(self.output_path, filename)
csv_file.write('{},{}\n'.format(idx, uniq_name))
return
def _save_current_image(self, idx, filename, image):
if image is None:
return
uniq_name = "{}_{}{}.nii.gz".format(idx, filename, self.prefix)
misc_io.save_data_array(self.output_path, uniq_name, image, None)
with open(self.inferred_csv, 'a') as csv_file:
filename = os.path.join(self.output_path, filename)
csv_file.write('{},{}\n'.format(idx, uniq_name))
return
def _save_current_image(self):
"""
Loop through the dictionary of images output and resize and reverse
the preprocessing prior to saving
:return:
"""
if self.input_image is None:
return
self.current_out = {}
for i in self.image_out:
resize_to_shape = self._initialise_image_shape(
image_id=self.image_id, n_channels=self.image_out[i].shape[-1])
window_shape = resize_to_shape
current_out = self.image_out[i]
while current_out.ndim < 5:
current_out = current_out[..., np.newaxis, :]
if self.window_border and any([b > 0 for b in self.window_border]):
np_border = self.window_border
while len(np_border) < 5:
np_border = np_border + (0, )
np_border = [(b, ) for b in np_border]
current_out = np.pad(current_out, np_border, mode='edge')
image_shape = current_out.shape
zoom_ratio = \
[float(p) / float(d) for p, d in zip(window_shape, image_shape)]
image_shape = list(image_shape[:3]) + [1, image_shape[-1]]
current_out = np.reshape(current_out, image_shape)
current_out = zoom_3d(
image=current_out,
ratio=zoom_ratio,
interp_order=self.output_interp_order)
self.current_out[i] = current_out
for layer in reversed(self.reader.preprocessors):
if isinstance(layer, PadLayer):
for i in self.image_out:
self.current_out[i], _ = layer.inverse_op(
self.current_out[i])
if isinstance(layer, DiscreteLabelNormalisationLayer):
for i in self.image_out:
self.image_out[i], _ = layer.inverse_op(self.image_out[i])
subject_name = self.reader.get_subject_id(self.image_id)
for i in self.image_out:
filename = "{}_{}_{}.nii.gz".format(i, subject_name, self.postfix)
source_image_obj = self.input_image[self.name]
misc_io.save_data_array(self.output_path, filename,
self.current_out[i], source_image_obj,
self.output_interp_order)
self.log_inferred(subject_name, filename)
return
def _save_current_image(self):
if self.input_image is None:
return
for layer in reversed(self.reader.preprocessors):
if isinstance(layer, PadLayer):
self.image_out, _ = layer.inverse_op(self.image_out)
if isinstance(layer, DiscreteLabelNormalisationLayer):
self.image_out, _ = layer.inverse_op(self.image_out)
subject_name = self.reader.get_subject_id(self.image_id)
filename = "{}_niftynet_out.nii.gz".format(subject_name)
source_image_obj = self.input_image[self.name]
misc_io.save_data_array(self.output_path, filename, self.image_out,
source_image_obj, self.output_interp_order)
return
def _save_current_image(self):
if self.input_image is None:
return
for layer in reversed(self.reader.preprocessors):
if isinstance(layer, PadLayer):
self.image_out, _ = layer.inverse_op(self.image_out)
if isinstance(layer, DiscreteLabelNormalisationLayer):
self.image_out, _ = layer.inverse_op(self.image_out)
subject_name = self.reader.get_subject_id(self.image_id)
filename = "{}_niftynet_out.nii.gz".format(subject_name)
source_image_obj = self.input_image[self.name]
misc_io.save_data_array(self.output_path,
filename,
self.image_out,
source_image_obj,
self.output_interp_order)
return
def _save_current_image(self, image_out):
if self.input_image is None:
return
window_shape = [1, 1, 1, 1, image_out.shape[-1]]
image_out = np.reshape(image_out, window_shape)
for layer in reversed(self.reader.preprocessors):
if isinstance(layer, DiscreteLabelNormalisationLayer):
image_out, _ = layer.inverse_op(image_out)
subject_name = self.reader.get_subject_id(self.image_id)
filename = "{}{}.nii.gz".format(subject_name, self.prefix)
source_image_obj = self.input_image[self.name]
misc_io.save_data_array(self.output_path, filename, image_out,
source_image_obj, self.output_interp_order)
with open(self.csv_path, 'a') as csv_file:
data_str = ','.join([str(i) for i in image_out[0, 0, 0, 0, :]])
csv_file.write(subject_name + ',' + data_str + '\n')
self.log_inferred(subject_name, filename)
return
def _save_current_image(self, image_out):
if self.input_image is None:
return
window_shape = [1, 1, 1, 1, image_out.shape[-1]]
image_out = np.reshape(image_out, window_shape)
for layer in reversed(self.reader.preprocessors):
if isinstance(layer, DiscreteLabelNormalisationLayer):
image_out, _ = layer.inverse_op(image_out)
subject_name = self.reader.get_subject_id(self.image_id)
filename = "{}{}.nii.gz".format(subject_name, self.prefix)
source_image_obj = self.input_image[self.name]
misc_io.save_data_array(self.output_path,
filename,
image_out,
source_image_obj,
self.output_interp_order)
with open(self.csv_path, 'a') as csv_file:
data_str = ','.join([str(i) for i in image_out[0, 0, 0, 0, :]])
csv_file.write(subject_name+','+data_str+'\n')
self.log_inferred(subject_name, filename)
return
def layer_op(self, subject_id, data):
analyses = self.app_param.evaluation_units.split(',')
if 'label' not in analyses and 'foreground' not in analyses:
raise ValueError('ErrorMaps work with label or foreground '
'analyses only')
if self.app_param.num_classes > 2:
raise ValueError('ErrorMaps work with binary segmentations only')
binarizer = cached_label_binarizer(1, self.app_param.output_prob)
seg, ref = binarizer(data)
cc_func = connected_components
cc_seg, cc_ref = cc_func(seg, ref, self.app_param.output_prob)
cc_aggregator = union_of_seg_for_each_ref_cc
ccs = cc_aggregator(cc_ref, cc_seg)
tp_seg_labels = set(s for seg_l, ref_l in ccs for s in seg_l)
tp_ref_labels = set(r for seg_l, ref_l in ccs for r in ref_l if len(
seg_l))
fn_ref_labels = set(range(1, cc_ref[1])) - tp_ref_labels
fp_seg_labels = set(range(1, cc_seg[1])) - tp_seg_labels
maps = {}
maps['tpc_map'] = np.logical_or(cc_seg in tp_seg_labels,
cc_ref in tp_ref_labels)
maps['fnc_map'] = cc_ref in fn_ref_labels
maps['fpc_map'] = cc_seg in fp_seg_labels
image_idx = self.reader.get_image_index(subject_id)
file_path = os.path.join(self.eval_param.save_csv_dir, 'images')
out = {'subject_id': subject_id}
for key in maps:
out[key] = os.path.join(file_path, subject_id + '_' + key + '.nii')
save_data_array(file_path,
subject_id + '_' + key + '.nii',
maps[key],
self.reader.output_list[image_idx]['label'], 0)
pdf = pd.DataFrame.from_records([out], ('subject_id',))
return [pdf]
def layer_op(self, subject_id, data):
analyses = self.app_param.evaluation_units.split(',')
if 'label' not in analyses and 'foreground' not in analyses:
raise ValueError('ErrorMaps work with label or foreground '
'analyses only')
if self.app_param.num_classes > 2:
raise ValueError('ErrorMaps work with binary segmentations only')
binarizer = cached_label_binarizer(1, self.app_param.output_prob)
seg, ref = binarizer(data)
cc_func = connected_components
cc_seg, cc_ref = cc_func(seg, ref, self.app_param.output_prob)
cc_aggregator = union_of_seg_for_each_ref_cc
ccs = cc_aggregator(cc_ref, cc_seg)
tp_seg_labels = set(s for seg_l, ref_l in ccs for s in seg_l)
tp_ref_labels = set(r for seg_l, ref_l in ccs for r in ref_l if len(
seg_l))
fn_ref_labels = set(range(1, cc_ref[1])) - tp_ref_labels
fp_seg_labels = set(range(1, cc_seg[1])) - tp_seg_labels
maps = {}
maps['tpc_map'] = np.logical_or(cc_seg in tp_seg_labels,
cc_ref in tp_ref_labels)
maps['fnc_map'] = cc_ref in fn_ref_labels
maps['fpc_map'] = cc_seg in fp_seg_labels
image_idx = self.reader.get_image_index(subject_id)
file_path = os.path.join(self.eval_param.save_csv_dir, 'images')
out = {'subject_id': subject_id}
for key in maps:
out[key] = os.path.join(file_path, subject_id + '_' + key + '.nii')
save_data_array(file_path,
subject_id + '_' + key + '.nii',
maps[key],
self.reader.output_list[image_idx]['label'], 0)
pdf = pd.DataFrame.from_records([out], ('subject_id',))
return [pdf]
def _save_current_image(self, image_out, resize_to):
if self.input_image is None:
return
window_shape = resize_to
while image_out.ndim < 5:
image_out = image_out[..., np.newaxis, :]
if self.window_border and any([b > 0 for b in self.window_border]):
np_border = self.window_border
while len(np_border) < 5:
np_border = np_border + (0,)
np_border = [(b,) for b in np_border]
image_out = np.pad(image_out, np_border, mode='edge')
image_shape = image_out.shape
zoom_ratio = \
[float(p) / float(d) for p, d in zip(window_shape, image_shape)]
image_shape = list(image_shape[:3]) + [1, image_shape[-1]]
image_out = np.reshape(image_out, image_shape)
image_out = zoom_3d(image=image_out,
ratio=zoom_ratio,
interp_order=self.output_interp_order)
for layer in reversed(self.reader.preprocessors):
if isinstance(layer, PadLayer):
image_out, _ = layer.inverse_op(image_out)
if isinstance(layer, DiscreteLabelNormalisationLayer):
image_out, _ = layer.inverse_op(image_out)
subject_name = self.reader.get_subject_id(self.image_id)
filename = "{}{}.nii.gz".format(subject_name, self.prefix)
source_image_obj = self.input_image[self.name]
misc_io.save_data_array(self.output_path,
filename,
image_out,
source_image_obj,
self.output_interp_order)
self.log_inferred(subject_name, filename)
return
def _save_current_image(self):
"""
For all the outputs to be saved as images, go through the dictionary
and save the resulting output after reversing the initial preprocessing
:return:
"""
if self.input_image is None:
return
for layer in reversed(self.reader.preprocessors):
if isinstance(layer, PadLayer):
for i in self.image_out:
self.image_out[i], _ = layer.inverse_op(self.image_out[i])
if isinstance(layer, DiscreteLabelNormalisationLayer):
for i in self.image_out:
self.image_out[i], _ = layer.inverse_op(self.image_out[i])
subject_name = self.reader.get_subject_id(self.image_id)
for i in self.image_out:
filename = "{}_{}_{}.nii.gz".format(i, subject_name, self.postfix)
source_image_obj = self.input_image[self.name]
misc_io.save_data_array(self.output_path, filename,
self.image_out[i], source_image_obj,
self.output_interp_order)
self.log_inferred(subject_name, filename)
return
def _save_current_image(self, idx, filename, image):
if image is None:
return
uniq_name = "{}_{}_niftynet_generated.nii.gz".format(idx, filename)
misc_io.save_data_array(self.output_path, uniq_name, image, None)
return
def _save_current_image(self, idx, filename, image):
if image is None:
return
uniq_name = "{}_{}_niftynet_generated.nii.gz".format(idx, filename)
misc_io.save_data_array(self.output_path, uniq_name, image, None)
return
