Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
We save the transform generated in this registration, so that we can use
it in the bundle profiles example
"""
np.save("slr_transform.npy", transform)
"""
let's visualize atlas tractogram and target tractogram after registration
"""
interactive = False
ren = window.Renderer()
ren.SetBackground(1, 1, 1)
ren.add(actor.line(atlas, colors=(1, 0, 1)))
ren.add(actor.line(moved, colors=(1, 1, 0)))
window.record(ren, out_path='tractograms_after_registration.png',
size=(600, 600))
if interactive:
window.show(ren)
"""
.. figure:: tractograms_after_registration.png
:align: center
Atlas and target after registration.
"""
"""
Read AF left and CST left bundles from already fetched atlas data to use them
raise ValueError("Invalid input streamline file format " +
"(must be trk): {0}".format(args.tractogram_filename))
# Load files and data. TRKs can have 'same' as reference
tractogram = load_tractogram(args.tractogram, 'same')
# Streamlines are saved in RASMM but seeds are saved in VOX
# This might produce weird behavior with non-iso
tractogram.to_vox()
streamlines = tractogram.streamlines
if 'seeds' not in tractogram.data_per_streamline:
parser.error('Tractogram does not contain seeds')
seeds = tractogram.data_per_streamline['seeds']
# Make display objects
streamlines_actor = actor.line(streamlines)
points = actor.dots(seeds, color=(1., 1., 1.))
# Add display objects to canvas
r = window.Renderer()
r.add(streamlines_actor)
r.add(points)
# Show and record if needed
if args.save is not None:
window.record(r, out_path=args.save, size=(1000, 1000))
window.show(r)
if iterator > 0:
last_choice = choices.pop()
if last_choice == 'r':
rejected_streamlines.pop()
else:
accepted_streamlines.pop()
logging.info('Rewind on step.')
iterator -= 1
else:
logging.warning('Cannot rewind, first element.')
if key in ['a', 'r', 'z'] and iterator < len(sft_accepted_on_size):
renderer.rm(curr_streamlines_actor)
curr_streamlines = sft_accepted_on_size[iterator].streamlines
curr_streamlines_actor = actor.line(curr_streamlines,
opacity=0.8,
linewidth=clusters_linewidth)
renderer.add(curr_streamlines_actor)
if iterator == len(sft_accepted_on_size):
print('No more cluster, press q to exit')
renderer.rm(curr_streamlines_actor)
renwin.Render()
sft_rejected_on_size.append(sft)
filename_rejected_on_size.append(basename)
if not filename_accepted_on_size:
parser.error('No cluster survived the cluster_size threshold.')
logging.info('{} clusters to be classified.'.format(
len(sft_accepted_on_size)))
# The clusters are sorted by size for simplicity/efficiency
tuple_accepted = zip(*sorted(zip(sft_accepted_on_size,
filename_accepted_on_size),
key=lambda x: len(x[0]), reverse=True))
sft_accepted_on_size, filename_accepted_on_size = tuple_accepted
# Initialize the actors, scene, window, observer
concat_streamlines_actor = actor.line(concat_streamlines,
colors=(1, 1, 1),
opacity=args.background_opacity,
linewidth=background_linewidth)
curr_streamlines_actor = actor.line(sft_accepted_on_size[0].streamlines,
opacity=0.8,
linewidth=clusters_linewidth)
scene = window.Scene()
interactor_style = interactor.CustomInteractorStyle()
show_manager = window.ShowManager(scene, size=(800, 800),
reset_camera=False,
interactor_style=interactor_style)
scene.add(concat_streamlines_actor)
scene.add(curr_streamlines_actor)
interactor_style.AddObserver('KeyPressEvent', keypress_callback)
renderer.add(stream_actor3)
renderer.add(bar2)
# window.show(renderer, size=(600, 600), reset_camera=False)
window.record(renderer, out_path='bundle3.png', size=(600, 600))
###############################################################################
# Show every bundle with a specific color
# ========================================
#
# You can have a bundle with a specific color. In this example, we are chosing
# orange.
renderer.clear()
stream_actor4 = actor.line(bundle_native, (1., 0.5, 0), linewidth=0.1)
renderer.add(stream_actor4)
# window.show(renderer, size=(600, 600), reset_camera=False)
window.record(renderer, out_path='bundle4.png', size=(600, 600))
###############################################################################
# Show every streamline of a bundle with a different color
# ========================================================
#
# Let's make a colormap where every streamline of the bundle is colored by its
# length.
renderer.clear()
from dipy.tracking.streamline import length
renderer.clear()
from dipy.tracking.streamline import length
lengths = length(bundle_native)
hue = (0.5, 0.5) # blue only
saturation = (0.0, 1.0) # black to white
lut_cmap = actor.colormap_lookup_table(
scale_range=(lengths.min(), lengths.max()),
hue_range=hue,
saturation_range=saturation)
stream_actor5 = actor.line(bundle_native, lengths, linewidth=0.1,
lookup_colormap=lut_cmap)
renderer.add(stream_actor5)
bar3 = actor.scalar_bar(lut_cmap)
renderer.add(bar3)
# window.show(renderer, size=(600, 600), reset_camera=False)
window.record(renderer, out_path='bundle5.png', size=(600, 600))
###############################################################################
# Show every point of every streamline with a different color
# ============================================================
#
# In this case in which we want to have a color per point and per streamline,
# we can create a list of the colors to correspond to the list of streamlines
##############################################################################
# Show every point with a value from a volume with your colormap
# ==============================================================
#
# Here we will need to input the ``fa`` map in ``streamtube``
renderer.clear()
hue = (0.0, 0.0) # red only
saturation = (0.0, 1.0) # white to red
lut_cmap = actor.colormap_lookup_table(hue_range=hue,
saturation_range=saturation)
stream_actor3 = actor.line(bundle_native, fa, linewidth=0.1,
lookup_colormap=lut_cmap)
bar2 = actor.scalar_bar(lut_cmap)
renderer.add(stream_actor3)
renderer.add(bar2)
# window.show(renderer, size=(600, 600), reset_camera=False)
window.record(renderer, out_path='bundle3.png', size=(600, 600))
###############################################################################
# Show every bundle with a specific color
# ========================================
#
# You can have a bundle with a specific color. In this example, we are chosing
# orange.
seed_masks = mask_from_bundle_ROI(bundles, mapping)
print("Getting Tracks...")
if not op.exists('dti_streamlines.trk'):
streamlines = list(aft.track(dti_params['params'], seed_mask=seed_masks))
aus.write_trk('./dti_streamlines.trk', streamlines, affine=img.affine)
else:
tg = nib.streamlines.load('./dti_streamlines.trk').tractogram
streamlines = tg.apply_affine(np.linalg.inv(img.affine)).streamlines
streamlines = dts.Streamlines(dtu.move_streamlines(
[s for s in streamlines if s.shape[0] > 100],
np.linalg.inv(img.affine)))
scene = window.Scene()
scene.add(actor.line(streamlines, line_colors(streamlines)))
scene.add(actor.contour_from_roi(seed_masks, img.affine, [0, 1, 1], 0.5))
window.show(scene)
###############################################################################
# If we want to see the objects in native space we need to make sure that all
# objects which are currently in world coordinates are transformed back to
# native space using the inverse of the affine.
if not world_coords:
from dipy.tracking.streamline import transform_streamlines
streamlines = transform_streamlines(streamlines, np.linalg.inv(affine))
###############################################################################
# Now we create, a ``Scene`` object and add the streamlines using the
# ``line`` function and an image plane using the ``slice`` function.
scene = window.Scene()
stream_actor = actor.line(streamlines)
if not world_coords:
image_actor_z = actor.slicer(data, affine=np.eye(4))
else:
image_actor_z = actor.slicer(data, affine)
###############################################################################
# We can also change also the opacity of the slicer.
slicer_opacity = 0.6
image_actor_z.opacity(slicer_opacity)
###############################################################################
# We can add additonal slicers by copying the original and adjusting the
# ``display_extent``.
parser.error('No cluster survived the cluster_size threshold.')
logging.info('{} clusters to be classified.'.format(
len(sft_accepted_on_size)))
# The clusters are sorted by size for simplicity/efficiency
tuple_accepted = zip(*sorted(zip(sft_accepted_on_size,
filename_accepted_on_size),
key=lambda x: len(x[0]), reverse=True))
sft_accepted_on_size, filename_accepted_on_size = tuple_accepted
# Initialize the actors, scene, window, observer
concat_streamlines_actor = actor.line(concat_streamlines,
colors=(1, 1, 1),
opacity=args.background_opacity,
linewidth=background_linewidth)
curr_streamlines_actor = actor.line(sft_accepted_on_size[0].streamlines,
opacity=0.8,
linewidth=clusters_linewidth)
scene = window.Scene()
interactor_style = interactor.CustomInteractorStyle()
show_manager = window.ShowManager(scene, size=(800, 800),
reset_camera=False,
interactor_style=interactor_style)
scene.add(concat_streamlines_actor)
scene.add(curr_streamlines_actor)
interactor_style.AddObserver('KeyPressEvent', keypress_callback)
# Lauch rendering and selection procedure
choices, accepted_streamlines, rejected_streamlines = [], [], []
show_curr_actor = True
show_manager.start()