def get_for_subses(self, subses_dict, reg_subject, reg_template, subject_sls=None, template_sls=None): mapping_file, meta_fname = self.get_fnames(self.extension, subses_dict) if self.use_prealign: reg_prealign = np.load( self.prealign(subses_dict, reg_subject, reg_template)) else: reg_prealign = None if not op.exists(mapping_file): start_time = time() mapping = self.gen_mapping(subses_dict, reg_subject, reg_template, subject_sls, template_sls, reg_prealign) total_time = time() - start_time reg.write_mapping(mapping, mapping_file) meta = dict(type="displacementfield", timing=total_time) afd.write_json(meta_fname, meta) if self.use_prealign: reg_prealign_inv = np.linalg.inv(reg_prealign) else: reg_prealign_inv = None mapping = reg.read_mapping(mapping_file, subses_dict['dwi_file'], reg_template, prealign=reg_prealign_inv) return mapping
def get_for_row(self, afq_object, row): mapping_file, meta_fname = self.get_fnames( self.extension, afq_object, row) if self.use_prealign: reg_prealign = np.load(self.prealign(afq_object, row)) else: reg_prealign = None if not op.exists(mapping_file): reg_template_img, reg_template_sls = \ afq_object._reg_img(afq_object.reg_template, False, row) reg_subject_img, reg_subject_sls = \ afq_object._reg_img(afq_object.reg_subject, True, row) start_time = time() mapping = self.gen_mapping( afq_object, row, reg_template_img, reg_template_sls, reg_subject_img, reg_subject_sls, reg_prealign) row['timing']['Registration'] =\ row['timing']['Registration'] + time() - start_time reg.write_mapping(mapping, mapping_file) meta = dict(type="displacementfield") afd.write_json(meta_fname, meta) if self.use_prealign: reg_prealign_inv = np.linalg.inv(reg_prealign) else: reg_prealign_inv = None mapping = reg.read_mapping( mapping_file, row['dwi_file'], afq_object.reg_template_img, prealign=reg_prealign_inv) return mapping
def _mapping(self, row): if self.use_prealign: mapping_file = self._get_fname( row, '_mapping_from-DWI_to_MNI_xfm.nii.gz') else: mapping_file = self._get_fname( row, '_mapping_from-DWI_to_MNI_xfm' + '_without_prealign.nii.gz') if self.force_recompute or not op.exists(mapping_file): gtab = row['gtab'] if self.use_prealign: reg_prealign = np.load(self._reg_prealign(row)) else: reg_prealign = None warped_b0, mapping = reg.syn_register_dwi( row['dwi_file'], gtab, template=self.reg_template, prealign=reg_prealign) if self.use_prealign: mapping.codomain_world2grid = np.linalg.inv(reg_prealign) reg.write_mapping(mapping, mapping_file) meta_fname = self._get_fname(row, '_mapping_reg_prealign.json') meta = dict(type="displacementfield") afd.write_json(meta_fname, meta) return mapping_file
def test_syn_registration(): with nbtmp.InTemporaryDirectory() as tmpdir: warped_moving, mapping = syn_registration(subset_b0, subset_t2, moving_affine=hardi_affine, static_affine=MNI_T2_affine, step_length=0.1, metric='CC', dim=3, level_iters=[5, 5, 5], sigma_diff=2.0, radius=1, prealign=None) npt.assert_equal(warped_moving.shape, subset_t2.shape) mapping_fname = op.join(tmpdir, 'mapping.nii.gz') write_mapping(mapping, mapping_fname) file_mapping = read_mapping(mapping_fname, subset_b0_img, subset_t2_img) # Test that it has the same effect on the data: warped_from_file = file_mapping.transform(subset_b0) npt.assert_equal(warped_from_file, warped_moving) # Test that it is, attribute by attribute, identical: for k in mapping.__dict__: assert (np.all( mapping.__getattribute__(k) == file_mapping.__getattribute__( k)))
def test_syn_registration(): with nbtmp.InTemporaryDirectory() as tmpdir: warped_moving, mapping = syn_registration(subset_b0, subset_t2, moving_affine=hardi_affine, static_affine=MNI_T2_affine, step_length=0.1, metric='CC', dim=3, level_iters=[10, 10, 5], sigma_diff=2.0, prealign=None) npt.assert_equal(warped_moving.shape, subset_t2.shape) mapping_fname = op.join(tmpdir, 'mapping.nii.gz') write_mapping(mapping, mapping_fname) file_mapping = read_mapping(mapping_fname, subset_b0_img, subset_t2_img) # Test that it has the same effect on the data: warped_from_file = file_mapping.transform(subset_b0) npt.assert_equal(warped_from_file, warped_moving) # Test that it is, attribute by attribute, identical: for k in mapping.__dict__: assert (np.all(mapping.__getattribute__(k) == file_mapping.__getattribute__(k)))
def _mapping(row, force_recompute=False): mapping_file = _get_fname(row, '_mapping.nii.gz') if not op.exists(mapping_file) or force_recompute: gtab = row['gtab'] reg_template = dpd.read_mni_template() mapping = reg.syn_register_dwi(row['dwi_file'], gtab, template=reg_template) reg.write_mapping(mapping, mapping_file) return mapping_file
def main(): with open('config.json') as config_json: config = json.load(config_json) data_file = str(config['data_file']) data_bval = str(config['data_bval']) data_bvec = str(config['data_bvec']) img = nib.load(data_file) print("Calculating DTI...") if not op.exists('./dti_FA.nii.gz'): dti_params = dti.fit_dti(data_file, data_bval, data_bvec, out_dir='.') else: dti_params = {'FA': './dti_FA.nii.gz', 'params': './dti_params.nii.gz'} tg = nib.streamlines.load('csa_prob.trk').tractogram streamlines = tg.apply_affine(np.linalg.inv(img.affine)).streamlines # Use only a small portion of the streamlines, for expedience: streamlines = streamlines[::100] templates = afd.read_templates() bundle_names = ["CST", "ILF"] bundles = {} for name in bundle_names: for hemi in ['_R', '_L']: bundles[name + hemi] = { 'ROIs': [ templates[name + '_roi1' + hemi], templates[name + '_roi1' + hemi] ], 'rules': [True, True] } print("Registering to template...") MNI_T2_img = dpd.read_mni_template() bvals, bvecs = read_bvals_bvecs(data_bval, data_bvec) gtab = gradient_table(bvals, bvecs, b0_threshold=100) mapping = reg.syn_register_dwi(data_file, gtab) reg.write_mapping(mapping, './mapping.nii.gz') print("Segmenting fiber groups...") fiber_groups = seg.segment(data_file, data_bval, data_bvec, streamlines, bundles, reg_template=MNI_T2_img, mapping=mapping, as_generator=False, affine=img.affine) """
def _mapping(row, reg_template, force_recompute=False): mapping_file = _get_fname(row, '_mapping.nii.gz') if not op.exists(mapping_file) or force_recompute: gtab = row['gtab'] reg_prealign = np.load( _reg_prealign(row, force_recompute=force_recompute)) warped_b0, mapping = reg.syn_register_dwi(row['dwi_file'], gtab, template=reg_template, prealign=reg_prealign) mapping.codomain_world2grid = np.linalg.inv(reg_prealign) reg.write_mapping(mapping, mapping_file) return mapping_file
def test_slr_registration(): # have to import subject sls file_dict = afd.read_stanford_hardi_tractography() streamlines = file_dict['tractography_subsampled.trk'] # have to import sls atlas afd.fetch_hcp_atlas_16_bundles() atlas_fname = op.join(afd.afq_home, 'hcp_atlas_16_bundles', 'Atlas_in_MNI_Space_16_bundles', 'whole_brain', 'whole_brain_MNI.trk') hcp_atlas = load_tractogram(atlas_fname, 'same', bbox_valid_check=False) with nbtmp.InTemporaryDirectory() as tmpdir: mapping = slr_registration(streamlines, hcp_atlas.streamlines, moving_affine=subset_b0_img.affine, static_affine=subset_t2_img.affine, moving_shape=subset_b0_img.shape, static_shape=subset_t2_img.shape, progressive=False, greater_than=10, rm_small_clusters=1, rng=np.random.RandomState(seed=8)) warped_moving = mapping.transform(subset_b0) npt.assert_equal(warped_moving.shape, subset_t2.shape) mapping_fname = op.join(tmpdir, 'mapping.npy') write_mapping(mapping, mapping_fname) file_mapping = read_mapping(mapping_fname, subset_b0_img, subset_t2_img) # Test that it has the same effect on the data: warped_from_file = file_mapping.transform(subset_b0) npt.assert_equal(warped_from_file, warped_moving) # Test that it is, attribute by attribute, identical: for k in mapping.__dict__: assert (np.all( mapping.__getattribute__(k) == file_mapping.__getattribute__( k)))
MNI_T2_img = afd.read_mni_template() if not op.exists(op.join(working_dir, 'mapping.nii.gz')): import dipy.core.gradients as dpg gtab = dpg.gradient_table(hardi_fbval, hardi_fbvec) b0 = np.mean(img.get_fdata()[..., gtab.b0s_mask], -1) # Prealign using affine registration _, prealign = affine_registration(b0, MNI_T2_img.get_fdata(), img.affine, MNI_T2_img.affine) # Then register using a non-linear registration using the affine for # prealignment warped_hardi, mapping = reg.syn_register_dwi(hardi_fdata, gtab, prealign=prealign) reg.write_mapping(mapping, op.join(working_dir, 'mapping.nii.gz')) else: mapping = reg.read_mapping(op.join(working_dir, 'mapping.nii.gz'), img, MNI_T2_img) ########################################################################## # Read in bundle specification # ------------------------------------------- # The waypoint ROIs, in addition to bundle probability maps are stored in this # data structure. The templates are first resampled into the MNI space, before # they are brought into the subject's individual native space. # For speed, we only segment two bundles here. bundles = api.BundleDict(["CST", "ARC"], resample_to=MNI_T2_img) ##########################################################################
out_dir='.') else: dti_params = {'FA': './dti_FA.nii.gz', 'params': './dti_params.nii.gz'} FA_img = nib.load(dti_params['FA']) FA_data = FA_img.get_fdata() print("Registering to template...") MNI_T2_img = afd.read_mni_template() if not op.exists('mapping.nii.gz'): import dipy.core.gradients as dpg gtab = dpg.gradient_table(hardi_fbval, hardi_fbvec) warped_hardi, mapping = reg.syn_register_dwi(hardi_fdata, gtab, template=MNI_T2_img) reg.write_mapping(mapping, './mapping.nii.gz') else: mapping = reg.read_mapping('./mapping.nii.gz', img, MNI_T2_img) bundle_names = ["CST", "UF", "CC_ForcepsMajor", "CC_ForcepsMinor"] bundles = api.make_bundle_dict(bundle_names=bundle_names, seg_algo="reco") print("Tracking...") if not op.exists('dti_streamlines_reco.trk'): seed_roi = np.zeros(img.shape[:-1]) for bundle in bundles: if bundle != 'whole_brain': sl_xform = dts.Streamlines( dtu.transform_tracking_output(bundles[bundle]['sl'], MNI_T2_img.affine))
dti_params = dti.fit_dti(fdata, fbval, fbvec, out_dir='.', mask=brain_mask) else: dti_params = {'FA': './dti_FA.nii.gz', 'MD': './dti_MD.nii.gz', 'RD': './dti_RD.nii.gz', 'AD': './dti_AD.nii.gz', 'params': './dti_params.nii.gz'} print("Registering to template...") MNI_T2_img = dpd.read_mni_template() if not op.exists('mapping.nii.gz'): import dipy.core.gradients as dpg gtab = dpg.gradient_table(fbval, fbvec) mapping = reg.syn_register_dwi(fdata, gtab) reg.write_mapping(mapping, './mapping.nii.gz') else: mapping = reg.read_mapping('./mapping.nii.gz', img, MNI_T2_img) print("Tracking...") if not op.exists('dti_streamlines.trk'): FA = nib.load(dti_params["FA"]).get_data() wm_mask = np.zeros_like(FA) wm_mask[FA > 0.2] = 1 step_size = 1 min_length_mm = 50 streamlines = dts.Streamlines( aft.track(dti_params['params'], directions="det", seed_mask=wm_mask, seeds=2,
def main(): with open('config.json') as config_json: config = json.load(config_json) #Paths to data data_file = str(config['data_file']) data_bval = str(config['data_bval']) data_bvec = str(config['data_bvec']) img = nib.load(data_file) """ print("Calculating DTI...") if not op.exists('./dti_FA.nii.gz'): dti_params = dti.fit_dti(data_file, data_bval, data_bvec, out_dir='.') else: dti_params = {'FA': './dti_FA.nii.gz', 'params': './dti_params.nii.gz'} """ #tg = nib.streamlines.load('track.trk').tractogram tg = nib.streamlines.load(config['tck_data']).tractogram streamlines = tg.apply_affine(np.linalg.inv(img.affine)).streamlines # Use only a small portion of the streamlines, for expedience: #streamlines = streamlines[::100] templates = afd.read_templates() bundle_names = ["CST", "ILF"] bundles = {} for name in bundle_names: for hemi in ['_R', '_L']: bundles[name + hemi] = { 'ROIs': [ templates[name + '_roi1' + hemi], templates[name + '_roi1' + hemi] ], 'rules': [True, True] } print("Registering to template...") if not op.exists('mapping.nii.gz'): gtab = gradient_table(data_bval, data_bvec) mapping = reg.syn_register_dwi(data_file, gtab) reg.write_mapping(mapping, './mapping.nii.gz') else: mapping = reg.read_mapping('./mapping.nii.gz', img, MNI_T2_img) """ MNI_T2_img = dpd.read_mni_template() bvals, bvecs = read_bvals_bvecs(data_bval, data_bvec) gtab = gradient_table(bvals, bvecs, b0_threshold=100) mapping = reg.syn_register_dwi(data_file, gtab) reg.write_mapping(mapping, './mapping.nii.gz') """ print("Segmenting fiber groups...") fiber_groups = seg.segment(data_file, data_bval, data_bvec, streamlines, bundles, reg_template=MNI_T2_img, mapping=mapping, as_generator=False, affine=img.affine) path = os.getcwd() + '/tract1/' if not os.path.exists(path): os.makedirs(path) for fg in fiber_groups: streamlines = fiber_groups[fg] fname = fg + ".tck" trg = nib.streamlines.Tractogram(streamlines, affine_to_rasmm=img.affine) nib.streamlines.save(trg, path + fname)