def test_streams2graph(fa_wei):
from dipy.core.gradients import gradient_table
from dipy.io import save_pickle
base_dir = str(Path(__file__).parent/"examples")
dwi_file = f"{base_dir}/003/test_out/003/dwi/sub-003_dwi_reor-RAS_res-2mm.nii.gz"
conn_model = 'csd'
min_length = 10
error_margin = 2
directget = 'prob'
track_type = 'particle'
target_samples = 500
overlap_thr = 1
min_span_tree = True
prune = 3
norm = 6
binary = False
roi = f"{base_dir}/miscellaneous/pDMN_3_bin.nii.gz"
network = 'Default'
ID = '003'
parc = True
disp_filt = False
node_size = None
dens_thresh = False
atlas = 'whole_brain_cluster_labels_PCA200'
uatlas = None
coord_file_path = f"{base_dir}/miscellaneous/Default_func_coords_wb.pkl"
coord_file = open(coord_file_path, 'rb')
coords = pickle.load(coord_file)
labels_file_path = f"{base_dir}/miscellaneous/Default_func_labelnames_wb.pkl"
labels_file = open(labels_file_path, 'rb')
labels = pickle.load(labels_file)
# Not actually normalized to mni-space in this test.
atlas_mni = f"{base_dir}/003/dmri/whole_brain_cluster_labels_PCA200_dwi_track.nii.gz"
streams = f"{base_dir}/miscellaneous/003_streamlines_est-csd_nodetype-parc_samples-1000streams_tt-particle_dg-prob_ml-10.trk"
B0_mask = f"{base_dir}/003/anat/mean_B0_bet_mask_tmp.nii.gz"
dir_path = f"{base_dir}/003/dmri"
bvals = f"{dir_path}/sub-003_dwi.bval"
bvecs = f"{base_dir}/003/test_out/003/dwi/bvecs_reor.bvec"
gtab_file = f"{base_dir}/gtab.pkl"
gtab = gradient_table(bvals, bvecs)
gtab.b0_threshold = 50
gtab_bvals = gtab.bvals.copy()
b0_thr_ixs = np.where(gtab_bvals < gtab.b0_threshold)[0]
gtab_bvals[b0_thr_ixs] = 0
gtab.b0s_mask = gtab_bvals == 0
save_pickle(gtab_file, gtab)
# Not actually normalized to mni-space in this test.
warped_fa = tens_mod_fa_est(gtab_file, dwi_file, B0_mask)[0]
conn_matrix = streams2graph(atlas_mni, streams, overlap_thr, dir_path, track_type, target_samples,
conn_model, network, node_size, dens_thresh, ID, roi, min_span_tree,
disp_filt, parc, prune, atlas, uatlas, labels, coords, norm, binary,
directget, warped_fa, error_margin, min_length, fa_wei)[2]
assert conn_matrix is not None
def test_tens_mod_fa_est(dmri_estimation_data):
"""Test tensor FA image estimation."""
gtab = dmri_estimation_data['gtab']
dwi_img = dmri_estimation_data['dwi_img']
B0_mask_img = dmri_estimation_data['B0_mask_img']
gtab_file = tempfile.NamedTemporaryFile(mode='w+', suffix='.pkl')
dwi_file = tempfile.NamedTemporaryFile(mode='w+', suffix='.nii.gz')
B0_mask_file = tempfile.NamedTemporaryFile(mode='w+', suffix='.nii.gz')
save_pickle(gtab_file.name, gtab)
nib.save(dwi_img, dwi_file.name)
nib.save(B0_mask_img, B0_mask_file.name)
[fa_path, _, _, _] = \
tens_mod_fa_est(gtab_file.name, dwi_file.name, B0_mask_file.name)
assert os.path.isfile(fa_path)
gtab_file.close()
dwi_file.close()
B0_mask_file.close()
def test_create_anisopowermap(dmri_estimation_data):
""" Test creating an anisotropic power map."""
gtab = dmri_estimation_data['gtab']
dwi_img = dmri_estimation_data['dwi_img']
B0_mask_img = dmri_estimation_data['B0_mask_img']
gtab_file = tempfile.NamedTemporaryFile(mode='w+', suffix='.pkl')
dwi_file = tempfile.NamedTemporaryFile(mode='w+', suffix='.nii.gz')
B0_mask_file = tempfile.NamedTemporaryFile(mode='w+', suffix='.nii.gz')
save_pickle(gtab_file.name, gtab)
nib.save(dwi_img, dwi_file.name)
nib.save(B0_mask_img, B0_mask_file.name)
[anisopwr_path, _, _, _] = \
create_anisopowermap(gtab_file.name, dwi_file.name, B0_mask_file.name)
assert os.path.isfile(anisopwr_path)
gtab_file.close()
dwi_file.close()
B0_mask_file.close()
def test_streams2graph(fa_wei, dsn):
from dipy.core.gradients import gradient_table
from pynets.registration import register
from pynets.core import nodemaker
from dipy.io import save_pickle
import os
base_dir = str(Path(__file__).parent / "examples")
dwi_file = f"{base_dir}/003/test_out/003/dwi/sub-003_dwi_reor-RAS_res-2mm.nii.gz"
conn_model = 'csd'
min_length = 10
error_margin = 2
directget = 'prob'
track_type = 'particle'
target_samples = 500
overlap_thr = 1
min_span_tree = True
prune = 3
norm = 6
binary = False
roi = f"{base_dir}/miscellaneous/pDMN_3_bin.nii.gz"
network = 'Default'
ID = '003'
parc = True
disp_filt = False
node_size = None
dens_thresh = False
atlas = 'whole_brain_cluster_labels_PCA200'
uatlas = f"{base_dir}/miscellaneous/whole_brain_cluster_labels_PCA200.nii.gz"
t1_aligned_mni = f"{base_dir}/miscellaneous/whole_brain_cluster_labels_PCA200.nii.gz"
atlas_dwi = f"{base_dir}/003/dmri/whole_brain_cluster_labels_PCA200_dwi_track.nii.gz"
streams = f"{base_dir}/miscellaneous/003_streamlines_est-csd_nodetype-parc_samples-1000streams_tt-particle_" \
f"dg-prob_ml-10.trk"
B0_mask = f"{base_dir}/003/anat/mean_B0_bet_mask_tmp.nii.gz"
dir_path = f"{base_dir}/003/dmri"
bvals = f"{dir_path}/sub-003_dwi.bval"
bvecs = f"{base_dir}/003/test_out/003/dwi/bvecs_reor.bvec"
gtab_file = f"{base_dir}/gtab.pkl"
gtab = gradient_table(bvals, bvecs)
gtab.b0_threshold = 50
gtab_bvals = gtab.bvals.copy()
b0_thr_ixs = np.where(gtab_bvals < gtab.b0_threshold)[0]
gtab_bvals[b0_thr_ixs] = 0
gtab.b0s_mask = gtab_bvals == 0
save_pickle(gtab_file, gtab)
fa_path = tens_mod_fa_est(gtab_file, dwi_file, B0_mask)[0]
coords = nodemaker.get_names_and_coords_of_parcels(uatlas)[0]
labels = np.arange(len(coords) +
1)[np.arange(len(coords) + 1) != 0].tolist()
# if dsn is True:
# os.makedirs(f"{dir_path}/dmri_reg/DSN", exist_ok=True)
# (streams_mni, dir_path, track_type, target_samples, conn_model, network, node_size, dens_thresh, ID, roi,
# min_span_tree, disp_filt, parc, prune, atlas, uatlas, labels, coords, norm, binary, atlas_mni, directget,
# warped_fa, min_length, error_margin) = register.direct_streamline_norm(streams, fa_path, fa_path, dir_path,
# track_type, target_samples, conn_model,
# network, node_size, dens_thresh, ID,
# roi, min_span_tree, disp_filt, parc,
# prune, atlas, atlas_dwi, uatlas,
# labels, coords, norm, binary, uatlas,
# dir_path, [0.1, 0.2], [40, 30],
# directget, min_length, t1_aligned_mni,
# error_margin)
#
# conn_matrix = streams2graph(atlas_mni, streams_mni, overlap_thr, dir_path, track_type, target_samples,
# conn_model, network, node_size, dens_thresh, ID, roi, min_span_tree,
# disp_filt, parc, prune, atlas, uatlas, labels, coords, norm, binary,
# directget, warped_fa, error_margin, min_length, fa_wei)[2]
# else:
# conn_matrix = streams2graph(atlas_dwi, streams, overlap_thr, dir_path, track_type, target_samples,
# conn_model, network, node_size, dens_thresh, ID, roi, min_span_tree,
# disp_filt, parc, prune, atlas, atlas_dwi, labels, coords, norm, binary,
# directget, fa_path, error_margin, min_length, fa_wei)[2]
conn_matrix = streams2graph(
atlas_dwi, streams, overlap_thr, dir_path, track_type, target_samples,
conn_model, network, node_size, dens_thresh, ID, roi, min_span_tree,
disp_filt, parc, prune, atlas, atlas_dwi, labels, coords, norm, binary,
directget, fa_path, error_margin, min_length, fa_wei)[2]
assert conn_matrix is not None
def make_gtab_and_bmask(fbval, fbvec, dwi_file):
"""
:param fbval:
:param fbvec:
:param dwi_file:
:return:
"""
import os
from dipy.io import save_pickle
import os.path as op
from dipy.io import read_bvals_bvecs
from dipy.core.gradients import gradient_table
from nilearn.image import mean_img
from pynets.utils import rescale_bvec
# """
# Takes bval and bvec files and produces a structure in dipy format
# **Positional Arguments:**
# """
# Use b0's from the DWI to create a more stable DWI image for registration
outdir = op.dirname(dwi_file)
nodif_b0 = "{}/nodif_b0.nii.gz".format(outdir)
nodif_b0_bet = "{}/nodif_b0_bet.nii.gz".format(outdir)
nodif_b0_mask = "{}/nodif_b0_bet_mask.nii.gz".format(outdir)
bvec_rescaled = "{}/bvec_scaled.bvec".format(outdir)
gtab_file = "{}/gtab.pkl".format(outdir)
# loading bvecs/bvals
bvals, bvecs = read_bvals_bvecs(fbval, fbvec)
bvecs[np.where(np.any(abs(bvecs) >= 10, axis=1) == True)] = [1, 0, 0]
bvecs[np.where(bvals == 0)] = 0
if len(bvecs[np.where(np.logical_and(bvals > 50, np.all(abs(bvecs) == np.array([0, 0, 0]), axis=1)))]) > 0:
raise ValueError('WARNING: Encountered potentially corrupted bval/bvecs. Check to ensure volumes with a '
'diffusion weighting are not being treated as B0\'s along the bvecs')
np.savetxt(fbval, bvals)
np.savetxt(fbvec, bvecs)
bvec_rescaled = rescale_bvec(fbvec, bvec_rescaled)
if fbval and bvec_rescaled:
bvals, bvecs = read_bvals_bvecs(fbval, bvec_rescaled)
else:
raise ValueError('Either bvals or bvecs files not found (or rescaling failed)!')
# Creating the gradient table
gtab = gradient_table(bvals, bvecs)
# Correct b0 threshold
gtab.b0_threshold = min(bvals)
# Get b0 indices
b0s = np.where(gtab.bvals == gtab.b0_threshold)[0]
print("%s%s" % ('b0\'s found at: ', b0s))
# Show info
print(gtab.info)
# Save gradient table to pickle
save_pickle(gtab_file, gtab)
# Extract and Combine all b0s collected
print('Extracting b0\'s...')
cmds = []
b0s_bbr = []
for b0 in b0s:
print(b0)
b0_bbr = "{}/{}_b0.nii.gz".format(outdir, str(b0))
cmds.append('fslroi {} {} {} 1'.format(dwi_file, b0_bbr, str(b0), ' 1'))
b0s_bbr.append(b0_bbr)
for cmd in cmds:
os.system(cmd)
# Get mean b0
mean_b0 = mean_img(b0s_bbr)
nib.save(mean_b0, nodif_b0)
# Get mean b0 brain mask
os.system("bet {} {} -m -f 0.2".format(nodif_b0, nodif_b0_bet))
return gtab_file, nodif_b0_bet, nodif_b0_mask, dwi_file
def save_affine(fname, affine_):
dio.save_pickle('affine', affine_)
def test_streams2graph(dmri_estimation_data,
tractography_estimation_data,
random_mni_roi_data,
dsn=False):
from pynets.registration.register import direct_streamline_norm
from dipy.core.gradients import gradient_table
from dipy.io import save_pickle
import random
import pkg_resources
tmp = tempfile.TemporaryDirectory()
dir_path = str(tmp.name)
os.makedirs(dir_path, exist_ok=True)
dwi_file = dmri_estimation_data['dwi_file']
conn_model = 'csd'
min_length = 10
error_margin = 5
traversal = 'prob'
track_type = 'local'
min_span_tree = False
prune = 3
norm = 6
binary = False
roi = random_mni_roi_data['roi_file']
subnet = 'Default'
ID = '003'
parc = True
disp_filt = False
node_radius = None
dens_thresh = False
atlas = 'whole_brain_cluster_labels_PCA200'
parcellation = pkg_resources.resource_filename(
"pynets", "templates/atlases/whole_brain_cluster_labels_PCA200.nii.gz")
streams = tractography_estimation_data['trk']
B0_mask = dmri_estimation_data['B0_mask']
bvals = dmri_estimation_data['fbvals']
bvecs = dmri_estimation_data['fbvecs']
gtab_file = dmri_estimation_data['gtab_file']
gtab = gradient_table(bvals, bvecs)
gtab.b0_threshold = 50
gtab_bvals = gtab.bvals.copy()
b0_thr_ixs = np.where(gtab_bvals < gtab.b0_threshold)[0]
gtab_bvals[b0_thr_ixs] = 0
gtab.b0s_mask = gtab_bvals == 0
save_pickle(gtab_file, gtab)
fa_path = tens_mod_fa_est(gtab_file, dwi_file, B0_mask)[0]
ap_path = create_anisopowermap(gtab_file, dwi_file, B0_mask)[0]
t1w_brain = dmri_estimation_data['t1w_file']
t1w_gm = dmri_estimation_data['f_pve_gm']
atlas_in_dwi = fname_presuffix(ap_path,
suffix="atlas_in_dwi",
use_ext=True)
resample_to_img(nib.load(parcellation),
nib.load(fa_path),
interpolation="nearest").to_filename(atlas_in_dwi)
coords = [
(random.random() * 2.0, random.random() * 2.0, random.random() * 2.0)
for _ in range(len(np.unique(nib.load(atlas_in_dwi).get_fdata())) - 1)
]
labels = np.arange(len(coords) +
1)[np.arange(len(coords) + 1) != 0].tolist()
if dsn is True:
os.makedirs(f"{dir_path}/dmri_reg/DSN", exist_ok=True)
(streams, dir_path, track_type, conn_model, subnet, node_radius,
dens_thresh, ID, roi, min_span_tree, disp_filt, parc, prune, atlas,
parcellation, labels, coords, norm, binary, atlas_for_streams,
traversal, fa_path,
min_length) = direct_streamline_norm(streams,
fa_path,
ap_path,
dir_path,
track_type,
conn_model,
subnet,
node_radius,
dens_thresh,
ID,
roi,
min_span_tree,
disp_filt,
parc,
prune,
atlas,
atlas_in_dwi,
parcellation,
labels,
coords,
norm,
binary,
t1w_gm,
dir_path, [0.1, 0.2], [40, 30],
traversal,
min_length,
t1w_brain,
run_dsn=True)
conn_matrix = streams2graph(
atlas_in_dwi, streams, os.path.dirname(streams), track_type,
conn_model, subnet, node_radius, dens_thresh, ID, roi, min_span_tree,
disp_filt, parc, prune, atlas, atlas_in_dwi, labels, coords, norm,
binary, traversal, fa_path, min_length, error_margin)[2]
assert conn_matrix is not None
def _run_interface(self, runtime):
import os
import time
from dipy.io import save_pickle
from dipy.io import read_bvals_bvecs
from dipy.core.gradients import gradient_table
from nipype.utils.filemanip import copyfile, fname_presuffix
# from dipy.segment.mask import median_otsu
from pynets.registration.utils import median
from pynets.dmri.utils import normalize_gradients, extract_b0
B0_bet = f"{runtime.cwd}/mean_B0_bet.nii.gz"
B0_mask = f"{runtime.cwd}/mean_B0_bet_mask.nii.gz"
fbvec_norm = f"{runtime.cwd}/bvec_normed.bvec"
fbval_norm = f"{runtime.cwd}/bval_normed.bvec"
gtab_file = f"{runtime.cwd}/gtab.pkl"
all_b0s_file = f"{runtime.cwd}/all_b0s.nii.gz"
fbval_tmp_path = fname_presuffix(self.inputs.fbval,
suffix="_tmp",
newpath=runtime.cwd)
copyfile(self.inputs.fbval,
fbval_tmp_path,
copy=True,
use_hardlink=False)
fbvec_tmp_path = fname_presuffix(self.inputs.fbvec,
suffix="_tmp",
newpath=runtime.cwd)
copyfile(self.inputs.fbvec,
fbvec_tmp_path,
copy=True,
use_hardlink=False)
# loading bvecs/bvals
bvals, bvecs = read_bvals_bvecs(fbval_tmp_path, fbvec_tmp_path)
bvecs_norm, bvals_norm = normalize_gradients(
bvecs, bvals, b0_threshold=self.inputs.b0_thr)
# Save corrected
np.savetxt(fbval_norm, bvals_norm)
np.savetxt(fbvec_norm, bvecs_norm)
# Creating the gradient table
gtab = gradient_table(bvals_norm, bvecs_norm)
# Correct b0 threshold
gtab.b0_threshold = self.inputs.b0_thr
# Correct bvals to set 0's for B0 based on thresh
gtab_bvals = gtab.bvals.copy()
b0_thr_ixs = np.where(gtab_bvals < gtab.b0_threshold)[0]
gtab_bvals[b0_thr_ixs] = 0
gtab.b0s_mask = gtab_bvals == 0
# Show info
print(gtab.info)
# Save gradient table to pickle
save_pickle(gtab_file, gtab)
dwi_file_tmp_path = fname_presuffix(self.inputs.dwi_file,
suffix="_tmp",
newpath=runtime.cwd)
copyfile(self.inputs.dwi_file,
dwi_file_tmp_path,
copy=True,
use_hardlink=False)
# Extract and Combine all b0s collected, make mean b0
print("Extracting b0's...")
all_b0s_file = extract_b0(dwi_file_tmp_path, b0_thr_ixs, all_b0s_file)
med_b0_file = median(all_b0s_file)
# TODO replace with bet and median_otsu with deep-learning classifier.
# med_b0_img = nib.load(med_b0_file)
# med_b0_data = np.asarray(med_b0_img.dataobj)
# # Create mean b0 brain mask
# b0_mask_data, mask_data = median_otsu(med_b0_data, median_radius=2,
# numpass=1)
#
# hdr = med_b0_img.header.copy()
# hdr.set_xyzt_units("mm")
# hdr.set_data_dtype(np.float32)
# nib.Nifti1Image(b0_mask_data, med_b0_img.affine,
# hdr).to_filename(B0_bet)
# nib.Nifti1Image(mask_data, med_b0_img.affine,
# hdr).to_filename(B0_mask)
# Get mean B0 brain mask
cmd = f"bet {med_b0_file} {B0_bet} -m -f 0.2"
os.system(cmd)
time.sleep(2)
self._results["gtab_file"] = gtab_file
self._results["B0_bet"] = B0_bet
self._results["B0_mask"] = B0_mask
self._results["dwi_file"] = self.inputs.dwi_file
tmp_files = [fbval_tmp_path, fbvec_tmp_path, dwi_file_tmp_path]
for j in tmp_files:
if j is not None:
if os.path.isfile(j):
os.system(f"rm -f {j} &")
return runtime
def make_gtab_and_bmask(fbval,
fbvec,
dwi_file,
network,
node_size,
atlas,
b0_thr=50):
"""
Create gradient table from bval/bvec, and a mean B0 brain mask.
Parameters
----------
fbval : str
File name of the b-values file.
fbvec : str
File name of the b-vectors file.
dwi_file : str
File path to diffusion weighted image.
network : str
Resting-state network based on Yeo-7 and Yeo-17 naming (e.g. 'Default') used to filter nodes in the study of
brain subgraphs.
node_size : int
Spherical centroid node size in the case that coordinate-based centroids
are used as ROI's.
atlas : str
Name of a Nilearn-hosted coordinate or parcellation/label-based atlas supported for fetching.
See Nilearn's datasets.atlas module for more detailed reference.
Returns
-------
gtab_file : str
File path to pickled DiPy gradient table object.
nodif_b0_bet : str
File path to mean brain-extracted B0 image.
B0_mask : str
File path to mean B0 brain mask.
dwi_file : str
File path to diffusion weighted image.
"""
import os
from dipy.io import save_pickle
import os.path as op
from dipy.io import read_bvals_bvecs
from dipy.core.gradients import gradient_table
from pynets.dmri.dmri_utils import make_mean_b0, normalize_gradients
outdir = op.dirname(dwi_file)
namer_dir = outdir + '/dmri_tmp'
if not os.path.isdir(namer_dir):
os.makedirs(namer_dir, exist_ok=True)
B0_bet = "%s%s" % (namer_dir, "/mean_B0_bet.nii.gz")
B0_mask = "%s%s" % (namer_dir, "/mean_B0_bet_mask.nii.gz")
fbvec_norm = "%s%s" % (namer_dir, "/bvec_normed.bvec")
fbval_norm = "%s%s" % (namer_dir, "/bval_normed.bvec")
gtab_file = "%s%s" % (namer_dir, "/gtab.pkl")
all_b0s_file = "%s%s" % (namer_dir, "/all_b0s.nii.gz")
# loading bvecs/bvals
bvals, bvecs = read_bvals_bvecs(fbval, fbvec)
bvecs_norm, bvals_norm = normalize_gradients(bvecs,
bvals,
b0_threshold=b0_thr)
# Save corrected
np.savetxt(fbval_norm, bvals_norm)
np.savetxt(fbvec_norm, bvecs_norm)
# Creating the gradient table
gtab = gradient_table(bvals_norm, bvecs_norm)
# Correct b0 threshold
gtab.b0_threshold = b0_thr
# Get b0 indices
b0s = np.where(gtab.bvals <= gtab.b0_threshold)[0]
print("%s%s" % ('b0\'s found at: ', b0s))
# Correct bvals to set 0's for B0 based on thresh
gtab_bvals = gtab.bvals.copy()
b0_thr_ixs = np.where(gtab_bvals < gtab.b0_threshold)[0]
gtab_bvals[b0_thr_ixs] = 0
gtab.b0s_mask = gtab_bvals == 0
# Show info
print(gtab.info)
# Save gradient table to pickle
save_pickle(gtab_file, gtab)
# Extract and Combine all b0s collected, make mean b0
print("Extracting b0's...")
b0_vols = []
dwi_img = nib.load(dwi_file)
all_b0s_aff = dwi_img.affine.copy()
dwi_data = np.asarray(dwi_img.dataobj)
dwi_img.uncache()
for b0 in b0s:
print(b0)
b0_vols.append(dwi_data[:, :, :, b0])
all_b0s_aff[3][3] = len(b0_vols)
nib.save(nib.Nifti1Image(np.stack(b0_vols, axis=3), affine=all_b0s_aff),
all_b0s_file)
mean_b0_file = make_mean_b0(all_b0s_file)
# Create mean b0 brain mask
cmd = 'bet ' + mean_b0_file + ' ' + B0_bet + ' -m -f 0.2'
os.system(cmd)
del dwi_data
return gtab_file, B0_bet, B0_mask, dwi_file
def make_gtab_and_bmask(fbval, fbvec, dwi_file):
import os
from dipy.io import save_pickle
import os.path as op
from dipy.io import read_bvals_bvecs
from dipy.core.gradients import gradient_table
from nilearn.image import mean_img
from pynets.utils import rescale_bvec
"""
Takes bval and bvec files and produces a structure in dipy format
**Positional Arguments:**
"""
# Use b0's from the DWI to create a more stable DWI image for registration
outdir = op.dirname(dwi_file)
nodif_b0 = "{}/nodif_b0.nii.gz".format(outdir)
nodif_b0_bet = "{}/nodif_b0_bet.nii.gz".format(outdir)
nodif_b0_mask = "{}/nodif_b0_bet_mask.nii.gz".format(outdir)
bvec_rescaled = "{}/bvec_scaled.bvec".format(outdir)
gtab_file = "{}/gtab.pkl".format(outdir)
# loading bvecs/bvals
bvals, bvecs = read_bvals_bvecs(fbval, fbvec)
bvecs[np.where(np.any(abs(bvecs) >= 10, axis=1) == True)] = [1, 0, 0]
bvecs[np.where(np.any(bvals == 0, axis=0) == True)] = 0
np.savetxt(fbval, bvals)
np.savetxt(fbvec, bvecs)
bvec_rescaled = rescale_bvec(fbvec, bvec_rescaled)
if fbval and bvec_rescaled:
bvals, bvecs = read_bvals_bvecs(fbval, bvec_rescaled)
else:
raise ValueError(
'Either bvals or bvecs files not found (or rescaling failed)!')
# Creating the gradient table
gtab = gradient_table(bvals, bvecs)
# Correct b0 threshold
gtab.b0_threshold = min(bvals)
# Get b0 indices
b0s = np.where(gtab.bvals == gtab.b0_threshold)[0]
print("%s%s" % ('b0\'s found at: ', b0s))
# Show info
print(gtab.info)
# Save gradient table to pickle
save_pickle(gtab_file, gtab)
# Extract and Combine all b0s collected
print('Extracting b0\'s...')
cmds = []
b0s_bbr = []
for b0 in b0s:
print(b0)
b0_bbr = "{}/{}_b0.nii.gz".format(outdir, str(b0))
cmd = 'fslroi ' + dwi_file + ' ' + b0_bbr + ' ' + str(b0) + ' 1'
cmds.append(cmd)
b0s_bbr.append(b0_bbr)
for cmd in cmds:
os.system(cmd)
# Get mean b0
mean_b0 = mean_img(b0s_bbr)
nib.save(mean_b0, nodif_b0)
# Get mean b0 brain mask
cmd = 'bet ' + nodif_b0 + ' ' + nodif_b0_bet + ' -m -f 0.2'
os.system(cmd)
return gtab_file, nodif_b0_bet, nodif_b0_mask, dwi_file
def dmri_estimation_data():
"""Fixture for dmri estimation tests."""
dpd.fetcher.dipy_home = f"{os.environ['HOME']}/.dipy"
os.makedirs(dpd.fetcher.dipy_home, exist_ok=True)
files, folder = dpd.fetcher.fetch_stanford_hardi()
dwi_file = f"{folder}/HARDI150.nii.gz"
fbvals = f"{folder}/HARDI150.bval"
fbvecs = f"{folder}/HARDI150.bvec"
files, folder = dpd.fetcher.fetch_stanford_t1()
t1w_file = f"{folder}/t1.nii.gz"
files, folder = dpd.fetcher.fetch_stanford_pve_maps()
f_pve_csf = f"{folder}/pve_csf.nii.gz"
f_pve_gm = f"{folder}/pve_gm.nii.gz"
f_pve_wm = f"{folder}/pve_wm.nii.gz"
bvals = np.loadtxt(fbvals)
b0_ixs = np.where(np.logical_and(bvals <= 50, bvals >= -50))[0]
dwi_img = nib.load(dwi_file)
dwi_data = dwi_img.get_fdata()
b0_mask, mask = median_otsu(np.asarray(dwi_data,
dtype=np.float32)[..., b0_ixs[0]],
median_radius=4,
numpass=2)
mask_img = nib.Nifti1Image(mask.astype(np.float32), dwi_img.affine)
B0_mask = fname_presuffix(dwi_file, suffix="_brain_mask", use_ext=True)
nib.save(mask_img, B0_mask)
mask_img_small = nib.Nifti1Image(mask[20:50, 55:85,
38:39].astype('float32'),
affine=mask_img.affine)
B0_mask_small = fname_presuffix(dwi_file,
suffix="_brain_mask_small",
use_ext=True)
nib.save(mask_img_small, B0_mask_small)
del mask
mask_img.uncache()
mask_img_small.uncache()
gc.collect()
gtab = gradient_table(bvals, np.loadtxt(fbvecs))
gtab.b0_threshold = 50
gtab_bvals = gtab.bvals.copy()
b0_thr_ixs = np.where(gtab_bvals < gtab.b0_threshold)[0]
gtab_bvals[b0_thr_ixs] = 0
gtab.b0s_mask = gtab_bvals == 0
gtab_file_tmp = tempfile.NamedTemporaryFile(mode='w+',
suffix='.pkl',
delete=False)
gtab_file = str(gtab_file_tmp.name)
save_pickle(gtab_file, gtab)
dwi_data_small = dwi_data.copy()
dwi_data_small = dwi_data_small[20:50, 55:85, 38:39]
dwi_img_small = nib.Nifti1Image(dwi_data_small,
header=dwi_img.header,
affine=dwi_img.affine)
dwi_file_small = fname_presuffix(dwi_file, suffix="_small", use_ext=True)
dwi_img_small.to_filename(dwi_file_small)
del dwi_data, dwi_data_small
dwi_img.uncache()
dwi_img_small.uncache()
gc.collect()
yield {
'dwi_file': dwi_file,
'fbvals': fbvals,
'fbvecs': fbvecs,
'gtab': gtab,
'gtab_file': gtab_file,
'dwi_file_small': dwi_file_small,
'B0_mask_small': B0_mask_small,
'B0_mask': B0_mask,
't1w_file': t1w_file,
'f_pve_csf': f_pve_csf,
'f_pve_wm': f_pve_wm,
'f_pve_gm': f_pve_gm
}
gtab_file_tmp.close()
