-
Notifications
You must be signed in to change notification settings - Fork 429
/
simulate_multi_tensor.py
111 lines (77 loc) · 2.55 KB
/
simulate_multi_tensor.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
"""
======================
MultiTensor Simulation
======================
In this example we show how someone can simulate the signal and the ODF of a
single voxel using a MultiTensor.
"""
import numpy as np
from dipy.sims.voxel import multi_tensor, multi_tensor_odf
from dipy.data import get_sphere
"""
For the simulation we will need a GradientTable with the b-values and b-vectors
Here we use the one we created in :ref:`example_gradients_spheres`.
"""
from gradients_spheres import gtab
"""
In ``mevals`` we save the eigenvalues of each tensor.
"""
mevals = np.array([[0.0015, 0.0003, 0.0003],
[0.0015, 0.0003, 0.0003]])
"""
In ``angles`` we save in polar coordinates (:math:`\theta, \phi`) the principal
axis of each tensor.
"""
angles = [(0, 0), (60, 0)]
"""
In ``fractions`` we save the percentage of the contribution of each tensor.
"""
fractions = [50, 50]
"""
The function ``multi_tensor`` will return the simulated signal and an array
with the principal axes of the tensors in cartesian coordinates.
"""
signal, sticks = multi_tensor(gtab, mevals, S0=100, angles=angles,
fractions=fractions, snr=None)
"""
We can also add Rician noise with a specific SNR.
"""
signal_noisy, sticks = multi_tensor(gtab, mevals, S0=100, angles=angles,
fractions=fractions, snr=20)
import matplotlib.pyplot as plt
plt.plot(signal, label='noiseless')
plt.plot(signal_noisy, label='with noise')
plt.legend()
#plt.show()
plt.savefig('simulated_signal.png')
"""
.. figure:: simulated_signal.png
:align: center
**Simulated MultiTensor signal**
"""
"""
For the ODF simulation we will need a sphere. Because we are interested in a
simulation of only a single voxel, we can use a sphere with very high
resolution. We generate that by subdividing the triangles of one of DIPY_'s
cached spheres, which we can read in the following way.
"""
sphere = get_sphere('repulsion724')
sphere = sphere.subdivide(2)
odf = multi_tensor_odf(sphere.vertices, mevals, angles, fractions)
from dipy.viz import window, actor
# Enables/disables interactive visualization
interactive = False
ren = window.Renderer()
odf_actor = actor.odf_slicer(odf[None, None, None, :], sphere=sphere, colormap='plasma')
odf_actor.RotateX(90)
ren.add(odf_actor)
print('Saving illustration as multi_tensor_simulation')
window.record(ren, out_path='multi_tensor_simulation.png', size=(300, 300))
if interactive:
window.show(ren)
"""
.. figure:: multi_tensor_simulation.png
:align: center
Simulating a MultiTensor ODF.
.. include:: ../links_names.inc
"""