def __init__(self, model, model_params):
""" Initialize a FreeWaterTensorFit class instance.
Since the free water tensor model is an extension of DTI, class
instance is defined as subclass of the TensorFit from dti.py
Parameters
----------
model : FreeWaterTensorModel Class instance
Class instance containing the free water tensor model for the fit
model_params : ndarray (x, y, z, 13) or (n, 13)
All parameters estimated from the free water tensor model.
Parameters are ordered as follows:
1) Three diffusion tensor's eigenvalues
2) Three lines of the eigenvector matrix each containing the
first, second and third coordinates of the eigenvector
3) The volume fraction of the free water compartment
References
----------
.. [1] Henriques, R.N., Rokem, A., Garyfallidis, E., St-Jean, S.,
Peterson E.T., Correia, M.M., 2017. [Re] Optimization of a free
water elimination two-compartment model for diffusion tensor
imaging. ReScience volume 3, issue 1, article number 2
"""
TensorFit.__init__(self, model, model_params)
def __init__(self, model, model_params):
""" Initialize a FreeWaterTensorFit class instance.
Since the free water tensor model is an extension of DTI, class
instance is defined as subclass of the TensorFit from dti.py
Parameters
----------
model : FreeWaterTensorModel Class instance
Class instance containing the free water tensor model for the fit
model_params : ndarray (x, y, z, 13) or (n, 13)
All parameters estimated from the free water tensor model.
Parameters are ordered as follows:
1) Three diffusion tensor's eigenvalues
2) Three lines of the eigenvector matrix each containing the
first, second and third coordinates of the eigenvector
3) The volume fraction of the free water compartment
"""
TensorFit.__init__(self, model, model_params)
def __init__(self, model, model_params):
""" Initialize a FreeWaterTensorFit class instance.
Since the free water tensor model is an extension of DTI, class
instance is defined as subclass of the TensorFit from dti.py
Parameters
----------
model : FreeWaterTensorModel Class instance
Class instance containing the free water tensor model for the fit
model_params : ndarray (x, y, z, 13) or (n, 13)
All parameters estimated from the free water tensor model.
Parameters are ordered as follows:
1) Three diffusion tensor's eigenvalues
2) Three lines of the eigenvector matrix each containing the
first, second and third coordinates of the eigenvector
3) The volume fraction of the free water compartment
"""
TensorFit.__init__(self, model, model_params)
def __init__(self, model, model_params):
""" Initialize a DiffusionKurtosisFit class instance.
Since DKI is an extension of DTI, class instance is defined as subclass
of the TensorFit from dti.py
Parameters
----------
model : DiffusionKurtosisModel Class instance
Class instance containing the Diffusion Kurtosis Model for the fit
model_params : ndarray (x, y, z, 27) or (n, 27)
All parameters estimated from the diffusion kurtosis model.
Parameters are ordered as follow:
1) Three diffusion tensor's eingenvalues
2) Three lines of the eigenvector matrix each containing the
first, second and third coordinates of the eigenvector
3) Fifteen elements of the kurtosis tensor
"""
TensorFit.__init__(self, model, model_params)
def __init__(self, model, model_params):
""" Initialize a DiffusionKurtosisFit class instance.
Since DKI is an extension of DTI, class instance is defined as subclass
of the TensorFit from dti.py
Parameters
----------
model : DiffusionKurtosisModel Class instance
Class instance containing the Diffusion Kurtosis Model for the fit
model_params : ndarray (x, y, z, 27) or (n, 27)
All parameters estimated from the diffusion kurtosis model.
Parameters are ordered as follow:
1) Three diffusion tensor's eingenvalues
2) Three lines of the eigenvector matrix each containing the
first, second and third coordinates of the eigenvector
3) Fifteen elements of the kurtosis tensor
"""
TensorFit.__init__(self, model, model_params)
def __init__(self, model, model_params):
self.model = model
self.model_params = model_params
perfusion_params = np.zeros((self.model_params.shape[0], 12))
diffusion_params = np.zeros((self.model_params.shape[0], 12))
self.perfusion_fraction = np.zeros(self.model_params.shape[0])
for vox in range(self.model_params.shape[0]):
self.perfusion_fraction[vox] = self.model_params[vox, 0]
tensor_evecs, tensor_evals = _reconstruct_tensor(
*self.model_params[vox, 1:7])
diffusion_params[vox] = np.hstack(
[tensor_evals, tensor_evecs.ravel()])
perfusion_evecs, perfusion_evals = _reconstruct_tensor(
*self.model_params[vox, 7:])
perfusion_params[vox] = np.hstack(
[perfusion_evals, perfusion_evecs.ravel()])
self.diffusion_fit = TensorFit(self.model.diffusion_model,
diffusion_params)
self.perfusion_fit = TensorFit(self.model.perfusion_model,
perfusion_params)
def execution(self, context):
tensor_coeff = aims.read(self.tensor_coefficients.fullPath())
tensor_params = np.asarray(tensor_coeff)
tensor_model = load(self.tensor_model.fullPath())
gtab = tensor_model.gtab
#Loading base signal
S0 = aims.read(self.S0_signal.fullPath())
S0 = vol_to_array(S0)
tenfit = TensorFit(tensor_model, tensor_params)
pred_sign = tenfit.predict(gtab=gtab, S0=S0)
hdr = tensor_coeff.header()
pred_vol = array_to_vol(pred_sign, header=hdr)
aims.write(pred_vol, self.predicted_signal.fullPath())
#Handling metada
transformManager = getTransformationManager()
transformManager.copyReferential(self.predicted_signal,
self.tensor_coefficients)
context.write("Process finish successfully")
pass
def execution(self, context):
#if an existing tensor has already been fitted dont compute a new one .
if self.tensor_coefficients is not None and self.tensor_model is not None:
context.write('Fitted Tensor already exists ! Let s use it !')
tensor_coeff_vol = aims.read(self.tensor_coefficients.fullPath())
tensor_coeff = np.asarray(tensor_coeff_vol)
hdr = tensor_coeff_vol.header()
tensor_model = load(self.tensor_model.fullPath())
tenfit = TensorFit(tensor_model, tensor_coeff)
if self.mask is not None:
mask_vol = aims.read(self.mask.fullPath())
mask = vol_to_array(mask_vol)
mask = array_to_mask(mask)
else:
context.write(
'No mask provided ! Estimating impulsionnal response from the whole volume or brain is not really accurate ! A default mask based on Fractionnal Anisotropy is computed. '
)
fa = tenfit.fa
# just to avoid nan is case of wrong fitting
fa = np.clip(fa, 0, 1)
#high FA vale is associated with single fiber direction voxel
mask = fa > self.fa_threshold
mask = mask.astype(bool)
#code extracted from dipy response_from_mask function
indices = np.where(mask > 0)
sub_tenfit = tenfit[indices]
lambdas = sub_tenfit.evals[:, :2]
gtab = sub_tenfit.model.gtab
vol = aims.read(self.diffusion_data.fullPath())
data = np.asarray(vol)
S0s = data[indices][:, np.nonzero(gtab.b0s_mask)[0]]
response, ratio = _get_response(S0s, lambdas)
else:
context.write('No Tensor Fitted Yet! Compute a new one')
gtab = load(self.gradient_table.fullPath())
if is_multi_shell(gtab):
context.warning(
"The DWI scheme for this data is multishell: bvalues",
shells(gtab),
". CSD implementation used in Diffuse currently only handle single shell DWI scheme. By default the higher shell bval",
max_shell(gtab), " is selected")
context.warning(
"Even if only the outer shell is use for deconvolution, the following estimation method will use the full DWI scheme for response estimation. It might be inaccurate if the deconvolved shell bvalue is too high (b5000)"
)
vol = aims.read(self.diffusion_data.fullPath())
data = np.asarray(vol)
if self.mask is not None:
mask_vol = aims.read(self.mask.fullPath())
mask = vol_to_array(mask_vol)
mask = array_to_mask(mask)
response, ratio = response_from_mask(gtab, data, mask)
else:
context.warning(
"No mask provided ! Compute a high-FA based mask: FA higher than "
+ str(self.fa_threshold) +
" are considered as single direction voxels")
#default tensor model --> we dont store it for now
tensor = TensorModel(gtab)
#whole volume fit
tenfit = tensor.fit(data)
fa = tenfit.fa
# just to avoid nan is case of wrong fitting
fa = np.clip(fa, 0, 1)
# high FA vale is associated with single fiber direction voxel
mask = fa > self.fa_threshold
mask = mask.astype(bool)
indices = np.where(mask)
# code extracted from dipy response_from_mask function
sub_tenfit = tenfit[indices]
lambdas = sub_tenfit.evals[:, :2]
gtab = sub_tenfit.model.gtab
vol = aims.read(self.diffusion_data.fullPath())
data = np.asarray(vol)
S0s = data[indices][:, np.nonzero(gtab.b0s_mask)[0]]
response, ratio = _get_response(S0s, lambdas)
#store the response
dump(response, self.response.fullPath())
def execution(self, context):
tensor_coeff_vol = aims.read(self.tensor_coefficients.fullPath())
tensor_coeff = np.asarray(tensor_coeff_vol)
hdr = tensor_coeff_vol.header()
tensor_model = load(self.tensor_model.fullPath())
tenfit = TensorFit(tensor_model, tensor_coeff)
#Mandatory parameters
fa = tenfit.fa
FA = array_to_vol(fa, hdr)
aims.write(FA, self.fractionnal_anisotropy.fullPath())
md = tenfit.md
MD = array_to_vol(md, hdr)
aims.write(MD, self.mean_diffusivity.fullPath())
evecs = tenfit.evecs
vectors = [
evecs[:, :, :, :, 0], evecs[:, :, :, :, 1], evecs[:, :, :, :, 2]
]
evals = tenfit.evals
eigen_values = array_to_vol(evals, hdr)
aims.write(eigen_values, self.evals.fullPath())
vectors_volume = [array_to_vol(v, hdr) for v in vectors]
aims.write(vectors_volume[0], self.first_eigen_vector.fullPath())
aims.write(vectors_volume[1], self.second_eigen_vector.fullPath())
aims.write(vectors_volume[2], self.third_eigen_vector.fullPath())
color_fa = tenfit.color_fa
color_fa_vol = array_to_vol(color_fa)
aims.write(color_fa_vol, self.colored_fractionnal_anisotropy.fullPath())
# handling referentials
transformManager = getTransformationManager()
transformManager.copyReferential(self.tensor_coefficients,
self.fractionnal_anisotropy)
transformManager.copyReferential(self.tensor_coefficients,
self.mean_diffusivity)
# additionnal metadata
self.mean_diffusivity.setMinf('tensor_coefficients_uuid',
self.tensor_coefficients.uuid())
self.fractionnal_anisotropy.setMinf('tensor_coefficients_uuid',
self.tensor_coefficients.uuid())
if self.advanced_indices:
axial_diffusivity = tenfit.ad
planarity = tenfit.planarity
sphericity = tenfit.sphericity
linearity = tenfit.linearity
mode = tenfit.mode
disk_items = [
self.axial_diffusivity, self.planarity, self.sphericity,
self.linearity, self.mode
]
arrays = [axial_diffusivity, planarity, sphericity, linearity, mode]
for ind, a in enumerate(arrays):
vol = array_to_vol(a, hdr)
aims.write(vol, disk_items[ind].fullPath())
transformManager.copyReferential(self.tensor_coefficients,
disk_items[ind])
pass
def _dti_fit(row):
dti_params_file = _dti(row)
dti_params = nib.load(dti_params_file).get_data()
tm = TensorModel(row['gtab'])
tf = TensorFit(tm, dti_params)
return tf
