def validate(model, df, input_shape, output_shape, n_tiles, n_classes): dice_coefs = [] for image_path, label_path in zip(df["preprocessed"], df["label"]): image = load_nifti(image_path) label = load_nifti(label_path) output = feedforward(model, image, input_shape, output_shape, n_tiles, n_classes) y = np.int32(np.argmax(output, axis=0)) dice_coefs.append(dice_coefficients(y, label, labels=range(n_classes))) dice_coefs = np.array(dice_coefs) return np.mean(dice_coefs, axis=0)
def fit_normalization(self, num_sample=None, show_progress=False): """ Calculate the voxel-wise mean and std across the dataset for normalization. Args: num_sample (int or None): If None (default), calculate the values across the complete dataset, otherwise sample a number of images. show_progress (bool): Show a progress bar during the calculation." """ if num_sample is None: num_sample = len(self) image_shape = self.image_shape() all_struct_arr = np.zeros( (num_sample, image_shape[0], image_shape[1], image_shape[2])) sampled_filenames = np.random.choice(self.filenames, num_sample, replace=False) if show_progress: sampled_filenames = tqdm_notebook(sampled_filenames) for i, filename in enumerate(sampled_filenames): struct_arr = utils.load_nifti(filename, mask=mask) all_struct_arr[i] = struct_arr self.mean = all_struct_arr.mean(0) self.std = all_struct_arr.std(0)
def check_masks_to_be_binary(masks_fps): wrong_masks = [] # check that masks are truly binary with tqdm.tqdm(total=len(masks_fps)) as pbar: for fp in masks_fps: pbar.set_description(os.path.basename(fp)) mask, mask_data = utils.load_nifti(fp) if mask_data.dtype != np.uint8: wrong_masks.append(fp) print( f'WARNING! "{os.path.basename(fp)}" has {mask_data.dtype} dtype' ) unique_values = np.unique(mask_data) if not np.array_equal(unique_values, [0, 1]): wrong_masks.append(fp) print( f'WARNING! "{os.path.basename(fp)}" is not binary. unique values: {unique_values}' ) pbar.update() return wrong_masks
def add_raw_masks(masks_raw_dp, masks_out_dp, postfix: str = 'resegm2_fixed_bin'): """add raw (not thresholded) masks into dataset""" print(f'\nadd_raw_masks()') print(f'masks_raw_dp: {masks_raw_dp}') print(f'masks_out_dp: {masks_out_dp}') masks_raw_fps = utils.get_nii_gz_filepaths(masks_raw_dp) print(f'# of raw masks to add: {len(masks_raw_fps)}') os.makedirs(masks_out_dp, exist_ok=True) with tqdm.tqdm(total=len(masks_raw_fps)) as pbar: for fp in masks_raw_fps: pbar.set_description(os.path.basename(fp)) mask_raw, data = utils.load_nifti(fp) data = preprocessing.threshold_mask(data) mask_new = utils.change_nifti_data(data, mask_raw, is_scan=False) mask_id = utils.parse_image_id_from_filepath(fp) fp_new = os.path.join(masks_out_dp, f'{mask_id}_{postfix}.nii.gz') utils.store_nifti_to_file(mask_new, fp_new) pbar.update()
def mask_matiere_blanche(filename): fa = utils.load_nifti(filename) data = fa.get_data() mask = np.zeros(data.shape) for i in range(data.shape[0]): for j in range(data.shape[1]): for k in range(data.shape[2]): if data[i, j, k] > 0.15: mask[i, j, k] = 1 return mask
def _init_info(self): paths_dict = utils.get_files_dict(self._scans_dp, self._masks_dp, ids=self._img_ids) for cur_id, paths in paths_dict.items(): if self._img_ids is None or cur_id in self._img_ids: img_scan, _ = utils.load_nifti(paths['scan_fp'], load_data=False) img_mask, _ = utils.load_nifti(paths['mask_fp'], load_data=False) assert img_scan.shape == img_mask.shape, ( f'scan shape != mask shape. ' f'id: {cur_id}. ' f'scan shape: {img_scan.shape}, ' f'mask shape: {img_mask.shape}') paths['shape'] = img_scan.shape self._info = paths_dict
def validate(model): dice_coefs = [] for image_path, label_path in zip(df_val["image"], df_val["label"]): image = load_nifti(image_path) label = load_nifti(label_path) centers = [[], [], []] for img_len, len_out, center, n_tile in zip(image.shape, args.output_shape, centers, args.n_tiles): assert img_len < len_out * n_tile, "{} must be smaller than {} x {}".format( img_len, len_out, n_tile) stride = int((img_len - len_out) / (n_tile - 1)) center.append(len_out / 2) for i in range(n_tile - 2): center.append(center[-1] + stride) center.append(img_len - len_out / 2) output = np.zeros((dataset["n_classes"], ) + image.shape[:-1]) for x, y, z in itertools.product(*centers): patch = crop_patch(image, [x, y, z], args.input_shape) patch = np.expand_dims(patch, 0) patch = xp.asarray(patch) slices_out = [ slice(center - len_out / 2, center + len_out / 2) for len_out, center in zip(args.output_shape, [x, y, z]) ] slices_in = [ slice((len_in - len_out) / 2, len_in - (len_in - len_out) / 2) for len_out, len_in, in zip(args.output_shape, args.input_shape) ] output[slice(None), slices_out[0], slices_out[1], slices_out[2]] += chainer.cuda.to_cpu( model(patch).data[0, slice(None), slices_in[0], slices_in[1], slices_in[2]]) y = np.argmax(output, axis=0).astype(np.int32) dice_coefs.append( dice_coefficients(y, label, labels=range(dataset["n_classes"]))) dice_coefs = np.array(dice_coefs) return np.mean(dice_coefs, axis=0)
def fix_resegm_masks(resegm_filenames, fixed_dp): if os.path.isdir(fixed_dp): print(f'removing directory with fixed scans: {fixed_dp}') shutil.rmtree(fixed_dp) os.makedirs(fixed_dp) pat = r'([^/]+)(.nii.gz)$' for fn in tqdm.tqdm(resegm_filenames.values()): img, img_data = utils.load_nifti(fn, load_data=False) new_affine = utils.diagonal_abs(img.affine) new_data = np.flip(img_data, axis=0) new_nii = nibabel.Nifti1Image(new_data, new_affine) new_fp = os.path.join(fixed_dp, '_fixed'.join(re.search(pat, fn).groups())) new_nii.to_filename(new_fp)
def __getitem__(self, idx): """Return the image as a numpy array and the label.""" label = self.labels[idx] struct_arr = utils.load_nifti(self.filenames[idx], mask=self.mask) # TDOO: Try normalizing each image to mean 0 and std 1 here. #struct_arr = (struct_arr - struct_arr.mean()) / (struct_arr.std() + 1e-10) struct_arr = (struct_arr - self.mean) / ( self.std + 1e-10) # prevent 0 division by adding small factor struct_arr = struct_arr[None] # add (empty) channel dimension struct_arr = torch.FloatTensor(struct_arr) if self.transform is not None: struct_arr = self.transform(struct_arr) return struct_arr, label
from sklearn.model_selection import train_test_split import multiprocessing import json import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torch.autograd import Variable from torch.utils.data import Dataset, DataLoader import torchvision from tabulate import tabulate # Binary brain mask used to cut out the skull. mask = utils.load_nifti('data/icbm_mask.nii.gz') # ------------------------- ADNI data tables ----------------------------------- # Ritter/Haynes lab file system at BCCN Berlin. #ADNI_DIR = '/analysis/share/ADNI' # Local. ADNI_DIR = 'data/ADNI' # Filepaths for 3 Tesla scans. table_3T = os.path.join( ADNI_DIR, 'ADNI_tables/customized/DxByImgClean_CompleteAnnual2YearVisitList_3T.csv') image_dir_3T = os.path.join(ADNI_DIR, 'ADNI_2Yr_3T_preprocessed') corrupt_images_3T = ['67380']
def store_as_numpy_dataset(self, out_dp: str, zoom_factor: float): """ Convert Nifti images to numpy nd.arrays and store them to .npy files to save time on probably time-expensive zoom. """ print(const.SEPARATOR) print('NiftiDataset.store_as_numpy_dataset():') print(f'\nout_dp: {out_dp}') print(f'zoom_factor: {zoom_factor}') if os.path.isdir(out_dp): print( f'\noutput dir "{out_dp}" already exists. \nwill remove and create a new one.' ) shutil.rmtree(out_dp) numpy_scans_dp = os.path.join(out_dp, 'numpy', 'scans') numpy_masks_dp = os.path.join(out_dp, 'numpy', 'masks') nifti_dp = os.path.join(out_dp, 'nifti') os.makedirs(numpy_scans_dp, exist_ok=True) os.makedirs(numpy_masks_dp, exist_ok=True) os.makedirs(nifti_dp, exist_ok=True) # store shapes dict for NumpyDataset shapes_dict = {k: v['shape'] for (k, v) in self._info.items()} shapes_dict_fp = os.path.join(out_dp, 'numpy', 'shapes.pickle') with open(shapes_dict_fp, 'wb') as fout: pickle.dump(shapes_dict, fout) # process and store scans with masks with tqdm.tqdm(total=len(self._info), unit='scan', bar_format=const.TQDM_BAR_FORMAT) as pbar: for cur_id, cur_info in self._info.items(): pbar.set_description( f'image: {cur_id}. shape: {cur_info["shape"]}') scan_img, scan_data = utils.load_nifti(cur_info['scan_fp']) mask_img, mask_data = utils.load_nifti(cur_info['mask_fp']) # check raw mask mask_is_ok, msg = utils.validate_binary_mask(mask_data) if not mask_is_ok: raise ValueError(f'id: "{cur_id}". {msg}') # clip scan scan_data = preprocessing.clip_intensities(scan_data) # convert scan to np.int16 after clipping intensities if needed if scan_data.dtype != np.int16: print( f'\nWARNING: scan {cur_id} has {scan_data.dtype} dtype.\n' f'will convert to np.int16') scan_data = scan_data.astype(np.int16) # zoom scan and mask scan_data = preprocessing.zoom_volume_along_x_y( scan_data, zoom_factor) mask_data = preprocessing.zoom_volume_along_x_y( mask_data, zoom_factor) # check mask after all transformations mask_is_ok, msg = utils.validate_binary_mask(mask_data) if not mask_is_ok: raise ValueError(f'id: "{cur_id}". {msg}') # store numpy arrays to files utils.store_npy(os.path.join(numpy_scans_dp, f'{cur_id}.npy'), scan_data) utils.store_npy(os.path.join(numpy_masks_dp, f'{cur_id}.npy'), mask_data) # also store processed images to Nifti scan_img_new = utils.change_nifti_data(data_new=scan_data, nifti_original=scan_img, is_scan=True) mask_img_new = utils.change_nifti_data(data_new=mask_data, nifti_original=mask_img, is_scan=False) utils.store_nifti_to_file( scan_img_new, os.path.join(nifti_dp, f'{cur_id}.nii.gz')) utils.store_nifti_to_file( mask_img_new, os.path.join(nifti_dp, f'{cur_id}_autolungs.nii.gz')) pbar.update()
# On suit la direction principale la plus alignee jusqu'a sortir du masque streamline.extend(build_streamline(brain_mask, pos_depart, 0.5, [0.0, 0.0, 0.0])) # On inverse la streamline pour continuer de l'autre cote streamline.reverse() # On suit la direction principale dans l'autre sens streamline.extend(build_streamline(brain_mask, pos_depart, -0.5, [0.0, 0.0, 0.0])) # On ajoute la streamline au reseau if len(streamline) > 0: streamlines.append(streamline) return np.array(streamlines) if __name__ == "__main__": # On load l'image, le masque et on fixe le nombre de stream lines nb_streamline = 10000 direc_max = utils.load_nifti("_peaks.nii").get_data() brain_mask = mask_matiere_blanche('_tensor_fa.nii.gz') # Afin de palier au probleme d'interpolation on s'assure que le rebord est noir brain_mask[:, :, 0] = 0 # On effectue la tractographie et on sauveguarde les streamlines lines = tracto(brain_mask, direc_max, nb_streamline) utils.save_streamlines(lines, "tp3_data\\_streamline.trk")
fig.add_subplot(122) plt.title("RGB") plt.axis('off') plt.imshow(rgb[:, rgb.shape[1]/2, :], cmap=cm.gray) #sauvegarde plt.savefig(os.path.dirname(os.path.realpath(__file__)) + "\\.." + "\\Latex\\Images\\" + filename + ".png") plt.show() if __name__ == "__main__": # loading image and gradient table bvals_filename="tp3_data\\bvals2000" bvecs_filename="tp3_data\\bvecs2000" img = utils.load_nifti("dwi2000.nii.gz") bvals, bvecs = read_bvals_bvecs(bvals_filename, bvecs_filename) gtab = dp.data.gradient_table(bvals, bvecs) data = img.get_data() print('data.shape (%d, %d, %d, %d)' % data.shape) # Creating the mask maskdata, mask = median_otsu(data, 3, 1, False, vol_idx=range(10, 50), dilate=2) print('maskdata.shape (%d, %d, %d, %d)' % maskdata.shape) # Creating tensor model tenmodel = dti.TensorModel(gtab) tenfit = tenmodel.fit(maskdata) # Computing anisotropy measures print('Computing anisotropy measures (FA, RGB)')
def main(): parser = argparse.ArgumentParser( description="calculate class probabilities with VoxResNet") parser.add_argument("--input_file", "-i", type=str, help="input json file of test dataset") parser.add_argument("--output_suffix", "-o", type=str, help="result of the segmentation") parser.add_argument( "--model", "-m", type=str, help="a file containing parameters of trained VoxResNet") parser.add_argument( "--input_shape", type=int, nargs="*", action="store", default=[80, 80, 80], help="input patch shape of VoxResNet, default=[80, 80, 80]") parser.add_argument( "--output_shape", type=int, nargs="*", action="store", default=[60, 60, 60], help="output patch shape of VoxResNet, default=[60, 60, 60]") parser.add_argument("--gpu", "-g", default=-1, type=int, help="negative value indicates no gpu, default=-1") parser.add_argument("--n_tiles", type=int, nargs="*", action="store", default=[5, 5, 5], help="number of tiles along each axis") args = parser.parse_args() print(args) with open(args.input_file) as f: dataset = json.load(f) test_df = pd.DataFrame(dataset["data"]) vrn = VoxResNet(dataset["in_channels"], dataset["n_classes"]) chainer.serializers.load_npz(args.model, vrn) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() vrn.to_gpu() for image_path, subject in zip(test_df["image"], test_df["subject"]): image, affine = load_nifti(image_path, with_affine=True) output = feedforward(vrn, image, args.input_shape, args.output_shape, args.n_tiles, dataset["n_classes"]) output /= np.sum(output, axis=0, keepdims=True) nib.save( nib.Nifti1Image(np.float32(output).transpose(1, 2, 3, 0), affine), os.path.join(os.path.dirname(image_path), subject + args.output_suffix))
from sklearn.model_selection import train_test_split import multiprocessing import json import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torch.autograd import Variable from torch.utils.data import Dataset, DataLoader import torchvision from tabulate import tabulate # Binary brain mask used to cut out the skull. mask = utils.load_nifti('data/binary_brain_mask.nii.gz') # ------------------------- ADNI data tables ----------------------------------- # Ritter/Haynes lab file system at BCCN Berlin. #ADNI_DIR = '/analysis/share/ADNI' # Local. ADNI_DIR = 'data/ADNI' # Filepaths for 3 Tesla scans. table_3T = os.path.join( ADNI_DIR, 'ADNI_tables/customized/DxByImgClean_CompleteAnnual2YearVisitList_3T.csv') image_dir_3T = os.path.join(ADNI_DIR, 'ADNI_2Yr_3T_preprocessed') corrupt_images_3T = [
def main(): parser = argparse.ArgumentParser(description="segment with VoxResNet") parser.add_argument("--input_file", "-i", type=str, help="input json file of test dataset") parser.add_argument( "--output_suffix", "-o", type=str, default="_segTRI_predict.nii.gz", help="result of the segmentation, default=_segTRI_predict.nii.gz") parser.add_argument( "--model", "-m", type=str, help="a file containing parameters of trained VoxResNet") parser.add_argument( "--input_shape", type=int, nargs="*", action="store", default=[80, 80, 80], help="input patch shape of VoxResNet, default=[80, 80, 80]") parser.add_argument( "--output_shape", type=int, nargs="*", action="store", default=[60, 60, 60], help="output patch shape of VoxResNet, default=[60, 60, 60]") parser.add_argument("--gpu", "-g", default=-1, type=int, help="negative value indicates no gpu, default=-1") parser.add_argument( "--n_tiles", type=int, nargs="*", action="store", default=[5, 5, 5], help="number of tiles along each axis, default=[5, 5, 5]") args = parser.parse_args() print(args) with open(args.input_file) as f: dataset = json.load(f) test_df = pd.DataFrame(dataset["data"]) vrn = VoxResNet(dataset["in_channels"], dataset["n_classes"]) chainer.serializers.load_npz(args.model, vrn) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() vrn.to_gpu() xp = chainer.cuda.cupy else: xp = np for image_path, subject in zip(test_df["image"], test_df["subject"]): image, affine = load_nifti(image_path, with_affine=True) centers = [[], [], []] for img_len, len_out, center, n_tile in zip(image.shape, args.output_shape, centers, args.n_tiles): assert img_len < len_out * n_tile, "{} must be smaller than {} x {}".format( img_len, len_out, n_tile) stride = int((img_len - len_out) / (n_tile - 1)) center.append(len_out / 2) for i in range(n_tile - 2): center.append(center[-1] + stride) center.append(img_len - len_out / 2) output = np.zeros((dataset["n_classes"], ) + image.shape[:-1]) for x, y, z in itertools.product(*centers): patch = crop_patch(image, [x, y, z], args.input_shape) patch = np.expand_dims(patch, 0) patch = xp.asarray(patch) slices_out = [ slice(center - len_out / 2, center + len_out / 2) for len_out, center in zip(args.output_shape, [x, y, z]) ] slices_in = [ slice((len_in - len_out) / 2, len_in - (len_in - len_out) / 2) for len_out, len_in, in zip(args.output_shape, args.input_shape) ] output[slice(None), slices_out[0], slices_out[1], slices_out[2]] += chainer.cuda.to_cpu( vrn(patch).data[0, slice(None), slices_in[0], slices_in[1], slices_in[2]]) y = np.argmax(output, axis=0) nib.save( nib.Nifti1Image(np.int32(y), affine), os.path.join(os.path.dirname(image_path), subject + args.output_suffix))
pos_depart = (np.random.randint(brain_mask.shape[0]), np.random.randint(brain_mask.shape[1]), np.random.randint(brain_mask.shape[2])) streamline.append(pos_depart) # On suit la direction principale la plus alignee jusqu'a sortir du masque streamline.extend(build_streamline(brain_mask, pos_depart, 0.5, [0.0, 0.0, 0.0])) # On inverse la streamline pour continuer de l'autre cote streamline.reverse() # On suit la direction principale dans l'autre sens] streamline.extend(build_streamline(brain_mask, pos_depart, -0.5, [0.0, 0.0, 0.0])) # Si on a trouve une streamline on l'ajoute a la liste finale if len(streamline) > 0: streamlines.append(np.array(streamline)) return np.array(streamlines) if __name__ == "__main__": # On load l'image, le masque et on fixe le nombre de stream lines nb_streamline = 30000 direc_max = utils.load_nifti("_fodfpeaks.nii.gz").get_data() brain_mask = mask_matiere_blanche('_tensor_fa.nii.gz') # Afin de palier au probleme d'interpolation on s'assure que le rebord est noir brain_mask[:, :, 0] = 0 # On effectue la tractographie et on sauveguarde les streamlines lines= tracto(brain_mask, direc_max, nb_streamline) utils.save_streamlines(lines, "tp3_data\\_streamline_fodf.trk")
tensorboard_callback, cp_callback, stop_callback ]) # evaluate on the test and val sets test_loss = model.evaluate(test_dataset) #cc_mean_test[layernum][kernum][filtnum] = test_loss[2] cc_mean_test_1D[count] = test_loss[2] val_loss = model.evaluate(valid_dataset) #cc_mean_val[layernum][kernum][filtnum] = val_loss[2] cc_mean_val_1D[count] = val_loss[2] # predict on test data predicted_batch = model.predict(test_dataset) test_batch = load_nifti(TEST_SUBIDS, rootpath=DATA_PATH, labelname=TASK_FILE_NAME, labelnum=TASK_FILE_NUM) save_prediction(predicted_batch=predicted_batch, rootpath=DATA_PATH, outpath=OUT_PATH, labelname=TASK_FILE_NAME, labelnum=TASK_FILE_NUM, template_subID=TEST_SUBIDS[0], subIDs=TEST_SUBIDS) cc = act_pred_corr(predicted_batch, test_batch) print(np.mean(np.diagonal(cc))) # cc_norm = normalize(cc,axis=0) # cc_norm = normalize(cc_norm,axis=1) # plt.subplot(1, 2, 1) # plt.imshow(cc,cmap="jet")
def segment_scans(self, checkpoint_fp: str, scans_dp: str, postfix: str, ids: List[str] = None, output_dp: str = None): """ :param checkpoint_fp: path to .pth file with net's params dict :param scans_dp: path directory with .nii.gz scans. will check that scans do not have any postfixes in their filenames. :param postfix: postfix of segmented filenames :param ids: list of image ids to consider. if None segment all scans under `scans_dp` :param output_dp: path to directory to store results of segmentation """ utils.check_var_to_be_iterable_collection(ids) print(const.SEPARATOR) print('Pipeline.segment_scans()') output_dp = output_dp or const.SEGMENTED_DN print(f'will store segmented masks under "{output_dp}"') os.makedirs(output_dp, exist_ok=True) print(f'postfix: {postfix}') self.load_net_from_weights(checkpoint_fp) scans_fps = utils.get_nii_gz_filepaths(scans_dp) print(f'# of .nii.gz files under "{scans_dp}": {len(scans_fps)}') # filter filepaths to scans scans_fps_filtered = [] for fp in scans_fps: img_id, img_postfix = utils.parse_image_id_from_filepath( fp, get_postfix=True) if img_postfix != '' or ids is not None and img_id not in ids: continue scans_fps_filtered.append(fp) print(f'# of scans left after filtering: {len(scans_fps_filtered)}') print('\nstarting segmentation...') time_start_segmentation = time.time() with tqdm.tqdm(total=len(scans_fps_filtered)) as pbar: for fp in scans_fps_filtered: cur_id = utils.parse_image_id_from_filepath(fp) pbar.set_description(cur_id) scan_nifti, scan_data = utils.load_nifti(fp) # clip intensities as during training scan_data_clipped = preprocessing.clip_intensities(scan_data) segmented_data = mu.segment_single_scan( scan_data_clipped, self.net, self.device) segmented_nifti = utils.change_nifti_data(segmented_data, scan_nifti, is_scan=False) out_fp = os.path.join(output_dp, f'{cur_id}_{postfix}.nii.gz') utils.store_nifti_to_file(segmented_nifti, out_fp) pbar.update() print( f'\nsegmentation ended. elapsed time: {utils.get_elapsed_time_str(time_start_segmentation)}' ) utils.print_cuda_memory_stats(self.device)
import matplotlib.pyplot as plt import matplotlib.cm as cm import os import nibabel as nib import numpy as np from dipy.segment.mask import median_otsu import utils if __name__ == "__main__": img = utils.load_nifti('b0.nii.gz') data = img.get_data() # b0_mask, mask = median_otsu(data, 2, 1) # b0_mask, mask = median_otsu(data, 3, 1) # b0_mask, mask = median_otsu(data, 1, 2) # b0_mask, mask = median_otsu(data, 1, 3) # b0_mask, mask = median_otsu(data, 3, 2) # b0_mask, mask = median_otsu(data, 2, 3) b0_mask, mask1 = median_otsu(data, 1, 1) b0_mask, mask2 = median_otsu(data, 4, 2) # parametres retenues b0_mask, mask = median_otsu(data, 2, 2) fig = plt.figure() fig.add_subplot(221) plt.title("Image") plt.axis('off') plt.imshow(data[data.shape[0]/2, :, :], cmap=cm.gray) fig.add_subplot(222)
def image_shape(self): """The shape of the MRI images.""" return utils.load_nifti(self.filenames[0], mask=mask).shape
with open(args.input_file) as f: dataset = json.load(f) test_df = pd.DataFrame(dataset["data"]) vrn = VoxResNet(dataset["in_channels"], dataset["n_classes"]) chainer.serializers.load_npz(args.model, vrn) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() vrn.to_gpu() xp = chainer.cuda.cupy else: xp = np for image_path, subject in zip(test_df["image"], test_df["subject"]): image, affine = load_nifti(image_path, with_affine=True) centers = [[], [], []] for img_len, len_out, center, n_tile in zip(image.shape, args.output_shape, centers, args.n_tiles): assert img_len < len_out * n_tile, "{} must be smaller than {} x {}".format( img_len, len_out, n_tile) stride = int((img_len - len_out) / (n_tile - 1)) center.append(len_out / 2) for i in range(n_tile - 2): center.append(center[-1] + stride) center.append(img_len - len_out / 2) output = np.zeros((dataset["n_classes"], ) + image.shape[:-1]) for x, y, z in itertools.product(*centers): patch = crop_patch(image, [x, y, z], args.input_shape) patch = np.expand_dims(patch, 0) patch = xp.asarray(patch)
def get_raw_image(self, idx): """Return the raw image at index idx (i.e. not normalized, no color channel, no transform.""" return utils.load_nifti(self.filenames[idx], mask=self.mask)
from dipy.io.gradients import read_bvals_bvecs from dipy.core.gradients import gradient_table import nibabel as nib import numpy as np import dipy.reconst.dti as dti import utils if __name__ == "__main__": # loading image and gradient table bvals, bvecs = read_bvals_bvecs("tp3_data\\bvals2000", "tp3_data\\bvecs2000") gtab = gradient_table(bvals, bvecs) img = utils.load_nifti("dwi2000.nii.gz") ##### utilisation d'un mask pour le calcul du tenseur tenmodel = dti.TensorModel(gtab) brain_mask = nib.load("tp3_data\\_mask.nii.gz").get_data() tenfit = tenmodel.fit(img.get_data(), mask=brain_mask) ##### sauvegarde des orientations principales peaks_fiberNav = np.zeros((112, 112, 60, 15), dtype='float32') peaks_fiberNav[:, :, :, 0:3] = tenfit.evecs[..., 0].astype(np.float32) nib.save(nib.Nifti1Image(peaks_fiberNav, img.get_affine()), "tp3_data\\_peaks") ##### sauvegarde des tenseurs from dipy.reconst.dti import lower_triangular tensor_vals = lower_triangular(tenfit.quadratic_form) correct_order = [0, 1, 3, 2, 4, 5] tensor_vals_reordered = tensor_vals[..., correct_order] fiber_tensors = nib.Nifti1Image(tensor_vals_reordered.astype(np.float32), img.get_affine()) nib.save(fiber_tensors, "tp3_data\\_tensor")