def main():
parser = argparse.ArgumentParser()
parser.add_argument('--in-trans-img', type=str, default=in_trans)
parser.add_argument('--in-ref-img', type=str, default=in_ref_img)
parser.add_argument('--out-jac-elem-prefix',
type=str,
default=out_elem_prefix)
parser.add_argument('--c3d-path', type=str, default=c3d_path)
args = parser.parse_args()
in_trans_img = nib.load(args.in_trans_img)
in_trans_data = in_trans_img.get_data()
print(in_trans_data.shape)
ref_obj = ScanWrapper(args.in_ref_img)
for idx_elem in range(9):
jac_elem = in_trans_data[:, :, :, 0, idx_elem]
out_elem_path = f'{args.out_jac_elem_prefix}_{idx_elem}_raw.nii.gz'
ref_obj.save_scan_same_space(out_elem_path, jac_elem)
out_clip_elem_path = f'{args.out_jac_elem_prefix}_{idx_elem}_clip_95.nii.gz'
cmd_str = f'{args.c3d_path} {out_elem_path} -clip 5% 95% -o {out_clip_elem_path}'
logger.info(f'{cmd_str}')
os.system(cmd_str)
def _run_single_scan(self, idx):
mask1 = ScanWrapper(self._in_data_folder.get_file_path(idx))
mask2 = ScanWrapper(self._in_folder2_obj.get_file_path(idx))
mask_union = np.zeros(mask1.get_data().shape, dtype=int)
mask_union[(mask1.get_data() == 1) | (mask2.get_data() == 1)] = 1
out_path = self._out_folder_obj.get_file_path(idx)
mask1.save_scan_same_space(out_path, mask_union)
def _run_single_scan(self, idx):
in_file_path = self._in_data_folder.get_file_path(idx)
out_file_path = self._out_folder_obj.get_file_path(idx)
in_img_obj = ScanWrapper(in_file_path)
in_img = ScanWrapper(in_file_path).get_data()
mask_img = np.zeros(in_img.shape, dtype=int)
mask_img.fill(self._mask_value)
in_img_obj.save_scan_same_space(out_file_path, in_img)
def _run_single_scan(self, idx):
in_img = ScanWrapper(self._in_data_folder.get_file_path(idx))
out_path = self._out_mask_folder_obj.get_file_path(idx)
in_img_data = in_img.get_data()
non_nan_mask = (in_img_data == in_img_data).astype(int)
if self._if_reverse:
non_nan_mask = 1 - non_nan_mask
in_img.save_scan_same_space(out_path, non_nan_mask)
def _run_single_scan(self, idx):
in_ori_path = self._in_data_folder.get_file_path(idx)
out_path = self._out_folder.get_file_path(idx)
im_obj = ScanWrapper(in_ori_path)
im_data = im_obj.get_data()
logger.info(f'Replace nan to valude {self._replace_val}')
new_im_data = np.nan_to_num(im_data, nan=self._replace_val)
im_obj.save_scan_same_space(out_path, new_im_data)
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_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 get_pad_mask2(in_native_nii, out_mask_nii):
in_native_obj = ScanWrapper(in_native_nii)
in_native_img = in_native_obj.get_data()
print(in_native_img.shape)
z_variance_map = np.var(in_native_img, axis=2)
print(z_variance_map.shape)
slice_pad_region = (z_variance_map == 0).astype(int)
mask_img = np.zeros(in_native_img.shape, dtype=int)
for z_idx in range(mask_img.shape[2]):
mask_img[:, :, z_idx] = slice_pad_region
in_native_obj.save_scan_same_space(out_mask_nii, mask_img)
return np.sum(slice_pad_region) != 0
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)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--in-trans-img', type=str, default=in_trans)
parser.add_argument('--in-ref-img', type=str, default=in_ref_img)
parser.add_argument('--out-d-idx-img', type=str, default=out_d_idx_img)
args = parser.parse_args()
in_trans_img = nib.load(args.in_trans_img)
in_trans_data = in_trans_img.get_data()
print(in_trans_data.shape)
in_trans_data = np.reshape(in_trans_data, (225, 225, 200, 1, 3, 3))
print(in_trans_data.shape)
print(f'Start calculate the svd')
_, s, _ = np.linalg.svd(in_trans_data)
print(f'Complete calculating svd.')
print(s.shape)
# print('Get the log jac')
# # jac_log = np.log((s[:,:,:,:, 0] * s[:,:,:,:, 1] * s[:,:,:,:, 2]))
#
# print('Done')
print('Get D index')
d_idx = np.zeros((s.shape[0], s.shape[1], s.shape[2]), dtype=float)
for idx in range(3):
print(f'idx {idx}')
s_idx_1 = idx % 3
s_idx_2 = (idx + 1) % 3
pair_wise_idx = np.abs(
np.log(
np.abs(s[:, :, :, 0, s_idx_1]) /
np.abs(s[:, :, :, 0, s_idx_2])))
d_idx += pair_wise_idx
print('Done')
print(f'Save to {args.out_d_idx_img}')
ref_obj = ScanWrapper(args.in_ref_img)
ref_obj.save_scan_same_space(args.out_d_idx_img, d_idx)
def get_pad_mask(in_nii, out_nii):
circle_info = get_ct_pixel_pad_circle_fit(in_nii)
in_obj = ScanWrapper(in_nii)
in_img = in_obj.get_data()
mask_img = np.zeros(in_img.shape, dtype=int)
if circle_info is not None:
c_x, c_y, c_r = circle_info
mask_slice = np.zeros((in_img.shape[0], in_img.shape[1]), dtype=int)
for i in range(in_img.shape[0]):
for j in range(in_img.shape[1]):
dist2center = np.sqrt((i - c_x)**2 + (j - c_y)**2)
if dist2center > c_r - 1:
mask_slice[i, j] = 1
for k in range(in_img.shape[2]):
mask_img[:, :, k] = mask_slice
in_obj.save_scan_same_space(out_nii, mask_img)
return circle_info is not None
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
