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()