def show_all_bundles(start, end): ren = fvtk.ren() ren.SetBackground(1, 1, 1.) from dipy.viz.fvtk import colors as c colors = [c.alice_blue, c.maroon, c.alizarin_crimson, c.mars_orange, c.antique_white, c.mars_yellow, c.aquamarine, c.melon, c.aquamarine_medium, c.midnight_blue, c.aureoline_yellow, c.mint, c.azure, c.mint_cream, c.banana, c.misty_rose, c.beige] print(len(colors)) for (i, bundle) in enumerate(bundle_names[start:end]): bun = load_bundle(bundle) bun_actor = vtk_a.streamtube(bun, colors[i], linewidth=0.5, tube_sides=9) fvtk.add(ren, bun_actor) fvtk.show(ren, size=(1800, 1000)) #fvtk.record(ren, n_frames=100, out_path='test.png', # magnification=1) fvtk.record(ren, size=(1800, 1000), n_frames=100, out_path='test.png', path_numbering=True, magnification=1)
def visualize_bundles(trk, ren=None, inline=True, interact=False): """ Visualize bundles in 3D using fvtk """ if isinstance(trk, str): trk = nib.streamlines.load(trk) if ren is None: ren = fvtk.ren() for b in np.unique(trk.tractogram.data_per_streamline['bundle']): idx = np.where(trk.tractogram.data_per_streamline['bundle'] == b)[0] this_sl = list(trk.streamlines[idx]) sl_actor = fvtk.line(this_sl, Tableau_20.colors[int(b)]) fvtk.add(ren, sl_actor) if inline: tdir = tempfile.gettempdir() fname = op.join(tdir, "fig.png") fvtk.record(ren, out_path=fname) display.display_png(display.Image(fname)) if interact: fvtk.show(ren) return ren
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 show_odfs(peaks, sphere, fname): ren = fvtk.ren() ren.SetBackground(1, 1, 1.) odf = np.dot(peaks.shm_coeff, peaks.invB) #odf = odf[14:24, 22, 23:33] #odf = odf[:, 22, :] odf = odf[:, 0, :] sfu = fvtk.sphere_funcs(odf[:, None, :], sphere, norm=True) sfu.RotateX(-90) fvtk.add(ren, sfu) fvtk.show(ren) fvtk.record(ren, n_frames=1, out_path=fname, size=(600, 600))
def label_streamlines(streamlines, labels, labels_Value, affine, hdr, f_name, data_path): cc_slice = labels == labels_Value cc_streamlines = utils.target(streamlines, labels, affine=affine) cc_streamlines = list(cc_streamlines) other_streamlines = utils.target(streamlines, cc_slice, affine=affine, include=False) other_streamlines = list(other_streamlines) assert len(other_streamlines) + len(cc_streamlines) == len(streamlines) print("num of roi steamlines is %d", len(cc_streamlines)) # Make display objects color = line_colors(cc_streamlines) cc_streamlines_actor = fvtk.line(cc_streamlines, line_colors(cc_streamlines)) cc_ROI_actor = fvtk.contour(cc_slice, levels=[1], colors=[(1., 1., 0.)], opacities=[1.]) # Add display objects to canvas r = fvtk.ren() fvtk.add(r, cc_streamlines_actor) fvtk.add(r, cc_ROI_actor) # Save figures fvtk.record(r, n_frames=1, out_path=f_name + '_roi.png', size=(800, 800)) fvtk.camera(r, [-1, 0, 0], [0, 0, 0], viewup=[0, 0, 1]) fvtk.record(r, n_frames=1, out_path=f_name + '_roi.png', size=(800, 800)) """""" csd_streamlines_trk = ((sl, None, None) for sl in cc_streamlines) csd_sl_fname = f_name + '_roi_streamline.trk' nib.trackvis.write(csd_sl_fname, csd_streamlines_trk, hdr, points_space='voxel') #nib.save(nib.Nifti1Image(FA, img.get_affine()), 'FA_map2.nii.gz') print('Saving "_roi_streamline.trk" sucessful.') import tractconverter as tc input_format = tc.detect_format(csd_sl_fname) input = input_format(csd_sl_fname) output = tc.FORMATS['vtk'].create(csd_sl_fname + ".vtk", input.hdr) tc.convert(input, output) return cc_streamlines
def show_odfs(fpng, odf_sh, invB, sphere): ren = fvtk.ren() ren.SetBackground(1, 1, 1.0) odf = np.dot(odf_sh, invB) print(odf.shape) odf = odf[14:24, 22, 23:33] # odf = odf[:, 22, :] # odf = odf[:, 0, :] sfu = fvtk.sphere_funcs(odf[:, None, :], sphere, norm=True) sfu.RotateX(-90) fvtk.add(ren, sfu) fvtk.show(ren) fvtk.record(ren, n_frames=1, out_path=fpng, size=(900, 900)) fvtk.clear(ren)
def show_odfs_with_map2(odf, sphere, map, w, fpng): ren = fvtk.ren() sfu = fvtk.sphere_funcs(odf, sphere, norm=True) #sfu.RotateX(-90) sfu.SetPosition(w, w, 1) sfu.SetScale(0.435) sli = fvtk.slicer(map, plane_i=None, plane_k=[0], outline=False) #sli.RotateX(-90) fvtk.add(ren, sli) fvtk.add(ren, sfu) #fvtk.add(ren, fvtk.axes((20, 20, 20))) #fvtk.show(ren) fvtk.record(ren, n_frames=1, out_path=fpng, magnification=2, 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_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 label_streamlines(streamlines,labels,labels_Value,affine,hdr,f_name,data_path): cc_slice=labels==labels_Value cc_streamlines = utils.target(streamlines, labels, affine=affine) cc_streamlines = list(cc_streamlines) other_streamlines = utils.target(streamlines, cc_slice, affine=affine, include=False) other_streamlines = list(other_streamlines) assert len(other_streamlines) + len(cc_streamlines) == len(streamlines) print ("num of roi steamlines is %d",len(cc_streamlines)) # Make display objects color = line_colors(cc_streamlines) cc_streamlines_actor = fvtk.line(cc_streamlines, line_colors(cc_streamlines)) cc_ROI_actor = fvtk.contour(cc_slice, levels=[1], colors=[(1., 1., 0.)], opacities=[1.]) # Add display objects to canvas r = fvtk.ren() fvtk.add(r, cc_streamlines_actor) fvtk.add(r, cc_ROI_actor) # Save figures fvtk.record(r, n_frames=1, out_path=f_name+'_roi.png', size=(800, 800)) fvtk.camera(r, [-1, 0, 0], [0, 0, 0], viewup=[0, 0, 1]) fvtk.record(r, n_frames=1, out_path=f_name+'_roi.png', size=(800, 800)) """""" csd_streamlines_trk = ((sl, None, None) for sl in cc_streamlines) csd_sl_fname = f_name+'_roi_streamline.trk' nib.trackvis.write(csd_sl_fname, csd_streamlines_trk, hdr, points_space='voxel') #nib.save(nib.Nifti1Image(FA, img.get_affine()), 'FA_map2.nii.gz') print('Saving "_roi_streamline.trk" sucessful.') import tractconverter as tc input_format=tc.detect_format(csd_sl_fname) input=input_format(csd_sl_fname) output=tc.FORMATS['vtk'].create(csd_sl_fname+".vtk",input.hdr) tc.convert(input,output) return cc_streamlines
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 show_peak_directions(fpng, peaks, scale=0.3, x=10, y=0, z=10): r = fvtk.ren() for index in ndindex(peaks.shape[:-1]): peak = peaks[index] directions = peak.reshape(peak.shape[0] / 3, 3) # pos = np.array(index) for i in xrange(directions.shape[0]): if norm(directions[i]) != 0: line_actor = fvtk.line( index + scale * np.vstack((-directions[i], directions[i])), abs(directions[i] / norm(directions[i])) ) line_actor.RotateX(-90) fvtk.add(r, line_actor) fvtk.show(r) fvtk.record(r, out_path=fpng, size=(900, 900)) fvtk.clear(r)
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))
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)) """ .. figure:: life_candidates.png :align: center **Candidate connectome before life optimization** """ """ Next, we initialize a LiFE model. We import the `dipy.tracking.life` module, which contains the classes and functions that implement the model: """
all_shift = [c + np.array([10, 0, 0]) for c in all] all_shift2 = [c + np.array([20, 0, 0]) for c in all] colors = np.zeros((len(all), 3)) colors2 = np.zeros((len(all), 3)) for (i, a) in enumerate(all): #print a[0] colors[i] = cm.boys2rgb(allo[i]) colors2[i] = cm.orient2rgb(allo[i]) fvtk.add(r, fvtk.line(all_shift, colors, linewidth=1.)) fvtk.add(r, fvtk.line(all_shift2, colors2, linewidth=2.)) """ .. figure:: visualize_cross1000000.png :align: center **The crossings of a region of interest shown with one color, or boy2rgb or standard orient2rgb colormap**. .. include:: ../links_names.inc """ # To show the figure # fvtk.show(r,size=(800,800)) # Here's how we make the illustration. print('Saving illustration as visualize_cross1000000.png') fvtk.record(r, n_frames=1, out_path='visualize_cross', size=(600, 600))
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`. Assuming a set of streamlines, we want a metric that computes the cosine
""" qb = QuickBundles(streamlines, dist_thr=10., pts=18) """ qb has attributes like `centroids` (cluster representatives), `total_clusters` (total number of clusters) and methods like `partitions` (complete description of all clusters) and `label2tracksids` (provides the indices of the streamlines which belong in a specific cluster). Lets first show the initial dataset. """ r = fvtk.ren() fvtk.add(r, fvtk.line(streamlines, fvtk.white, opacity=1, linewidth=3)) fvtk.record(r, 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): """ centroids = qb.centroids colormap = np.random.rand(len(centroids), 3) fvtk.clear(r) fvtk.add(r, fvtk.line(centroids, colormap, opacity=1., linewidth=5))
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 """
# Instantiate model from dipy.reconst.multi_voxel import multi_voxel_fit SparseKernelModel.fit = multi_voxel_fit(SparseKernelModel.fit) #from dipy.segment.mask import median_otsu #maskdata, mask = median_otsu(data, 3, 1, True, # vol_idx=range(10, 50), dilate=2) # Select segment of data to work with data_small = data[13:43, 44:74, 28:29] fit = model.fit(data_small) sphere = get_sphere('symmetric724') odfs = fit.odf(sphere) # It is common for some models to produce negative values, we can remove those # using ``np.clip`` odfs = np.clip(odfs, 0, np.max(odfs, -1)[..., None]) # Visualie from dipy.viz import fvtk r = fvtk.ren() fvtk.add(r, fvtk.sphere_funcs(odfs, sphere, colormap='jet')) fn = model.__class__.__name__ + '_odfs.png' print('Saving illustration as %s' % fn) fvtk.record(r, n_frames=1, out_path=fn, size=(600, 600))
fit_wls = dti_wls.fit(data) fa1 = fit_wls.fa evals1 = fit_wls.evals evecs1 = fit_wls.evecs cfa1 = dti.color_fa(fa1, evecs1) sphere = dpd.get_sphere('symmetric724') """ We visualize the ODFs in the ROI using fvtk: """ ren = fvtk.ren() fvtk.add(ren, fvtk.tensor(evals1, evecs1, cfa1, sphere)) print('Saving illustration as tensor_ellipsoids_wls.png') fvtk.record(ren, n_frames=1, out_path='tensor_ellipsoids_wls.png', size=(600, 600)) """ .. figure:: tensor_ellipsoids_wls.png :align: center **Tensor Ellipsoids**. """ fvtk.clear(ren) """ Next, we corrupt the data with some noise. To simulate a subject that moves intermittently, we will replace a few of the images with a very low signal """
dsid_model = DiffusionSpectrumDeconvModel(gtab) dsid_odf = dsid_model.fit(signal).odf(sphere) """ Finally, we can visualize the ground truth ODF, together with the DSI and DSI with deconvolution ODFs and observe that with the deconvolved method it is easier to resolve the correct fiber directions because the ODF is sharper. """ from dipy.viz import fvtk ren = fvtk.ren() odfs = np.vstack((odf_gt, dsi_odf, dsid_odf))[:, None, None] odf_actor = fvtk.sphere_funcs(odfs, sphere) odf_actor.RotateX(90) fvtk.add(ren, odf_actor) fvtk.record(ren, out_path='dsid.png', size=(300, 300)) """ .. figure:: dsid.png :align: center **Ground truth ODF (left), DSI ODF (middle), DSI with Deconvolution ODF(right)** .. [Canales10] Canales-Rodriguez et al., Deconvolution in Diffusion Spectrum Imaging, Neuroimage, vol 50, no 1, 136-149, 2010. """
distributed on the hemisphere. Let's visualize them. """ from dipy.viz import fvtk ren = fvtk.ren() ren.SetBackground(1, 1, 1) fvtk.add(ren, fvtk.point(hsph_initial.vertices, fvtk.colors.red, point_radius=0.05)) fvtk.add( ren, fvtk.point(hsph_updated.vertices, fvtk.colors.green, point_radius=0.05)) print('Saving illustration as initial_vs_updated.png') fvtk.record(ren, out_path='initial_vs_updated.png', size=(300, 300)) """ .. figure:: initial_vs_updated.png :align: center **Example of electrostatic repulsion of red points which become green points**. We can also create a sphere from the hemisphere and show it in the following way. """ sph = Sphere(xyz=np.vstack((hsph_updated.vertices, -hsph_updated.vertices))) fvtk.rm_all(ren) fvtk.add(ren, fvtk.point(sph.vertices, fvtk.colors.green, point_radius=0.05)) print('Saving illustration as full_sphere.png')
filename = os.path.join(os.getcwd(), 'test_data', filename) plt.style.use('ggplot') # Create a render object ren = fvtk.ren() # Define values for fODF reconstruction evals = np.array([2, 2, 5]) evecs = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]]) # Set a shpere sphere = get_sphere('symmetric642') # Assign responses response_odf = single_tensor_odf(sphere.vertices, evals, evecs) response_actor = fvtk.sphere_funcs(response_odf, sphere) # Render the spherical function fvtk.add(ren, response_actor) print('[ OK ]\t Saving illustration: ' + filename) fvtk.record(ren, out_path=filename, size=size) print('[ OK ] DONE!') # Visualise the output img = plt.imread(filename) plt.imshow(img) plt.axis('off') plt.show()
dsid_odf = dsid_model.fit(signal).odf(sphere) """ Finally, we can visualize the ground truth ODF, together with the DSI and DSI with deconvolution ODFs and observe that with the deconvolved method it is easier to resolve the correct fiber directions because the ODF is sharper. """ from dipy.viz import fvtk ren = fvtk.ren() odfs = np.vstack((odf_gt, dsi_odf, dsid_odf))[:, None, None] odf_actor = fvtk.sphere_funcs(odfs, sphere) odf_actor.RotateX(90) fvtk.add(ren, odf_actor) fvtk.record(ren, out_path='dsid.png', size=(300, 300)) """ .. figure:: dsid.png :align: center **Ground truth ODF (left), DSI ODF (middle), DSI with Deconvolution ODF(right)** .. [Canales10] Canales-Rodriguez et al., Deconvolution in Diffusion Spectrum Imaging, Neuroimage, vol 50, no 1, 136-149, 2010. """
[ 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)) fvtk.add(ren, fvtk.streamtube(clusters.centroids, colormap, linewidth=0.4))
threshold_classifier, seeds, affine, step_size=.5, return_all=True) save_trk("deterministic_threshold_classifier_all.trk", all_streamlines_threshold_classifier, affine, labels.shape) streamlines = [sl for sl in all_streamlines_threshold_classifier] fvtk.clear(ren) fvtk.add(ren, fvtk.line(streamlines, line_colors(streamlines))) fvtk.record(ren, out_path='all_streamlines_threshold_classifier.png', size=(600, 600)) """ .. figure:: all_streamlines_threshold_classifier.png :align: center **Deterministic tractography using a thresholded fractional anisotropy.** """ """ Binary Tissue Classifier ------------------------ A binary mask can be used to define where the tracking stops. The binary tissue classifier stops the tracking whenever the tracking position is outside the mask. Here, we show how to obtain the binary tissue classifier from
""" Fitting the model to this small volume of data, we calculate the ODF of this model on the sphere, and plot it. """ sf_fit = sf_model.fit(data_small) sf_odf = sf_fit.odf(sphere) fodf_spheres = fvtk.sphere_funcs(sf_odf, sphere, scale=1.3, norm=True) ren = fvtk.ren() fvtk.add(ren, fodf_spheres) print('Saving illustration as sf_odfs.png') fvtk.record(ren, out_path='sf_odfs.png', size=(1000, 1000)) """ We can extract the peaks from the ODF, and plot these as well """ sf_peaks = dpp.peaks_from_model(sf_model, data_small, sphere, relative_peak_threshold=.5, min_separation_angle=25, return_sh=False) fvtk.clear(ren) fodf_peaks = fvtk.peaks(sf_peaks.peak_dirs, sf_peaks.peak_values, scale=1.3)
stopping_values[:] = FA[..., None] """ For quality assurance we can also visualize a slice from the direction field which we will use as the basis to perform the tracking. """ ren = fvtk.ren() slice_no = data.shape[2] / 2 fvtk.add(ren, fvtk.peaks(csd_peaks.peak_dirs[:, :, slice_no:slice_no + 1], stopping_values[:, :, slice_no:slice_no + 1])) print('Saving illustration as csd_direction_field.png') fvtk.record(ren, out_path='csd_direction_field.png', size=(900, 900)) """ .. figure:: csd_direction_field.png :align: center **Direction Field (peaks)** ``EuDX`` [Garyfallidis12]_ is a fast algorithm that we use here to generate streamlines. If the parameter ``seeds`` is a positive integer it will generate that number of randomly placed seeds everywhere in the volume. Alternatively, you can specify the exact seed points using an array (N, 3) where N is the number of seed points. For simplicity, here we will use the first option (random seeds). ``a_low`` is the threshold of the fist parameter (``stopping_values``) which means that there will that tracking will stop in regions with FA < 0.1.
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)) shutil.move("life_candidates.png", args.output_life_candidates)
def main(): parser = _build_arg_parser() args = parser.parse_args() logging.basicConfig(level=logging.INFO) assert_inputs_exist(parser, [args.bvecs_in, args.eddyparams]) assert_outputs_exists(parser, args, [args.bvecs_out, args.trans, args.angles]) _, bvecs = read_bvals_bvecs(None, args.bvecs_in) eddy = np.loadtxt(args.eddyparams) eddy_a = np.array(eddy) bvecs_rotated = np.zeros(bvecs.shape) norm_diff = np.zeros(bvecs.shape[0]) angle = np.zeros(bvecs.shape[0]) # Documentation here: http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/eddy/Faq # Will eddy rotate my bvecs for me? # No, it will not. There is nothing to prevent you from doing that # yourself though. eddy produces two output files, one with the corrected # images and another a text file with one row of parameters for each volume # in the --imain file. Columns 4-6 of these rows pertain to rotation # (in radians) around around the x-, y- and z-axes respectively. # eddy uses "pre-multiplication". # IMPORTANT: from various emails with FSL's people, we couldn't directly # get the information about the handedness of the system. # From the FAQ linked earlier, we deduced that the system # is considered left-handed, and therefore the following # matrices are correct. for i in range(len(bvecs)): theta_x = eddy_a[i, 3] theta_y = eddy_a[i, 4] theta_z = eddy_a[i, 5] Rx = np.array([[1, 0, 0], [0, np.cos(theta_x), np.sin(theta_x)], [0, -np.sin(theta_x), np.cos(theta_x)]]) Ry = np.array([[np.cos(theta_y), 0, -np.sin(theta_y)], [0, 1, 0], [np.sin(theta_y), 0, np.cos(theta_y)]]) Rz = np.array([[np.cos(theta_z), np.sin(theta_z), 0], [-np.sin(theta_z), np.cos(theta_z), 0], [0, 0, 1]]) v = bvecs[i, :] rotation_matrix = np.linalg.inv(np.dot(np.dot(Rx, Ry), Rz)) v_rotated = np.dot(rotation_matrix, v) bvecs_rotated[i, :] = v_rotated norm_diff[i] = np.linalg.norm(v - v_rotated) if np.linalg.norm(v): angle[i] = np.arctan2(np.linalg.norm(np.cross(v, v_rotated)), np.dot(v, v_rotated)) logging.info('%s mm is the maximum translation error', np.max(norm_diff)) logging.info('%s degrees is the maximum rotation error', np.max(angle) * 180 / np.pi) if args.vis: print('Red points are the original & Green points are the motion ' 'corrected ones') ren = fvtk.ren() sphere_actor = fvtk.point(bvecs, colors=fvtk.colors.red, opacity=1, point_radius=0.01, theta=10, phi=20) fvtk.add(ren, sphere_actor) sphere_actor_rot = fvtk.point(bvecs_rotated, colors=fvtk.colors.green, opacity=1, point_radius=0.01, theta=10, phi=20) fvtk.add(ren, sphere_actor_rot) fvtk.show(ren) fvtk.record(ren, n_frames=1, out_path=args.bvecs_out + '.png', size=(600, 600)) np.savetxt(args.bvecs_out, bvecs_rotated.T) if args.trans: np.savetxt(args.trans, norm_diff) if args.angles: np.savetxt(args.angles, angle * 180 / np.pi)
Fit the SHORE model to the data """ asmfit = asm.fit(data_small) """ Load an odf reconstruction sphere """ sphere = get_sphere('symmetric724') """ Compute the ODF """ odf = asmfit.odf(sphere) print('odf.shape (%d, %d, %d)' % odf.shape) """ Display the ODFs """ r = fvtk.ren() fvtk.add(r, fvtk.sphere_funcs(odf, sphere, colormap='jet')) fvtk.show(r) fvtk.record(r, n_frames=1, out_path='odfs.png', size=(600, 600)) """ .. include:: ../links_names.inc """
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)) """ .. figure:: sfm_streamlines.png :align: center **Sparse Fascicle Model tracks** Finally, we can save these streamlines to a 'trk' file, for use in other software, or for further analysis. """ from dipy.io.trackvis import save_trk save_trk("sfm_detr.trk", streamlines, affine, labels.shape) """
# part for changing including streamlines only longer than particular length, here 50 from dipy.tracking.metrics import length longer_streamlines = [] for tract in streamlines: if length(tract) > 50.0: longer_streamlines.append(tract) # Streamlines visualization from dipy.viz import fvtk from dipy.viz.colormap import line_colors # Make display objects streamlines_actor = fvtk.line(longer_streamlines, line_colors(longer_streamlines)) # Add display objects to canvas r = fvtk.ren() fvtk.add(r, streamlines_actor) # Save figure fvtk.camera(r, [-1, 0, 0], [0, 0, 0], viewup=[0, 0, 1]) fvtk.record(r, n_frames=1, out_path='streamlines_saggital.png', size=(800, 800))
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 streamline. If there is an even number of points, the feature will then correspond to the point halfway between the two middle points.
from dipy.viz import fvtk from dipy.viz.colormap import line_colors # Make display objects color = line_colors(cc_streamlines) cc_streamlines_actor = fvtk.line(cc_streamlines, line_colors(cc_streamlines)) cc_ROI_actor = fvtk.contour(cc_slice, levels=[1], colors=[(1., 1., 0.)], opacities=[1.]) # Add display objects to canvas r = fvtk.ren() fvtk.add(r, cc_streamlines_actor) fvtk.add(r, cc_ROI_actor) # Save figures fvtk.record(r, n_frames=1, out_path='corpuscallosum_axial.png', size=(800, 800)) fvtk.camera(r, [-1, 0, 0], [0, 0, 0], viewup=[0, 0, 1]) fvtk.record(r, n_frames=1, out_path='corpuscallosum_sagittal.png', size=(800, 800)) """ .. figure:: corpuscallosum_axial.png :align: center **Corpus Callosum Axial** .. include:: ../links_names.inc .. figure:: corpuscallosum_sagittal.png :align: center
""" """ 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('symmetric724') sphere = sphere.subdivide(2) odf = multi_tensor_odf(sphere.vertices, mevals, angles, fractions) from dipy.viz import fvtk ren = fvtk.ren() odf_actor = fvtk.sphere_funcs(odf, sphere) odf_actor.RotateX(90) fvtk.add(ren, odf_actor) print('Saving illustration as multi_tensor_simulation') fvtk.record(ren, out_path='multi_tensor_simulation.png', size=(300, 300)) """ .. figure:: multi_tensor_simulation.png :align: center **Simulating a MultiTensor ODF** """
evals = tenfit.evals[13:43, 44:74, 28:29] evecs = tenfit.evecs[13:43, 44:74, 28:29] """ We can color the ellipsoids using the ``color_fa`` values that we calculated above. In this example we additionally normalize the values to increase the contrast. """ cfa = RGB[13:43, 44:74, 28:29] cfa /= cfa.max() fvtk.add(ren, fvtk.tensor(evals, evecs, cfa, sphere)) print('Saving illustration as tensor_ellipsoids.png') fvtk.record(ren, n_frames=1, out_path='tensor_ellipsoids.png', size=(600, 600)) """ .. figure:: tensor_ellipsoids.png :align: center **Tensor Ellipsoids**. """ fvtk.clear(ren) """ Finally, we can visualize the tensor orientation distribution functions for the same area as we did with the ellipsoids. """
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 r = fvtk.ren() fvtk.add(r, vol_actor) fvtk.add(r, vol_actor2) fvtk.add(r, cc_streamlines_actor) fvtk.add(r, cc_ROI_actor) # Save figures fvtk.record(r, n_frames=1, out_path='corpuscallosum_axial.png', size=(800, 800)) fvtk.camera(r, [-1, 0, 0], [0, 0, 0], viewup=[0, 0, 1]) fvtk.record(r, n_frames=1, out_path='corpuscallosum_sagittal.png', size=(800, 800)) """ .. figure:: corpuscallosum_axial.png :align: center **Corpus Callosum Axial** .. include:: ../links_names.inc .. figure:: corpuscallosum_sagittal.png
fit_wls = dti_wls.fit(data) fa1 = fit_wls.fa evals1 = fit_wls.evals evecs1 = fit_wls.evecs cfa1 = dti.color_fa(fa1, evecs1) sphere = dpd.get_sphere('symmetric724') """ We visualize the ODFs in the ROI using fvtk: """ ren = fvtk.ren() fvtk.add(ren, fvtk.tensor(evals1, evecs1, cfa1, sphere)) print('Saving illustration as tensor_ellipsoids_wls.png') fvtk.record(ren, n_frames=1, out_path='tensor_ellipsoids_wls.png', size=(600, 600)) """ .. figure:: tensor_ellipsoids_wls.png :align: center Tensor Ellipsoids. """ fvtk.clear(ren) """ Next, we corrupt the data with some noise. To simulate a subject that moves intermittently, we will replace a few of the images with a very low signal """ noisy_data = np.copy(data)
from dipy.viz import fvtk r=fvtk.ren() fvtk.add(r,fvtk.line(ten_tracks,fvtk.red,opacity=0.05)) gqs_tracks2=[t+np.array([10,0,0]) for t in gqs_tracks] fvtk.add(r,fvtk.line(gqs_tracks2,fvtk.green,opacity=0.05)) """ Press 's' to save this screenshot when you have displayed it with ``fvtk.show``. Or you can even record a video using ``fvtk.record``. You would show the figure with something like:: fvtk.show(r,png_magnify=1,size=(600,600)) To record a video of 50 frames of png, something like:: fvtk.record(r,cam_pos=(0,40,-40),cam_focal=(5,0,0),n_frames=50,magnification=1,out_path='nii_2_tracks',size=(600,600),bgr_color=(0,0,0)) .. figure:: nii_2_tracks1000000.png :align: center **Same region of interest with different underlying voxel representations generates different tractographies**. """ # Here's how we make the figure. print('Saving illustration as nii_2_tracks1000000.png') fvtk.record(r,n_frames=1,out_path='nii_2_tracks',size=(600,600))
fvtk.add(ren, lineactor) # Horizontal (axial) slice of T1 data vol_actor1 = fvtk.slicer(t1_data, affine=affine) vol_actor1.display(None, None, 20) fvtk.add(ren, vol_actor1) # Vertical (sagittal) slice of T1 data vol_actor2 = fvtk.slicer(t1_data, affine=affine) vol_actor2.display(35, None, None) fvtk.add(ren, vol_actor2) # Show original fibers fvtk.camera(ren, pos=(-264, 285, 155), focal=(0, -14, 9), viewup=(0, 0, 1), verbose=False) fvtk.record(ren, n_frames=1, out_path='OR_before.png', size=(900, 900)) # Show thresholded fibers fvtk.rm(ren, lineactor) fvtk.add(ren, actor.line(fbc_sl_thres, clrs_thres, linewidth=0.2)) fvtk.record(ren, n_frames=1, out_path='OR_after.png', size=(900, 900)) """ .. figure:: OR_before.png :align: center The optic radiation obtained through probabilistic tractography colored by local fiber to bundle coherence. .. figure:: OR_after.png :align: center
def record_slice(fname, data, k, show=False): ren = fvtk.ren() fvtk.add(ren, fvtk.slicer(data, plane_k=[k])) if show: fvtk.show(ren) fvtk.record(ren, out_path=fname, size=(600, 600))
# 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 streamline. If there is an even number of points, the feature will then correspond to the point halfway between the two middle points.
""" Reduce the number of points for faster visualization using the ``approx_polygon_track`` algorithm which retains points depending on how much they are need to define the shape of the track: """ T=[td.approx_polygon_track(t) for t in T] """ Show the initial *Fornix* dataset: """ r=fvtk.ren() fvtk.add(r,fvtk.line(T,fvtk.white,opacity=1)) #fvtk.show(r) fvtk.record(r,n_frames=1,out_path='fornix_initial',size=(600,600)) """ .. figure:: fornix_initial1000000.png :align: center **Initial Fornix dataset**. """ """ Show the *Fornix* after clustering (with random bundle colors): """ fvtk.clear(r) colors=np.zeros((len(T),3)) for c in C:
md1 = dti.mean_diffusivity(tenfit.evals) nibabel.save(nibabel.Nifti1Image(md1.astype(numpy.float32), img.affine), 'output_md.nii') shutil.move('output_md.nii', args.output_nifti1_md) move_directory_files(input_dir, args.output_nifti1_md_files_path, copy=True) fa = numpy.clip(fa, 0, 1) rgb = color_fa(fa, tenfit.evecs) nibabel.save(nibabel.Nifti1Image(numpy.array(255 * rgb, 'uint8'), img.affine), 'output_rgb.nii') shutil.move('output_rgb.nii', args.output_nifti1_rgb) move_directory_files(input_dir, args.output_nifti1_rgb_files_path, copy=True) sphere = get_sphere('symmetric724') ren = fvtk.ren() evals = tenfit.evals[13:43, 44:74, 28:29] evecs = tenfit.evecs[13:43, 44:74, 28:29] cfa = rgb[13:43, 44:74, 28:29] cfa /= cfa.max() fvtk.add(ren, fvtk.tensor(evals, evecs, cfa, sphere)) fvtk.record(ren, n_frames=1, out_path='tensor_ellipsoids.png', size=(600, 600)) shutil.move('tensor_ellipsoids.png', args.output_png_ellipsoids) fvtk.clear(ren) tensor_odfs = tenmodel.fit(data[20:50, 55:85, 38:39]).odf(sphere) fvtk.add(ren, fvtk.sphere_funcs(tensor_odfs, sphere, colormap=None)) fvtk.record(ren, n_frames=1, out_path='tensor_odfs.png', size=(600, 600)) shutil.move('tensor_odfs.png', args.output_png_odfs)
hdr, points_space='voxel') """ Visualize the streamlines with fvtk (python vtk is required). """ from dipy.viz import fvtk from dipy.viz.colormap import line_colors r = fvtk.ren() fvtk.add(r, fvtk.line(csa_streamlines, line_colors(csa_streamlines))) print('Saving illustration as tensor_tracks.png') fvtk.record(r, n_frames=1, out_path='csa_tracking.png', size=(600, 600)) """ .. figure:: csa_tracking.png :align: center **Deterministic streamlines with EuDX on ODF peaks field modulated by GFA**. It is also possible to use EuDX with multiple ODF peaks, which is very helpful when tracking in crossing areas. """ eu = EuDX(csapeaks.peak_values, csapeaks.peak_indices, seeds=10000, odf_vertices=sphere.vertices, ang_thr=20.,
axial_middle = data.shape[2] / 2 plt.figure('Showing the datasets') plt.subplot(1, 2, 1).set_axis_off() plt.imshow(data[:, :, axial_middle, 0].T, cmap='gray', origin='lower') plt.subplot(1, 2, 2).set_axis_off() plt.imshow(data[:, :, axial_middle, 10].T, cmap='gray', origin='lower') plt.show() plt.savefig('data.png', bbox_inches='tight') from dipy.data import get_sphere sphere = get_sphere('symmetric642') from dipy.viz import fvtk ren = fvtk.ren() evals = tenfit.evals[55:85, 80:90, 40:45] evecs = tenfit.evecs[55:85, 80:90, 40:45] cfa = Rgbv[55:80, 80:90, 40:45] #print cfa[1,1,1] cfa /= cfa.max() fvtk.add(ren, fvtk.tensor(evals, evecs, cfa)) fvtk.show(ren) print('Saving illustration as fa.png') fvtk.record(ren, n_frames=1, out_path='fa.png', size=(600, 600)) print "Hello World!"
We can double-check that we have a good response function by visualizing the response function's ODF. Here is how you would do that: """ from dipy.viz import fvtk ren = fvtk.ren() evals = response[0] evecs = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]]).T from dipy.data import get_sphere sphere = get_sphere('symmetric724') from dipy.sims.voxel import single_tensor_odf response_odf = single_tensor_odf(sphere.vertices, evals, evecs) response_actor = fvtk.sphere_funcs(response_odf, sphere) fvtk.add(ren, response_actor) print('Saving illustration as csd_response.png') fvtk.record(ren, out_path='csd_response.png', size=(200, 200)) """ .. figure:: csd_response.png :align: center **Estimated response function**. """ fvtk.rm(ren, response_actor) """ Depending on the dataset, FA threshold may not be the best way to find the best possible response function. For one, it depends on the diffusion tensor (FA and first eigenvector), which has lower accuracy at high
# Compute streamlines and store as a list. streamlines = list(streamlines) # Prepare the display objects. color = line_colors(streamlines) if fvtk.have_vtk: streamlines_actor = fvtk.line(streamlines, line_colors(streamlines)) # Create the 3d display. r = fvtk.ren() fvtk.add(r, streamlines_actor) # Save still images for this static example. Or for interactivity use # fvtk.show fvtk.record(r, n_frames=1, out_path='deterministic.png', size=(800, 800)) """ .. figure:: deterministic.png :align: center **Corpus Callosum Deterministic** We've created a deterministic set of streamlines, so called because if you repeat the fiber tracking (keeping all the inputs the same) you will get exactly the same set of streamlines. We can save the streamlines as a Trackvis file so it can be loaded into other software for visualization or further analysis. """ from dipy.io.trackvis import save_trk
Compute the ODFs The radial order s can be increased to sharpen the results, but it might also make the odfs noisier. Always check the results visually. """ odf = mapfit_both_iso.odf(sphere, s=2) print('odf.shape (%d, %d, %d, %d)' % odf.shape) """ Display the ODFs """ r = fvtk.ren() sfu = fvtk.sphere_funcs(odf, sphere, colormap='jet') sfu.RotateX(-90) fvtk.add(r, sfu) fvtk.record(r, n_frames=1, out_path='odfs.png', size=(600, 600)) """ .. figure:: odfs.png :align: center **Orientation distribution functions**. .. [Ozarslan2013]_ Ozarslan E. et. al, "Mean apparent propagator (MAP) MRI: A novel diffusion imaging method for mapping tissue microstructure", NeuroImage, 2013. .. [Fick2016]_ Fick, Rutger HJ, et al. "MAPL: Tissue microstructure estimation using Laplacian-regularized MAP-MRI and its application to HCP data." NeuroImage (2016). .. [Craven1978]_ Craven et al. "Smoothing Noisy Data with Spline Functions."
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)) """ .. figure:: simulated_cosine_bundle.png :align: center **Initial bundle (down), downsampled at 12 equidistant points (middle), downsampled not equidistantly(up)** From the figure above we can see that all 3 bundles look quite similar. However, when we plot the histogram of the number of points used for each streamline, it becomes obvious that we have managed to reduce in a great amount the size of the initial dataset. """ import matplotlib.pyplot as plt
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 """
plt.figure('Showing the datasets') plt.subplot(1, 2, 1).set_axis_off() plt.imshow(data[:, :, axial_middle, 0].T, cmap='gray', origin='lower') plt.subplot(1, 2, 2).set_axis_off() plt.imshow(data[:, :, axial_middle, 10].T, cmap='gray', origin='lower') plt.show() plt.savefig('data.png', bbox_inches='tight') from dipy.data import get_sphere sphere = get_sphere('symmetric642') from dipy.viz import fvtk ren = fvtk.ren() evals=tenfit.evals[55:85,80:90,40:45] evecs=tenfit.evecs[55:85,80:90,40:45] cfa = Rgbv[55:80, 80:90, 40:45] #print cfa[1,1,1] cfa /= cfa.max() fvtk.add(ren, fvtk.tensor(evals, evecs, cfa)) fvtk.show(ren) print('Saving illustration as fa.png') fvtk.record(ren, n_frames=1, out_path='fa.png', size=(600, 600)) print "Hello World!"