def show_Pi_mapping(streamlines_A, streamlines_B, Pi_ids_A, mapping_Pi):
r = fvtk.ren()
Pi_viz_A = fvtk.streamtube(streamlines_A[Pi_ids_A], fvtk.colors.red)
fvtk.add(r, Pi_viz_A)
# Pi_viz_B = fvtk.streamtube(streamlines_B[Pi_ids_B], fvtk.colors.blue)
# fvtk.add(r, Pi_viz_B)
Pi_viz_A_1nn_B = fvtk.streamtube(streamlines_B[mapping_Pi], fvtk.colors.white)
fvtk.add(r, Pi_viz_A_1nn_B)
fvtk.show(r)
def test_fvtk_functions():
# Create a renderer
r = fvtk.ren()
# Create 2 lines with 2 different colors
lines = [np.random.rand(10, 3), np.random.rand(20, 3)]
colors = np.random.rand(2, 3)
c = fvtk.line(lines, colors)
fvtk.add(r, c)
# create streamtubes of the same lines and shift them a bit
c2 = fvtk.streamtube(lines, colors)
c2.SetPosition(2, 0, 0)
fvtk.add(r, c2)
# Create a volume and return a volumetric actor using volumetric rendering
vol = 100 * np.random.rand(100, 100, 100)
vol = vol.astype('uint8')
r = fvtk.ren()
v = fvtk.volume(vol)
fvtk.add(r, v)
# Remove all objects
fvtk.rm_all(r)
# Put some text
l = fvtk.label(r, text='Yes Men')
fvtk.add(r, l)
# Slice the volume
fvtk.add(r, fvtk.slicer(vol, plane_i=[50]))
# Change the position of the active camera
fvtk.camera(r, pos=(0.6, 0, 0), verbose=False)
def show(imgtck, clusters, out_path):
colormap = fvtk.create_colormap(np.ravel(clusters.centroids), name='jet')
colormap_full = np.ones((len(imgtck.streamlines), 3))
for cluster, color in zip(clusters, colormap):
colormap_full[cluster.indices] = color
ren = fvtk.ren()
ren.SetBackground(1, 1, 1)
fvtk.add(ren, fvtk.streamtube(imgtck.streamlines, colormap_full))
fvtk.record(ren, n_frames=1, out_path=out_path, size=(600, 600))
fvtk.show(ren)
def test_fvtk_functions():
# This tests will fail if any of the given actors changed inputs or do
# not exist
# Create a renderer
r = fvtk.ren()
# Create 2 lines with 2 different colors
lines = [np.random.rand(10, 3), np.random.rand(20, 3)]
colors = np.random.rand(2, 3)
c = fvtk.line(lines, colors)
fvtk.add(r, c)
# create streamtubes of the same lines and shift them a bit
c2 = fvtk.streamtube(lines, colors)
c2.SetPosition(2, 0, 0)
fvtk.add(r, c2)
# Create a volume and return a volumetric actor using volumetric rendering
vol = 100 * np.random.rand(100, 100, 100)
vol = vol.astype('uint8')
r = fvtk.ren()
v = fvtk.volume(vol)
fvtk.add(r, v)
# Remove all objects
fvtk.rm_all(r)
# Put some text
l = fvtk.label(r, text='Yes Men')
fvtk.add(r, l)
# Slice the volume
slicer = fvtk.slicer(vol)
slicer.display(50, None, None)
fvtk.add(r, slicer)
# Change the position of the active camera
fvtk.camera(r, pos=(0.6, 0, 0), verbose=False)
fvtk.clear(r)
# Peak directions
p = fvtk.peaks(np.random.rand(3, 3, 3, 5, 3))
fvtk.add(r, p)
p2 = fvtk.peaks(np.random.rand(3, 3, 3, 5, 3),
np.random.rand(3, 3, 3, 5),
colors=(0, 1, 0))
fvtk.add(r, p2)
def test_fvtk_functions():
# This tests will fail if any of the given actors changed inputs or do
# not exist
# Create a renderer
r = fvtk.ren()
# Create 2 lines with 2 different colors
lines = [np.random.rand(10, 3), np.random.rand(20, 3)]
colors = np.random.rand(2, 3)
c = fvtk.line(lines, colors)
fvtk.add(r, c)
# create streamtubes of the same lines and shift them a bit
c2 = fvtk.streamtube(lines, colors)
c2.SetPosition(2, 0, 0)
fvtk.add(r, c2)
# Create a volume and return a volumetric actor using volumetric rendering
vol = 100 * np.random.rand(100, 100, 100)
vol = vol.astype('uint8')
r = fvtk.ren()
v = fvtk.volume(vol)
fvtk.add(r, v)
# Remove all objects
fvtk.rm_all(r)
# Put some text
l = fvtk.label(r, text='Yes Men')
fvtk.add(r, l)
# Slice the volume
slicer = fvtk.slicer(vol)
slicer.display(50, None, None)
fvtk.add(r, slicer)
# Change the position of the active camera
fvtk.camera(r, pos=(0.6, 0, 0), verbose=False)
fvtk.clear(r)
# Peak directions
p = fvtk.peaks(np.random.rand(3, 3, 3, 5, 3))
fvtk.add(r, p)
p2 = fvtk.peaks(np.random.rand(3, 3, 3, 5, 3),
np.random.rand(3, 3, 3, 5),
colors=(0, 1, 0))
fvtk.add(r, p2)
def show_both_bundles(bundles, colors=None, show=False, fname=None):
ren = fvtk.ren()
ren.SetBackground(1., 1, 1)
for (i, bundle) in enumerate(bundles):
color = colors[i]
lines = fvtk.streamtube(bundle, color, linewidth=0.3)
lines.RotateX(-90)
lines.RotateZ(90)
fvtk.add(ren, lines)
if show:
fvtk.show(ren)
if fname is not None:
sleep(1)
fvtk.record(ren, n_frames=1, out_path=fname, size=(900, 900))
def show_both_bundles(bundles, colors=None, show=False, fname=None):
ren = fvtk.ren()
ren.SetBackground(1.0, 1, 1)
for (i, bundle) in enumerate(bundles):
color = colors[i]
lines = fvtk.streamtube(bundle, color, linewidth=0.3)
lines.RotateX(-90)
lines.RotateZ(90)
fvtk.add(ren, lines)
if show:
fvtk.show(ren)
if fname is not None:
sleep(1)
fvtk.record(ren, n_frames=1, out_path=fname, size=(900, 900))
def show_bundles(streamlines, clusters, show_b=True):
# Color each streamline according to the cluster they belong to.
colormap = fvtk.create_colormap(np.arange(len(clusters)))
colormap_full = np.ones((len(streamlines), 3))
for cluster, color in zip(clusters, colormap):
colormap_full[cluster.indices] = color
ren = fvtk.ren()
ren.SetBackground(1, 1, 1)
fvtk.add(ren, fvtk.streamtube(streamlines, colormap_full))
fvtk.record(ren,
n_frames=1,
out_path='fornix_clusters_cosine.png',
size=(600, 600))
if show_b:
fvtk.show(ren)
def show_all_bundles(bundles, colors=None, show=True, fname=None):
ren = fvtk.ren()
ren.SetBackground(1., 1, 1)
for (i, bundle) in enumerate(bundles):
if colors is None:
color = np.random.rand(3)
else:
color = colors[i]
lines = fvtk.streamtube(bundle, color, linewidth=0.15 * 2)
lines.RotateX(-90)
lines.RotateZ(90)
fvtk.add(ren, lines)
#fvtk.add(ren, fvtk.axes((20, 20, 20)))
if show:
fvtk.show(ren)
if fname is not None:
fvtk.record(ren, n_frames=1, out_path=fname, size=(900, 900))
def createVtkPng(source, anatomical, roi):
import vtk
from dipy.viz.colormap import line_colors
from dipy.viz import fvtk
target = source.replace(".trk",".png")
roiImage= nibabel.load(roi)
anatomicalImage = nibabel.load(anatomical)
sourceImage = [s[0] for s in nibabel.trackvis.read(source, points_space='voxel')[0]]
try:
sourceActor = fvtk.streamtube(sourceImage, line_colors(sourceImage))
roiActor = fvtk.contour(roiImage.get_data(), levels=[1], colors=[(1., 1., 0.)], opacities=[1.])
anatomicalActor = fvtk.slicer(anatomicalImage.get_data(),
voxsz=(1.0, 1.0, 1.0),
plane_i=None,
plane_j=None,
plane_k=[65],
outline=False)
except ValueError:
return False
sourceActor.RotateX(-70)
sourceActor.RotateY(2.5)
sourceActor.RotateZ(185)
roiActor.RotateX(-70)
roiActor.RotateY(2.5)
roiActor.RotateZ(185)
anatomicalActor.RotateX(-70)
anatomicalActor.RotateY(2.5)
anatomicalActor.RotateZ(185)
ren = fvtk.ren()
fvtk.add(ren, sourceActor)
fvtk.add(ren, roiActor)
fvtk.add(ren, anatomicalActor)
fvtk.record(ren, out_path=target, size=(1200, 1200), n_frames=1, verbose=True, cam_pos=(90.03, 118.33, 700.59))
return target
def show_both_bundles(bundles, colors=None, show_b=False, fname=None):
"""
Show both bundles
bundles: return of --pyfat/algorithm/fiber_math/bundle_registration
example:
show_both_bundles([cb_subj1, cb_subj2_aligned],
colors=[fvtk.colors.orange, fvtk.colors.red],
fname='after_registration.png')
"""
ren = fvtk.ren()
ren.SetBackground(1., 1, 1)
for (i, bundle) in enumerate(bundles):
color = colors[i]
lines = fvtk.streamtube(bundle, color, linewidth=0.3)
lines.RotateX(-90)
lines.RotateZ(90)
fvtk.add(ren, lines)
if show_b:
fvtk.show(ren)
if fname is not None:
sleep(1)
fvtk.record(ren, n_frames=1, out_path=fname, size=(900, 900))
The streamlines that are entered into the model are termed 'candidate
streamliness' (or a 'candidate connectome'):
"""
"""
Let's visualize the initial candidate group of streamlines in 3D, relative to the
anatomical structure of this brain:
"""
from dipy.viz.colormap import line_colors
from dipy.viz import fvtk
candidate_streamlines_actor = fvtk.streamtube(candidate_sl,
line_colors(candidate_sl))
cc_ROI_actor = fvtk.contour(cc_slice,
levels=[1],
colors=[(1., 1., 0.)],
opacities=[1.])
vol_actor = fvtk.slicer(t1_data)
vol_actor.display(40, None, None)
vol_actor2 = vol_actor.copy()
vol_actor2.display(None, None, 35)
# Add display objects to canvas
ren = fvtk.ren()
fvtk.add(ren, candidate_streamlines_actor)
fvtk.add(ren, cc_ROI_actor)
qb = QuickBundles(threshold=2., metric=metric)
clusters = qb.cluster(streamlines)
"""
We will now visualize the clustering result.
"""
# Color each streamline according to the cluster they belong to.
colormap = fvtk.create_colormap(np.ravel(clusters.centroids))
colormap_full = np.ones((len(streamlines), 3))
for cluster, color in zip(clusters, colormap):
colormap_full[cluster.indices] = color
ren = fvtk.ren()
ren.SetBackground(1, 1, 1)
fvtk.add(ren, fvtk.streamtube(streamlines, colormap_full))
fvtk.record(ren, n_frames=1, out_path='fornix_clusters_arclength.png', size=(600, 600))
"""
.. figure:: fornix_clusters_arclength.png
:align: center
**Showing the different clusters obtained by using the arc length**.
Extending `Metric`
==================
This section will guide you through the creation of a new metric that can be
used in the context of this clustering framework. For a list of available
metrics in Dipy see :ref:`example_segment_clustering_metrics`.
t1_data = t1.get_data()
t1_aff = t1.affine
color = line_colors(streamlines)
"""
To speed up visualization, we will select a random sub-set of streamlines to
display. This is particularly important, if you track from seeds throughout the
entire white matter, generating many streamlines. In this case, for
demonstration purposes, we subselect 900 streamlines.
"""
from dipy.tracking.streamline import select_random_set_of_streamlines
plot_streamlines = select_random_set_of_streamlines(streamlines, 900)
streamlines_actor = fvtk.streamtube(
list(move_streamlines(plot_streamlines, inv(t1_aff))),
line_colors(streamlines), linewidth=0.1)
vol_actor = fvtk.slicer(t1_data)
vol_actor.display(40, None, None)
vol_actor2 = vol_actor.copy()
vol_actor2.display(None, None, 35)
ren = fvtk.ren()
fvtk.add(ren, streamlines_actor)
fvtk.add(ren, vol_actor)
fvtk.add(ren, vol_actor2)
fvtk.record(ren, n_frames=1, out_path='sfm_streamlines.png',
size=(800, 800))
# Extract feature of every streamline.
centers = np.asarray(map(feature.extract, streamlines))
# Color each center of mass according to the cluster they belong to.
rng = np.random.RandomState(42)
colormap = fvtk.create_colormap(np.arange(len(clusters)))
colormap_full = np.ones((len(streamlines), 3))
for cluster, color in zip(clusters, colormap):
colormap_full[cluster.indices] = color
# Visualization
ren = fvtk.ren()
fvtk.clear(ren)
ren.SetBackground(0, 0, 0)
fvtk.add(ren, fvtk.streamtube(streamlines, fvtk.colors.white, opacity=0.05))
fvtk.add(ren, fvtk.point(centers[:, 0, :], colormap_full, point_radius=0.2))
fvtk.record(ren, n_frames=1, out_path='center_of_mass_feature.png', size=(600, 600))
"""
.. figure:: center_of_mass_feature.png
:align: center
**Showing the center of mass of each streamline and colored according to
the QuickBundles results**.
.. _clustering-examples-MidpointFeature:
Midpoint Feature
================
**What:** Instances of `MidpointFeature` extract the middle point of a
[ 67.67449188, 85.57660675, 79.98880005],
[ 65.69326782, 86.66771698, 77.44818115],
[ 64.02451324, 88.43942261, 75.0697403 ]], dtype=float32)
"""
"""
`clusters` has also attributes like `centroids` (cluster representatives), and
methods like `add`, `remove`, and `clear` to modify the clustering result.
Lets first show the initial dataset.
"""
ren = fvtk.ren()
ren.SetBackground(1, 1, 1)
fvtk.add(ren, fvtk.streamtube(streamlines, fvtk.colors.white))
fvtk.record(ren, n_frames=1, out_path='fornix_initial.png', size=(600, 600))
"""
.. figure:: fornix_initial.png
:align: center
**Initial Fornix dataset**.
Show the centroids of the fornix after clustering (with random colors):
"""
colormap = np.random.rand(len(clusters), 3)
fvtk.clear(ren)
ren.SetBackground(1, 1, 1)
less curvy regions. In contrast with ``downsample`` it does not enforce that
segments should be of equal size.
"""
bundle_downsampled2 = [approx_polygon_track(s, 0.25) for s in bundle]
n_pts_ds2 = [len(streamline) for streamline in bundle_downsampled2]
"""
Both, ``downsample`` and ``approx_polygon_track`` can be thought as methods for
lossy compression of streamlines.
"""
from dipy.viz import fvtk
ren = fvtk.ren()
ren.SetBackground(*fvtk.colors.white)
bundle_actor = fvtk.streamtube(bundle, fvtk.colors.red, linewidth=0.3)
fvtk.add(ren, bundle_actor)
bundle_actor2 = fvtk.streamtube(bundle_downsampled,
fvtk.colors.red,
linewidth=0.3)
bundle_actor2.SetPosition(0, 40, 0)
bundle_actor3 = fvtk.streamtube(bundle_downsampled2,
fvtk.colors.red,
linewidth=0.3)
bundle_actor3.SetPosition(0, 80, 0)
fvtk.add(ren, bundle_actor2)
fvtk.add(ren, bundle_actor3)
segments should be of equal size. """ bundle_downsampled2 = [approx_polygon_track(s, 0.25) for s in bundle] n_pts_ds2 = [len(streamline) for streamline in bundle_downsampled2] """ Both, ``downsample`` and ``approx_polygon_track`` can be thought as methods for lossy compression of streamlines. """ from dipy.viz import fvtk ren = fvtk.ren() ren.SetBackground(*fvtk.colors.white) bundle_actor = fvtk.streamtube(bundle, fvtk.colors.red, linewidth=0.3) fvtk.add(ren, bundle_actor) bundle_actor2 = fvtk.streamtube(bundle_downsampled, fvtk.colors.red, linewidth=0.3) bundle_actor2.SetPosition(0, 40, 0) bundle_actor3 = fvtk.streamtube(bundle_downsampled2, fvtk.colors.red, linewidth=0.3) bundle_actor3.SetPosition(0, 80, 0) fvtk.add(ren, bundle_actor2) fvtk.add(ren, bundle_actor3) fvtk.camera(ren, pos=(0, 0, 0), focal=(30, 0, 0)) fvtk.record(ren, out_path="simulated_cosine_bundle.png", size=(900, 900))
t1_data = t1.get_data() t1_aff = t1.get_affine() color = line_colors(streamlines) """ To speed up visualization, we will select a random sub-set of streamlines to display. This is particularly important, if you track from seeds throughout the entire white matter, generating many streamlines. In this case, for demonstration purposes, we subselect 900 streamlines. """ from dipy.tracking.streamline import select_random_set_of_streamlines plot_streamlines = select_random_set_of_streamlines(streamlines, 900) streamlines_actor = fvtk.streamtube(list(move_streamlines(plot_streamlines, inv(t1_aff))), line_colors(streamlines)) vol_actor = fvtk.slicer(t1_data, voxsz=(1.0, 1.0, 1.0), plane_i=[40], plane_j=None, plane_k=[35], outline=False) ren = fvtk.ren() fvtk.add(ren, streamlines_actor) fvtk.add(ren, vol_actor) fvtk.record(ren, n_frames=1, out_path="sfm_streamlines.png", size=(800, 800)) """ .. figure:: sfm_streamlines.png :align: center **Sparse Fascicle Model tracks** Finally, we can save these streamlines to a 'trk' file, for use in other
e2 = dm_small2[np.triu_indices(dm_small2.shape[0],1)]
spgk[i] = np.multiply.outer(np.exp(-e1), np.exp(-e2)).sum()
print i, spgk[i]
r = fvtk.ren()
# lines = tracks
# c = fvtk.streamtube(lines, fvtk.colors.red)
# fvtk.add(r,c)
# lines = tracks[np.argsort(spgk)[-30:]]
# c = fvtk.streamtube(lines, fvtk.colors.red)
# fvtk.add(r,c)
lines = tracks[idx1]
c = fvtk.streamtube(lines, fvtk.colors.red)
fvtk.add(r,c)
lines = [tracks[sid]]
c = fvtk.streamtube(lines, fvtk.colors.cyan)
fvtk.add(r,c)
# lines = tracks[idx1]
# c = fvtk.streamtube(lines, fvtk.colors.cyan)
# fvtk.add(r,c)
# lines = tracks[sid]
# c = fvtk.streamtube(lines, fvtk.colors.cyan)
# fvtk.add(r,c)
best = np.argsort(spgk)[-1] # np.argmax(spgk)
lines = tracks[kdt.query_radius(dp[best], radius)[0]]
c = fvtk.streamtube(lines, fvtk.colors.carrot)
fvtk.add(r,c)
# We'll need to know where the corpus callosum is from these variables.
hardi_img, gtab, labels_img = read_stanford_labels()
labels = labels_img.get_data()
cc_slice = labels == 2
t1 = read_stanford_t1()
t1_data = t1.get_data()
data = hardi_img.get_data()
# Read the candidates from file in voxel space:
candidate_sl = [
s[0]
for s in nib.trackvis.read(args.input_trackvis, points_space='voxel')[0]
]
# Visualize the initial candidate group of streamlines
# in 3D, relative to the anatomical structure of this brain.
candidate_streamlines_actor = fvtk.streamtube(candidate_sl,
line_colors(candidate_sl))
cc_ROI_actor = fvtk.contour(cc_slice,
levels=[1],
colors=[(1., 1., 0.)],
opacities=[1.])
vol_actor = fvtk.slicer(t1_data)
vol_actor.display(40, None, None)
vol_actor2 = vol_actor.copy()
vol_actor2.display(None, None, 35)
# Add display objects to canvas.
ren = fvtk.ren()
fvtk.add(ren, candidate_streamlines_actor)
fvtk.add(ren, cc_ROI_actor)
fvtk.add(ren, vol_actor)
fvtk.add(ren, vol_actor2)
fvtk.record(ren, n_frames=1, out_path="life_candidates.png", size=(800, 800))
"""
ren = fvtk.ren()
"""
Every streamline will be coloured according to its orientation
"""
from dipy.viz.colormap import line_colors
"""
fvtk.line adds a streamline actor for streamline visualization
and fvtk.add adds this actor in the scene
"""
fvtk.add(ren, fvtk.streamtube(tensor_streamlines, line_colors(tensor_streamlines)))
print('Saving illustration as tensor_tracks.png')
ren.SetBackground(1, 1, 1)
fvtk.record(ren, n_frames=1, out_path='tensor_tracks.png', size=(600, 600))
"""
.. figure:: tensor_tracks.png
:align: center
**Deterministic streamlines with EuDX on a Tensor Field**.
.. include:: ../links_names.inc
"""
ref_vec = set_number_of_points(data['streamlines'][ref_idx], p_per_strm)
srr = StreamlineLinearRegistration()
for i,strm in enumerate(data['streamlines']):
print 'registering %d/%d' % (i,len(data['file'])-1)
print '# streamlines = %d' %len(strm)
if len(strm) == 0 or i==ref_idx:
print 'skipping'
continue
mov_vec = set_number_of_points(strm, 20)
srm = srr.optimize(static=ref_vec, moving=mov_vec)
data['aligned_strms'].append(srm.transform(mov_vec))
from dipy.viz import fvtk
ren = fvtk.ren()
ren.SetBackground(1., 1, 1)
reflines = fvtk.streamtube(ref_vec, fvtk.colors.red, linewidth=0.2)
fvtk.add(ren, reflines)
for (i, bundle) in enumerate(data['aligned_strms']):
lines = fvtk.streamtube(bundle, np.random.rand(3), linewidth=0.1)
# lines.RotateX(-90)
# lines.RotateZ(90)
fvtk.add(ren, lines)
fvtk.show(ren)
The streamlines that are entered into the model are termed 'candidate
streamliness' (or a 'candidate connectome'):
"""
"""
Let's visualize the initial candidate group of streamlines in 3D, relative to the
anatomical structure of this brain:
"""
from dipy.viz.colormap import line_colors
from dipy.viz import fvtk
candidate_streamlines_actor = fvtk.streamtube(candidate_sl,
line_colors(candidate_sl))
cc_ROI_actor = fvtk.contour(cc_slice, levels=[1], colors=[(1., 1., 0.)],
opacities=[1.])
vol_actor = fvtk.slicer(t1_data, voxsz=(1.0, 1.0, 1.0), plane_i=[40],
plane_j=None, plane_k=[35], outline=False)
# Add display objects to canvas
ren = fvtk.ren()
fvtk.add(ren, candidate_streamlines_actor)
fvtk.add(ren, cc_ROI_actor)
fvtk.add(ren, vol_actor)
fvtk.record(ren, n_frames=1, out_path='life_candidates.png',
size=(800, 800))
"""
.. figure:: life_candidates.png
subject_A = 210
subject_B = 205
side = 'L' # or 'R'
show = False
k = 100
filename = 'data_als/%d/tracks_dti_3M_linear.trk'
filename_A = filename % subject_A
filename_B = filename % subject_B
streamlines_A, cst_ids_A, Pi_ids_A, dr_A = load_or_create(subject_A, side, k=k)
streamlines_B, cst_ids_B, Pi_ids_B, dr_B = load_or_create(subject_B, side, k=k)
if show:
r = fvtk.ren()
cst_viz_A = fvtk.streamtube(cst_streamlines_A, fvtk.colors.red)
cst_viz_B = fvtk.streamtube(cst_streamlines_B, fvtk.colors.blue)
fvtk.add(r, cst_viz_A)
fvtk.add(r, cst_viz_B)
fvtk.show(r)
if show:
r = fvtk.ren()
Pi_viz_A = fvtk.streamtube(streamlines_A[Pi_ids_A], fvtk.colors.red)
fvtk.add(r, Pi_viz_A)
Pi_viz_B = fvtk.streamtube(streamlines_B[Pi_ids_B], fvtk.colors.blue)
fvtk.add(r, Pi_viz_B)
fvtk.show(r)
print "Computing the distance matrix between Pi_A streamlines."
dm_Pi_A = bundles_distances_mam(streamlines_A[Pi_ids_A], streamlines_A[Pi_ids_A])
metric = SumPointwiseEuclideanMetric(feature=ArcLengthFeature())
qb = QuickBundles(threshold=2., metric=metric)
clusters = qb.cluster(streamlines)
"""
We will now visualize the clustering result.
"""
# Color each streamline according to the cluster they belong to.
colormap = fvtk.create_colormap(np.ravel(clusters.centroids))
colormap_full = np.ones((len(streamlines), 3))
for cluster, color in zip(clusters, colormap):
colormap_full[cluster.indices] = color
ren = fvtk.ren()
ren.SetBackground(1, 1, 1)
fvtk.add(ren, fvtk.streamtube(streamlines, colormap_full))
fvtk.record(ren,
n_frames=1,
out_path='fornix_clusters_arclength.png',
size=(600, 600))
"""
.. figure:: fornix_clusters_arclength.png
:align: center
**Showing the different clusters obtained by using the arc length**.
Extending `Metric`
==================
This section will guide you through the creation of a new metric that can be
used in the context of this clustering framework. For a list of available
[ 78.98937225, 89.57682037, 85.63652039],
[ 74.72344208, 86.60827637, 84.9391861 ],
[ 70.40846252, 85.15874481, 82.4484024 ],
[ 66.74534607, 86.00262451, 78.82582092],
[ 64.02451324, 88.43942261, 75.0697403 ]], dtype=float32)
`clusters` has also attributes like `centroids` (cluster representatives), and
methods like `add`, `remove`, and `clear` to modify the clustering result.
Lets first show the initial dataset.
"""
ren = fvtk.ren()
ren.SetBackground(1, 1, 1)
fvtk.add(ren, fvtk.streamtube(streamlines, fvtk.colors.white))
fvtk.record(ren, n_frames=1, out_path='fornix_initial.png', size=(600, 600))
"""
.. figure:: fornix_initial.png
:align: center
Initial Fornix dataset.
Show the centroids of the fornix after clustering (with random colors):
"""
colormap = fvtk.create_colormap(np.arange(len(clusters)))
fvtk.clear(ren)
ren.SetBackground(1, 1, 1)
fvtk.add(ren, fvtk.streamtube(streamlines, fvtk.colors.white, opacity=0.05))
# Extract feature of every streamline.
centers = np.asarray(map(feature.extract, streamlines))
# Color each center of mass according to the cluster they belong to.
rng = np.random.RandomState(42)
colormap = fvtk.create_colormap(np.arange(len(clusters)))
colormap_full = np.ones((len(streamlines), 3))
for cluster, color in zip(clusters, colormap):
colormap_full[cluster.indices] = color
# Visualization
ren = fvtk.ren()
fvtk.clear(ren)
ren.SetBackground(0, 0, 0)
fvtk.add(ren, fvtk.streamtube(streamlines, fvtk.colors.white, opacity=0.05))
fvtk.add(ren, fvtk.point(centers[:, 0, :], colormap_full, point_radius=0.2))
fvtk.record(ren,
n_frames=1,
out_path='center_of_mass_feature.png',
size=(600, 600))
"""
.. figure:: center_of_mass_feature.png
:align: center
**Showing the center of mass of each streamline and colored according to
the QuickBundles results**.
.. _clustering-examples-MidpointFeature:
Midpoint Feature
Create a scene.
"""
ren = fvtk.ren()
"""
Every streamline will be coloured according to its orientation
"""
from dipy.viz.colormap import line_colors
"""
fvtk.line adds a streamline actor for streamline visualization
and fvtk.add adds this actor in the scene
"""
fvtk.add(ren,
fvtk.streamtube(tensor_streamlines, line_colors(tensor_streamlines)))
print('Saving illustration as tensor_tracks.png')
ren.SetBackground(1, 1, 1)
fvtk.record(ren, n_frames=1, out_path='tensor_tracks.png', size=(600, 600))
"""
.. figure:: tensor_tracks.png
:align: center
**Deterministic streamlines with EuDX on a Tensor Field**.
.. [Garyfallidis12] Garyfallidis E., "Towards an accurate brain tractography", PhD thesis, University of Cambridge, 2012.
.. include:: ../links_names.inc
print "loss =", loss_coregistration_1nn
if do_simulated_annealing_from_1nn:
print
print "Simulated Annealing"
np.random.seed(1) # this is the random seed of the optimization process
initial_state = mapping12_coregistration_1nn
mapping12_best_from_1nn, energy_best_from_1nn = anneal(
initial_state=initial_state,
energy_function=loss_function,
neighbour=neighbour4,
transition_probability=transition_probability,
temperature=temperature_boltzmann,
max_steps=iterations_anneal,
energy_max=0.0,
T0=200.0,
log_every=1000,
)
if show:
from dipy.viz import fvtk
sid = 22
r = fvtk.ren()
# fvtk.add(r, fvtk.streamtube(tractography1, fvtk.colors.orange))
# fvtk.add(r, fvtk.streamtube(tractography2, fvtk.colors.blue))
fvtk.add(r, fvtk.streamtube([tractography1[sid]], fvtk.colors.red))
fvtk.add(r, fvtk.streamtube([tractography2[mapping12_best[sid]]], fvtk.colors.cyan))
fvtk.add(r, fvtk.streamtube([tractography2[mapping12_coregistration_1nn[sid]]], fvtk.colors.green))
fvtk.show(r)
