def _run_single_scan(self, idx):
in_ori_image = ScanWrapper(self._in_data_folder.get_file_path(idx))
in_ori_data = in_ori_image.get_data()
in_effective_mask = (in_ori_data == in_ori_data).astype(int)
effective_region_mask = in_effective_mask * self._in_ref_valid_mask.get_data(
)
# We need to make sure the boundary elements are all 0
boundary_mask = np.zeros(in_ori_image.get_shape())
boundary_mask[1:-1, 1:-1, 1:-1] = 1
effective_region_mask = effective_region_mask * boundary_mask
edt_img = ndi.distance_transform_edt(effective_region_mask)
effective_region_mask = (edt_img > self._etch_radius).astype(int)
out_mask_path = self._out_folder_obj.get_file_path(idx)
in_ori_image.save_scan_same_space(out_mask_path, effective_region_mask)
def _run_single_scan(self, idx):
in_img = ScanWrapper(self._in_data_folder.get_file_path(idx))
in_mask = None
if self._in_mask_folder_obj is not None:
in_mask = ScanWrapper(self._in_mask_folder_obj.get_file_path(idx))
if self._in_mask_file_obj is not None:
in_mask = self._in_mask_file_obj
out_path = self._out_folder_obj.get_file_path(idx)
in_img_data = in_img.get_data()
in_mask_data = in_mask.get_data()
new_img_data = np.full(in_img.get_shape(), self._ambient_val)
np.copyto(new_img_data, in_img_data, where=in_mask_data > 0)
in_img.save_scan_same_space(out_path, new_img_data)
class AverageValidRegion(AbstractParallelRoutine):
def __init__(self, in_folder_obj, num_process):
super().__init__(in_folder_obj, num_process)
self._ref_img = ScanWrapper(self._in_data_folder.get_first_path())
self._sum_map = None
self._average_map = None
self._sum_variance_map = None
self._valid_count_map = None
self._run_mode = None
def run_get_average(self):
logger.info('Calculating average')
self._run_mode = 'get_average'
result_list = self.run_parallel()
im_shape = self._ref_img.get_shape()
self._sum_map = np.zeros(im_shape)
self._valid_count_map = np.zeros(im_shape)
for result in result_list:
self._sum_map += result['sum_image']
self._valid_count_map += result['region_count']
average_image = np.zeros(im_shape)
average_image = np.divide(self._sum_map,
self._valid_count_map,
out=average_image,
where=self._valid_count_map > 0.5)
self._average_map = average_image
def output_result_average(self, output_path, ambient_val):
average_image_out_data = np.ma.masked_array(
self._average_map, mask=self._valid_count_map == 0)
self._ref_img.save_scan_same_space(
output_path, average_image_out_data.filled(ambient_val))
def _run_chunk(self, chunk_list):
result_list = []
if self._run_mode == 'get_average':
result_list = self._run_chunk_get_average(chunk_list)
elif self._run_mode == 'get_variance':
result_list = self._run_chunk_get_variance(chunk_list)
else:
logger.info('Into the error')
raise NotImplementedError
return result_list
def _run_chunk_get_average(self, chunk_list):
result_list = []
im_shape = self._ref_img.get_shape()
sum_image_union = np.zeros(im_shape)
region_mask_count_image = np.zeros(im_shape)
for idx in chunk_list:
self._in_data_folder.print_idx(idx)
img_obj = ScanWrapper(self._in_data_folder.get_file_path(idx))
img_data = img_obj.get_data()
valid_mask = np.logical_not(np.isnan(img_data)).astype(int)
np.add(img_data,
sum_image_union,
out=sum_image_union,
where=valid_mask > 0)
region_mask_count_image += valid_mask
result = {
'sum_image': sum_image_union,
'region_count': region_mask_count_image
}
result_list.append(result)
return result_list
def _run_chunk_get_variance(self, chunk_list):
result_list = []
im_shape = self._ref_img.get_shape()
sum_image_union = np.zeros(im_shape)
for idx in chunk_list:
self._in_data_folder.print_idx(idx)
img_obj = ScanWrapper(self._in_data_folder.get_file_path(idx))
img_data = img_obj.get_data()
valid_mask = np.logical_not(np.isnan(img_data)).astype(int)
residue_map = np.zeros(img_data.shape)
np.subtract(img_data,
self._average_map,
out=residue_map,
where=valid_mask > 0)
residue_map = np.power(residue_map, 2)
np.add(residue_map,
sum_image_union,
out=sum_image_union,
where=valid_mask > 0)
result = {'sum_image': sum_image_union}
result_list.append(result)
return result_list
class AverageValidRegion(AbstractParallelRoutine):
def __init__(self, in_folder_obj, in_omat_folder_obj,
out_corrected_folder_obj, num_process):
super().__init__(in_folder_obj, num_process)
self._in_omat_folder_obj = in_omat_folder_obj
self._out_corrected_folder_obj = out_corrected_folder_obj
self._ref_img = ScanWrapper(self._in_data_folder.get_first_path())
self._sum_map = None
self._average_map = None
self._sum_variance_map = None
self._variance_map = None
self._valid_count_map = None
self._run_mode = None
def run_get_average(self):
logger.info('Calculating average')
self._run_mode = 'get_average'
result_list = self.run_parallel()
im_shape = self._ref_img.get_shape()
self._sum_map = np.zeros(im_shape)
self._valid_count_map = np.zeros(im_shape)
for result in result_list:
self._sum_map += result['sum_image']
self._valid_count_map += result['region_count']
average_image = np.zeros(im_shape)
average_image = np.divide(self._sum_map,
self._valid_count_map,
out=average_image,
where=self._valid_count_map > 0.5)
self._average_map = average_image
def run_get_variance(self):
logger.info('Calculating variance')
self._run_mode = 'get_variance'
result_list = self.run_parallel()
im_shape = self._ref_img.get_shape()
self._sum_variance_map = np.zeros(im_shape)
for result in result_list:
self._sum_variance_map += result['sum_image']
self._variance_map = np.zeros(im_shape)
self._variance_map = np.divide(self._sum_variance_map,
self._valid_count_map,
out=self._variance_map,
where=self._valid_count_map > 0.5)
epsilon = 1.0e-5
self._variance_map = np.log(np.add(self._variance_map, epsilon))
def output_result_folder(self, output_folder, ambient_val):
average_img_path = os.path.join(output_folder, 'average.nii.gz')
variance_img_path = os.path.join(output_folder, 'variance.nii.gz')
count_map_path = os.path.join(output_folder, 'count_map.nii.gz')
average_image_out_data = np.ma.masked_array(
self._average_map, mask=self._valid_count_map == 0)
variance_image_out_data = np.ma.masked_array(
self._variance_map, mask=self._valid_count_map == 0)
self._ref_img.save_scan_same_space(
average_img_path, average_image_out_data.filled(ambient_val))
self._ref_img.save_scan_same_space(
variance_img_path, variance_image_out_data.filled(ambient_val))
self._ref_img.save_scan_same_space(count_map_path,
self._valid_count_map)
def _run_chunk(self, chunk_list):
result_list = []
if self._run_mode == 'get_average':
result_list = self._run_chunk_get_average(chunk_list)
elif self._run_mode == 'get_variance':
result_list = self._run_chunk_get_variance(chunk_list)
else:
logger.info('Into the error')
raise NotImplementedError
return result_list
def _run_chunk_get_average(self, chunk_list):
result_list = []
im_shape = self._ref_img.get_shape()
sum_image_union = np.zeros(im_shape)
region_mask_count_image = np.zeros(im_shape)
for idx in chunk_list:
self._in_data_folder.print_idx(idx)
# img_obj = ScanWrapper(self._in_data_folder.get_file_path(idx))
# img_data = img_obj.get_data()
img_data = self._get_img_data(idx)
valid_mask = np.logical_not(np.isnan(img_data)).astype(int)
np.add(img_data,
sum_image_union,
out=sum_image_union,
where=valid_mask > 0)
region_mask_count_image += valid_mask
result = {
'sum_image': sum_image_union,
'region_count': region_mask_count_image
}
result_list.append(result)
return result_list
def _run_chunk_get_variance(self, chunk_list):
result_list = []
im_shape = self._ref_img.get_shape()
sum_image_union = np.zeros(im_shape)
for idx in chunk_list:
self._in_data_folder.print_idx(idx)
# img_obj = ScanWrapper(self._in_data_folder.get_file_path(idx))
# img_data = img_obj.get_data()
img_data = self._get_img_data(idx)
valid_mask = np.logical_not(np.isnan(img_data)).astype(int)
residue_map = np.zeros(img_data.shape)
np.subtract(img_data,
self._average_map,
out=residue_map,
where=valid_mask > 0)
residue_map = np.power(residue_map, 2)
np.add(residue_map,
sum_image_union,
out=sum_image_union,
where=valid_mask > 0)
result = {'sum_image': sum_image_union}
result_list.append(result)
return result_list
def _get_img_data(self, idx):
img_obj = ScanWrapper(self._in_data_folder.get_file_path(idx))
img_data = img_obj.get_data()
img_data = np.abs(img_data)
np.copyto(img_data, np.nan, where=img_data < 0.01)
img_data = np.log10(img_data)
in_omat_path = self._in_omat_folder_obj.get_file_path(idx)
omat = np.loadtxt(in_omat_path)
img_data = img_data + np.log10(np.linalg.det(omat))
save_corrected_path = self._out_corrected_folder_obj.get_file_path(idx)
img_obj.save_scan_same_space(save_corrected_path, img_data)
return img_data
def _run_single_scan(self, idx):
in_mask = ScanWrapper(self._in_data_folder.get_file_path(idx))
mask_diff = np.zeros(in_mask.get_shape(), dtype=int)
mask_diff[in_mask.get_data() != self._ref_mask_obj.get_data()] = 1
out_path = self._out_folder_obj.get_file_path(idx)
self._ref_mask_obj.save_scan_same_space(out_path, mask_diff)
