def export_rois(subses_dict, bundle_dict, mapping, dwi_affine):
rois_dir = op.join(subses_dict['results_dir'], 'ROIs')
os.makedirs(rois_dir, exist_ok=True)
roi_files = {}
for bundle in bundle_dict:
roi_files[bundle] = []
for ii, roi in enumerate(bundle_dict[bundle]['ROIs']):
if bundle_dict[bundle]['rules'][ii]:
inclusion = 'include'
else:
inclusion = 'exclude'
fname = op.split(
get_fname(
subses_dict,
f'_desc-ROI-{bundle}-{ii + 1}-{inclusion}.nii.gz'))
fname = op.join(rois_dir, fname[1])
if not op.exists(fname):
warped_roi = auv.transform_inverse_roi(
roi,
mapping,
bundle_name=bundle)
# Cast to float32, so that it can be read in by MI-Brain:
logger.info(f"Saving {fname}")
nib.save(
nib.Nifti1Image(
warped_roi.astype(np.float32),
dwi_affine), fname)
meta = dict()
meta_fname = fname.split('.')[0] + '.json'
afd.write_json(meta_fname, meta)
roi_files[bundle].append(fname)
return {'rois_file': roi_files}
def get_mask(self, afq_object, row):
if afq_object.use_prealign:
reg_prealign = np.load(afq_object._reg_prealign(row))
reg_prealign_inv = np.linalg.inv(reg_prealign)
else:
reg_prealign_inv = None
mapping = reg.read_mapping(
afq_object._mapping(row),
row['dwi_file'],
afq_object.reg_template_img,
prealign=reg_prealign_inv)
mask_data = None
for bundle_name, bundle_info in afq_object.bundle_dict.items():
for idx, roi in enumerate(bundle_info['ROIs']):
if afq_object.bundle_dict[bundle_name]['rules'][idx]:
warped_roi = auv.transform_inverse_roi(
roi,
mapping,
bundle_name=bundle_name)
if mask_data is None:
mask_data = np.zeros(warped_roi.shape)
mask_data = np.logical_or(
mask_data,
warped_roi.astype(bool))
return mask_data, afq_object["dwi_affine"], dict(source="ROIs")
def mask_getter(subses_dict, dwi_affine, mapping_imap, bundle_dict,
segmentation_params):
mask_data = None
if self.use_presegment:
bundle_dict = \
segmentation_params["presegment_bundle_dict"]
else:
bundle_dict = bundle_dict
for bundle_name, bundle_info in bundle_dict.items():
for idx, roi in enumerate(bundle_info['ROIs']):
if bundle_dict[bundle_name]['rules'][idx]:
warped_roi = auv.transform_inverse_roi(
roi,
mapping_imap["mapping"],
bundle_name=bundle_name)
if mask_data is None:
mask_data = np.zeros(warped_roi.shape)
mask_data = np.logical_or(mask_data,
warped_roi.astype(bool))
return mask_data, dict(source="ROIs")
bundles = api.BundleDict(["CST", "ARC"], resample_to=MNI_T2_img)
##########################################################################
# Tracking
# --------
# Streamlines are generate using DTI and a deterministic tractography
# algorithm. For speed, we seed only within the waypoint ROIs for each bundle.
print("Tracking...")
if not op.exists(op.join(working_dir, 'dti_streamlines.trk')):
seed_roi = np.zeros(img.shape[:-1])
for bundle in bundles:
for idx, roi in enumerate(bundles[bundle]['ROIs']):
if bundles[bundle]['rules'][idx]:
warped_roi = transform_inverse_roi(roi,
mapping,
bundle_name=bundle)
nib.save(nib.Nifti1Image(warped_roi.astype(float), img.affine),
op.join(working_dir, f"{bundle}_{idx+1}.nii.gz"))
# Add voxels that aren't there yet:
seed_roi = np.logical_or(seed_roi, warped_roi)
nib.save(nib.Nifti1Image(seed_roi.astype(float), img.affine),
op.join(working_dir, 'seed_roi.nii.gz'))
sft = aft.track(dti_params['params'],
seed_mask=seed_roi,
stop_mask=FA_data,
stop_threshold=0.1)
save_tractogram(sft,
op.join(working_dir, 'dti_streamlines.trk'),
bbox_valid_check=False)
def viz_indivBundle(subses_dict,
dwi_affine,
viz_backend,
bundle_dict,
data_imap,
mapping_imap,
segmentation_imap,
tracking_params,
segmentation_params,
reg_template,
best_scalar,
xform_volume_indiv=False,
cbv_lims_indiv=[None, None],
xform_color_by_volume_indiv=False,
volume_opacity_indiv=0.3,
n_points_indiv=40):
mapping = mapping_imap["mapping"]
scalar_dict = segmentation_imap["scalar_dict"]
volume = data_imap["b0_file"]
color_by_volume = data_imap[best_scalar + "_file"]
start_time = time()
volume = _viz_prepare_vol(
volume, xform_volume_indiv, mapping, scalar_dict)
color_by_volume = _viz_prepare_vol(
color_by_volume, xform_color_by_volume_indiv, mapping, scalar_dict)
flip_axes = [False, False, False]
for i in range(3):
flip_axes[i] = (dwi_affine[i, i] < 0)
bundle_names = bundle_dict.keys()
for bundle_name in bundle_names:
logger.info(f"Generating {bundle_name} visualization...")
uid = bundle_dict[bundle_name]['uid']
figure = viz_backend.visualize_volume(
volume,
opacity=volume_opacity_indiv,
flip_axes=flip_axes,
interact=False,
inline=False)
try:
figure = viz_backend.visualize_bundles(
segmentation_imap["clean_bundles_file"],
color_by_volume=color_by_volume,
cbv_lims=cbv_lims_indiv,
bundle_dict=bundle_dict,
bundle=uid,
n_points=n_points_indiv,
flip_axes=flip_axes,
interact=False,
inline=False,
figure=figure)
except ValueError:
logger.info(
"No streamlines found to visualize for "
+ bundle_name)
if segmentation_params["filter_by_endpoints"]:
warped_rois = []
endpoint_info = segmentation_params["endpoint_info"]
if endpoint_info is not None:
start_p = endpoint_info[bundle_name]['startpoint']
end_p = endpoint_info[bundle_name]['endpoint']
for pp in [start_p, end_p]:
pp = resample(
pp.get_fdata(),
reg_template,
pp.affine,
reg_template.affine).get_fdata()
atlas_roi = np.zeros(pp.shape)
atlas_roi[np.where(pp > 0)] = 1
warped_roi = auv.transform_inverse_roi(
atlas_roi,
mapping,
bundle_name=bundle_name)
warped_rois.append(warped_roi)
else:
aal_atlas = afd.read_aal_atlas(reg_template)
atlas = aal_atlas['atlas'].get_fdata()
aal_targets = afd.bundles_to_aal(
[bundle_name], atlas=atlas)[0]
for targ in aal_targets:
if targ is not None:
aal_roi = np.zeros(atlas.shape[:3])
aal_roi[targ[:, 0],
targ[:, 1],
targ[:, 2]] = 1
warped_roi = auv.transform_inverse_roi(
aal_roi,
mapping,
bundle_name=bundle_name)
warped_rois.append(warped_roi)
for i, roi in enumerate(warped_rois):
figure = viz_backend.visualize_roi(
roi,
name=f"{bundle_name} endpoint ROI {i}",
flip_axes=flip_axes,
inline=False,
interact=False,
figure=figure)
for i, roi in enumerate(mapping_imap["rois_file"][bundle_name]):
figure = viz_backend.visualize_roi(
roi,
name=f"{bundle_name} ROI {i}",
flip_axes=flip_axes,
inline=False,
interact=False,
figure=figure)
roi_dir = op.join(subses_dict['results_dir'], 'viz_bundles')
os.makedirs(roi_dir, exist_ok=True)
if "no_gif" not in viz_backend.backend:
fname = op.split(
get_fname(
subses_dict,
f'_{bundle_name}'
f'_viz.gif',
tracking_params=tracking_params,
segmentation_params=segmentation_params))
fname = op.join(roi_dir, fname[1])
viz_backend.create_gif(figure, fname)
if "plotly" in viz_backend.backend:
roi_dir = op.join(subses_dict['results_dir'], 'viz_bundles')
os.makedirs(roi_dir, exist_ok=True)
fname = op.split(
get_fname(
subses_dict,
f'_{bundle_name}'
f'_viz.html',
tracking_params=tracking_params,
segmentation_params=segmentation_params))
fname = op.join(roi_dir, fname[1])
figure.write_html(fname)
meta_fname = get_fname(
subses_dict, '_vizIndiv.json',
tracking_params=tracking_params,
segmentation_params=segmentation_params)
meta = dict(Timing=time() - start_time)
afd.write_json(meta_fname, meta)
return True