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