def test_design_matrix():
"""
Testing that our assumptions about the design matrix are correct
"""
data = (np.random.rand(10 * 10 * 10).reshape(10 * 10 * 10, 1) +
np.zeros((10 * 10 * 10, 160))).reshape(10, 10, 10,160)
mask_array = np.zeros(ni.load(data_path+'small_dwi.nii.gz').shape[:3])
# Only two voxels:
mask_array[1:3, 1:3, 1:3] = 1
SSD = SparseDeconvolutionModel(data,
data_path + 'dwi.bvecs',
data_path + 'dwi.bvals',
mask=mask_array,
params_file=tempfile.NamedTemporaryFile().name)
all_bvecs = SSD.bvecs[:, SSD.b_idx]
all_bvals = SSD.bvals[SSD.b_idx]
axial_diffusivity=AD
radial_diffusivity=RD
for i, this_bvec in enumerate(all_bvecs.T):
my_tensor = ozt.rotate_to_vector(this_bvec, [axial_diffusivity,
radial_diffusivity,
radial_diffusivity],
np.eye(3), all_bvecs, all_bvals)
pred_sig = my_tensor.predicted_signal(1)
pred_sig = pred_sig - np.mean(pred_sig)
# The ith column of the matrix should be the demeaned response function
# of a tensor pointing in this direction:
npt.assert_array_equal(pred_sig, SSD.design_matrix[:, i])
def _calc_rotations(self, vertices, mode=None):
"""
Given the rot_vecs of the object and a set of vertices (for the fitting
these are the b-vectors of the measurement), calculate the rotations to
be used as a design matrix
"""
# unless we ask to change it, just use the mode of the object
if mode is None:
mode = self.mode
out = np.empty((self.rot_vecs.shape[-1], vertices.shape[-1]))
# We will use the eigen-value/vectors from the response function
# and rotate them around to each one of these vectors, calculating
# the predicted signal in the bvecs of the actual measurement (even
# when over-sampling):
# If we have as many vertices as b-vectors, we can take the
# b-values from the measurement
if vertices.shape[0] == len(self.b_idx):
bvals = self.bvals[self.b_idx]
# Otherwise, we have to assume a constant b-value
else:
bvals = np.ones(vertices.shape[-1]) * self.bvals[self.b_idx][0]
evals, evecs = self.response_function.decompose
for idx, bvec in enumerate(self.rot_vecs.T):
this_rot = ozt.rotate_to_vector(bvec, evals, evecs,
vertices, bvals)
pred_sig = this_rot.predicted_signal(1)
if mode == 'distance':
# This is the special case where we use the diffusion distance
# calculation, instead of the predicted signal:
out[idx] = this_rot.diffusion_distance
elif mode == 'ADC':
# This is another special case, calculating the ADC instead of
# using the predicted signal:
out[idx] = this_rot.ADC
# Otherwise, we do one of these with the predicted signal:
elif mode == 'signal_attenuation':
# Fit to 1 - S/S0
out[idx] = 1 - pred_sig
elif mode == 'relative_signal':
# Fit to S/S0 using the predicted diffusion attenuated signal:
out[idx] = pred_sig
elif mode == 'normalize':
# Normalize your regressors to have a maximum of 1:
out[idx] = pred_sig / np.max(pred_sig)
elif mode == 'log':
# Take the log and divide out the b value:
out[idx] = np.log(pred_sig)
return out
def _calc_rotations(self, vertices, mode=None):
"""
Given the rot_vecs of the object and a set of vertices (for the fitting
these are the b-vectors of the measurement), calculate the rotations to
be used as a design matrix
"""
# unless we ask to change it, just use the mode of the object
if mode is None:
mode = self.mode
out = np.empty((self.rot_vecs.shape[-1], vertices.shape[-1]))
# We will use the eigen-value/vectors from the response function
# and rotate them around to each one of these vectors, calculating
# the predicted signal in the bvecs of the actual measurement (even
# when over-sampling):
# If we have as many vertices as b-vectors, we can take the
# b-values from the measurement
if vertices.shape[0] == len(self.b_idx):
bvals = self.bvals[self.b_idx]
# Otherwise, we have to assume a constant b-value
else:
bvals = np.ones(vertices.shape[-1]) * self.bvals[self.b_idx][0]
evals, evecs = self.response_function.decompose
for idx, bvec in enumerate(self.rot_vecs.T):
this_rot = ozt.rotate_to_vector(bvec, evals, evecs, vertices,
bvals)
pred_sig = this_rot.predicted_signal(1)
if mode == 'distance':
# This is the special case where we use the diffusion distance
# calculation, instead of the predicted signal:
out[idx] = this_rot.diffusion_distance
elif mode == 'ADC':
# This is another special case, calculating the ADC instead of
# using the predicted signal:
out[idx] = this_rot.ADC
# Otherwise, we do one of these with the predicted signal:
elif mode == 'signal_attenuation':
# Fit to 1 - S/S0
out[idx] = 1 - pred_sig
elif mode == 'relative_signal':
# Fit to S/S0 using the predicted diffusion attenuated signal:
out[idx] = pred_sig
elif mode == 'normalize':
# Normalize your regressors to have a maximum of 1:
out[idx] = pred_sig / np.max(pred_sig)
elif mode == 'log':
# Take the log and divide out the b value:
out[idx] = np.log(pred_sig)
return out
def test_rotations():
evals_t, evecs_t = test_response_function()
out_t = np.empty((5, 1))
for idx, bvec in enumerate(rot_vecs_t[:,3:8].T):
this_rot_t = ozt.rotate_to_vector(bvec, evals_t, evecs_t,
np.reshape(bvecs_t[:,4], (3,1)),
np.array([bvals_scaled_t[4]/1000]))
out_t[idx] = this_rot_t.predicted_signal(1)
npt.assert_equal(out_t, mb._calc_rotations(np.reshape(bvecs_t[:,4], (3,1)),
bvals_scaled_t[4]/1000))
return out_t
def test_rotations():
evals_t, evecs_t = test_response_function()
out_t = np.empty((5, 1))
for idx, bvec in enumerate(rot_vecs_t[:, 3:8].T):
this_rot_t = ozt.rotate_to_vector(bvec, evals_t, evecs_t,
np.reshape(bvecs_t[:, 4], (3, 1)),
np.array([bvals_scaled_t[4] / 1000]))
out_t[idx] = this_rot_t.predicted_signal(1)
npt.assert_equal(
out_t,
mb._calc_rotations(np.reshape(bvecs_t[:, 4], (3, 1)),
bvals_scaled_t[4] / 1000))
return out_t
