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_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
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_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 __init__(self, ori_img, ref_img, affine_img, non_rigid_img):
self._ori_img = ScanWrapper(ori_img).get_data()
self._ref_img = ScanWrapper(ref_img).get_data()
self._affine_img = ScanWrapper(affine_img).get_data()
self._non_rigid_img = ScanWrapper(non_rigid_img).get_data()
self._vmin = -1000
self._vmax = 500
self._sub_title_font_size = 70
self._checkerboard_n_tiles = (10, 10)
self._ref_cm = 'jet'
self._moving_cm = 'hsv'
self._out_dpi = 15
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 _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
class CalculateDice(AbstractParallelRoutine):
def __init__(self, in_folder_obj, effective_mask_folder, num_process,
gt_mask):
super().__init__(in_folder_obj, num_process)
self._effective_mask_folder_obj = effective_mask_folder
self._gt_mask = ScanWrapper(gt_mask)
self._df_dice = None
def get_dice(self):
logger.info(f'Calculating dice score')
result_list = self.run_parallel()
logger.info(f'Done.')
self._df_dice = pd.DataFrame(result_list)
# print(self._df_dice)
def save_csv(self, csv_file):
logger.info(f'Save dice table to csv {csv_file}')
self._df_dice.to_csv(csv_file, index=False)
def _run_single_scan(self, idx):
test_mask = ScanWrapper(self._in_data_folder.get_file_path(idx))
effective_mask = ScanWrapper(
self._effective_mask_folder_obj.get_file_path(idx))
dice_val = get_dice_with_effective_mask(self._gt_mask.get_data(),
test_mask.get_data(),
effective_mask.get_data())
result = {'Scan': test_mask.get_file_name(), 'Dice': dice_val}
return result
class GetDiceEffectiveRegion(AbstractParallelRoutine):
def __init__(self, in_ori_folder_obj, in_ref_valid_mask, num_process,
out_folder_obj, etch_radius):
super().__init__(in_ori_folder_obj, num_process)
self._in_ref_valid_mask = ScanWrapper(in_ref_valid_mask)
self._out_folder_obj = out_folder_obj
self._etch_radius = etch_radius
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 main():
parser = argparse.ArgumentParser(
description='Run preprocess on in data folder')
parser.add_argument('--in-folder',
type=str,
help='Folder of input data',
required=True)
parser.add_argument('--out-folder',
type=str,
help='Output location for preprocessed images',
required=True)
parser.add_argument(
'--average-img',
type=str,
help='Use this average image to impute the missing voxels in targets')
parser.add_argument('--file-list-txt', type=str)
parser.add_argument('--num-process', type=int, default=10)
args = parser.parse_args()
in_folder_obj = DataFolder(args.in_folder, args.file_list_txt)
out_folder_obj = DataFolder(args.out_folder, args.file_list_txt)
average_img_obj = ScanWrapper(args.average_img)
preprocess_obj = PreprocessAverageImputation(in_folder_obj, out_folder_obj,
average_img_obj,
args.num_process)
preprocess_obj.run_parallel()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--in-ori-folder', type=str)
parser.add_argument('--in-affine-folder')
parser.add_argument('--in-warped-folder', type=str)
parser.add_argument('--ref-img', type=str)
parser.add_argument('--file-list-txt', type=str)
parser.add_argument('--out-png-folder', type=str)
parser.add_argument('--step-axial', type=int, default=50)
parser.add_argument('--step-sagittal', type=int, default=75)
parser.add_argument('--step-coronal', type=int, default=30)
parser.add_argument('--num-process', type=int, default=10)
args = parser.parse_args()
in_ori_folder_obj = DataFolder(args.in_ori_folder, args.file_list_txt)
in_affine_folder_obj = DataFolder(args.in_affine_folder,
args.file_list_txt)
in_warped_folder_obj = DataFolder(args.in_warped_folder,
args.file_list_txt)
out_png_folder_obj = DataFolder(args.out_png_folder, args.file_list_txt)
out_png_folder_obj.change_suffix('.png')
ref_img = ScanWrapper(args.ref_img)
exe_obj = Overlay3Views(in_ori_folder_obj, in_affine_folder_obj,
in_warped_folder_obj, out_png_folder_obj, ref_img,
args.step_axial, args.step_sagittal,
args.step_coronal, args.num_process)
exe_obj.run_parallel()
def clip_overlay_with_mask_n_clip(in_nii, in_mask, out_png, num_clip=10):
print(f'reading {in_nii}')
print(f'reading {in_mask}')
in_img = ScanWrapper(in_nii).get_data()
in_mask_img = ScanWrapper(in_mask).get_data()
clip_in_img_montage = []
clip_in_mask_montage = []
for idx_clip in range(num_clip):
clip_in_img = _clip_image(in_img, num_clip, idx_clip)
clip_in_img = np.concatenate([clip_in_img, clip_in_img], axis=1)
clip_mask_img = _clip_image(in_mask_img, num_clip, idx_clip)
clip_mask_img = np.concatenate([
np.zeros(
(in_img.shape[0], in_img.shape[1]), dtype=int), clip_mask_img
],
axis=1)
clip_mask_img = clip_mask_img.astype(float)
clip_mask_img[clip_mask_img == 0] = np.nan
clip_in_img_montage.append(clip_in_img)
clip_in_mask_montage.append(clip_mask_img)
clip_in_img_montage = np.concatenate(clip_in_img_montage, axis=0)
clip_in_mask_montage = np.concatenate(clip_in_mask_montage, axis=0)
vmin_img = -1200
vmax_img = 600
fig, ax = plt.subplots()
plt.axis('off')
ax.imshow(clip_in_img_montage,
interpolation='bilinear',
cmap='gray',
norm=colors.Normalize(vmin=vmin_img, vmax=vmax_img),
alpha=0.8)
ax.imshow(clip_in_mask_montage,
interpolation='none',
cmap='Reds',
norm=colors.Normalize(vmin=0, vmax=1),
alpha=0.5)
print(f'Save to {out_png}')
plt.savefig(out_png, bbox_inches='tight', pad_inches=0, dpi=300)
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 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 clip_connected_component_bb_center_with_mask(in_nii, in_mask, out_folder):
mkdir_p(out_folder)
# Find the connected components,
in_img = ScanWrapper(in_nii).get_data()
in_mask_img = ScanWrapper(in_mask).get_data()
in_mask_img = np.flip(in_mask_img, axis=1)
connected_label, num_label = label(in_mask_img, return_num=True)
props = regionprops(connected_label)
# Clip at the centers
for idx_component in range(num_label):
center = props[idx_component].centroid
print(center)
out_png = os.path.join(out_folder, f'component.{idx_component}.png')
_clip_image_location_triplanar(in_nii, in_mask, center, out_png)
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
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 = ScanWrapper(in_file_path).get_data()
average_img = self._average_img_obj.get_data()
np.copyto(in_img, average_img, where=(in_img != in_img))
np.copyto(in_img, 0, where=(in_img != in_img))
self._average_img_obj.save_scan_same_space(out_file_path, in_img)
def clip_overlay_with_mask(in_nii, in_mask, out_png):
# Only do the clip on axial plane.
print(f'reading {in_nii}')
print(f'reading {in_mask}')
in_img = ScanWrapper(in_nii).get_data()
in_mask_img = ScanWrapper(in_mask).get_data()
clip_in_img = in_img[:, :, int(in_img.shape[2] / 2.0)]
clip_in_img = np.rot90(clip_in_img)
clip_in_img = np.concatenate([clip_in_img, clip_in_img], axis=1)
clip_mask_img = in_mask_img[:, :, int(in_img.shape[2] / 2.0)]
clip_mask_img = np.rot90(clip_mask_img)
clip_mask_img = np.concatenate(
[np.zeros((in_img.shape[0], in_img.shape[1]), dtype=int),
clip_mask_img], axis=1
)
clip_mask_img = clip_mask_img.astype(float)
clip_mask_img[clip_mask_img == 0] = np.nan
vmin_img = -1200
vmax_img = 600
fig, ax = plt.subplots()
plt.axis('off')
ax.imshow(
clip_in_img,
interpolation='bilinear',
cmap='gray',
norm=colors.Normalize(vmin=vmin_img, vmax=vmax_img),
alpha=0.8)
ax.imshow(
clip_mask_img,
interpolation='none',
cmap='jet',
norm=colors.Normalize(vmin=np.min(in_mask_img), vmax=np.max(in_mask_img)),
alpha=0.5
)
print(f'Save to {out_png}')
plt.savefig(out_png, bbox_inches='tight', pad_inches=0, dpi=150)
plt.close()
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_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 clip_plot(self, out_png_folder):
in_img_obj = ScanWrapper(self._in_img_path)
in_mask_obj = ScanWrapper(self._in_mask_path)
in_img_data = in_img_obj.get_data()
in_mask_data = in_mask_obj.get_data()
masked_img_data = np.zeros(in_img_data.shape, dtype=float)
masked_img_data.fill(np.nan)
masked_img_data[in_mask_data == 1] = in_img_data[in_mask_data == 1]
# masked_img_data[masked_img_data != masked_img_data] = self._vmin
self._plot_view(
self._num_clip,
self._step_axial,
masked_img_data,
'axial',
out_png_folder
)
self._plot_view(
self._num_clip,
self._step_sagittal,
masked_img_data,
'sagittal',
out_png_folder
)
self._plot_view(
self._num_clip,
self._step_coronal,
masked_img_data,
'coronal',
out_png_folder
)
def _run_single_scan(self, idx):
im_obj = ScanWrapper(self._in_data_folder.get_file_path(idx))
in_img_data = im_obj.get_data()
out_png_prefix = self._out_folder_obj.get_file_path(idx)
# self._plot_view(
# self._offset_axial,
# in_img_data,
# 'axial',
# out_png_prefix
# )
#
# self._plot_view(
# self._offset_sagittal,
# in_img_data,
# 'sagittal',
# out_png_prefix
# )
self._plot_view(self._offset_coronal, in_img_data, 'coronal',
out_png_prefix)
def _run_single_scan(self, idx):
test_mask = ScanWrapper(self._in_data_folder.get_file_path(idx))
effective_mask = ScanWrapper(
self._effective_mask_folder_obj.get_file_path(idx))
dice_val = get_dice_with_effective_mask(self._gt_mask.get_data(),
test_mask.get_data(),
effective_mask.get_data())
result = {'Scan': test_mask.get_file_name(), 'Dice': dice_val}
return result
def _run_single_scan(self, idx):
in_scan_data = ScanWrapper(
self._in_data_folder.get_file_path(idx)).get_data()
neg_map = (in_scan_data < 0).astype(int)
neg_ratio = np.sum(neg_map) / neg_map.size
result = {
'Scan': self._in_data_folder.get_file_name(idx),
'STD': np.std(in_scan_data),
'NegRatio': neg_ratio
}
return result
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--in-folder', type=str)
parser.add_argument('--mask-img', type=str)
parser.add_argument('--file-list-txt', type=str)
parser.add_argument('--out-bin-path', type=str)
args = parser.parse_args()
in_folder_obj = DataFolder(args.in_folder, args.file_list_txt)
mask_img = ScanWrapper(args.mask_img)
creator_obj = CreateMaskedFeatureMatrix(in_folder_obj, mask_img)
creator_obj.load_data()
creator_obj.save_to_bin(args.out_bin_path)
def clip_plot_3_view(self, out_png_folder):
in_img_obj = ScanWrapper(self._in_img_path)
in_mask_obj = ScanWrapper(self._in_mask_path)
in_img_data = in_img_obj.get_data()
in_mask_data = in_mask_obj.get_data()
masked_img_data = np.zeros(in_img_data.shape, dtype=float)
masked_img_data.fill(np.nan)
masked_img_data[in_mask_data == 1] = in_img_data[in_mask_data == 1]
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--in-folder', type=str)
parser.add_argument('--ref-img', type=str)
parser.add_argument('--file-list-txt', type=str)
parser.add_argument('--niftyreg-root', type=str)
parser.add_argument('--out-csv', type=str)
parser.add_argument('--num-process', type=int, default=10)
args = parser.parse_args()
in_folder_obj = DataFolder(args.in_folder, args.file_list_txt)
ref_img = ScanWrapper(args.ref_img)
exe_obj = MetricNMI(in_folder_obj, ref_img, args.niftyreg_root,
args.num_process)
exe_obj.get_nmi()
exe_obj.save_csv(args.out_csv)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--in-mask-folder', type=str)
parser.add_argument('--in-ref-mask', type=str, default=None)
parser.add_argument('--out-folder', type=str)
parser.add_argument('--file-list-txt', type=str)
parser.add_argument('--num-process', type=int, default=10)
args = parser.parse_args()
in_folder_obj = DataFolder(args.in_mask_folder, args.file_list_txt)
out_folder_obj = DataFolder(args.out_folder, args.file_list_txt)
ref_mask_obj = ScanWrapper(args.in_ref_mask)
exe_obj = GetDiffMask(in_folder_obj, out_folder_obj, ref_mask_obj,
args.num_process)
exe_obj.run_parallel()
