def genren_AGG(sls, sls2=None, niidata=None, roi1=None, roi2=None, roi3=None, aff=np.eye(4), putpath='test.png', showme=False, showaxes=False): renderer = window.Renderer() renderer.set_camera(position=(-606.93, -153.23, 28.70), focal_point=(2.78, 11.06, 15.66), view_up=(0, 0, 1)) stream_actor = actor.line(sls) renderer.add(stream_actor) if sls2 is not None: stream_actor2 = actor.line(sls2, colors=(1, 1, 1)) renderer.add(stream_actor2) if roi1 is not None: contour_actor1 = actor.contour_from_roi(roi1, affine=aff, color=(1., 1., 0.), opacity=0.5) renderer.add(contour_actor1) if roi2 is not None: contour_actor2 = actor.contour_from_roi(roi2, affine=aff, color=(1., 0., 0.), opacity=0.5) renderer.add(contour_actor2) if roi3 is not None: contour_actor3 = actor.contour_from_roi(roi3, affine=aff, color=(0., 0., 1.), opacity=0.5) renderer.add(contour_actor3) if niidata is not None: slice_actor = actor.slicer(niidata, affine=aff) renderer.add(slice_actor) if showaxes: axes = actor.axes() renderer.add(axes) if showme: window.show(renderer, size=(500, 500), reset_camera=False) window.record(renderer, out_path=putpath, size=(500, 500)) # renderer.camera_info() del renderer return putpath
def window_show_test(bundles, mask_roi, anat, interactive=True, outpath=None): """ :param bundles: :param mask_roi: :param anat: :param interactive: :param outpath: :return: """ candidate_streamlines_actor = actor.streamtube( bundles, cmap.line_colors(candidate_sl)) ROI_actor = actor.contour_from_roi(mask_roi, color=(1., 1., 0.), opacity=0.5) ren = window.Renderer() if anat: vol_actor = actor.slicer(anat) vol_actor.display(x=40) vol_actor2 = vol_actor.copy() vol_actor2.display(z=35) # Add display objects to canvas ren.add(candidate_streamlines_actor) ren.add(ROI_actor) ren.add(vol_actor) ren.add(vol_actor2) if outpath is not None: window.record(ren, n_frames=1, out_path=outpath, size=(800, 800)) if interactive: window.show(ren)
def visualize_roi(roi, affine_or_mapping=None, static_img=None, roi_affine=None, static_affine=None, reg_template=None, scene=None, color=np.array([1, 0, 0]), opacity=1.0, inline=False, interact=False): """ Render a region of interest into a VTK viz as a volume """ if not isinstance(roi, np.ndarray): if isinstance(roi, str): roi = nib.load(roi).get_fdata() else: roi = roi.get_fdata() if affine_or_mapping is not None: if isinstance(affine_or_mapping, np.ndarray): # This is an affine: if (static_img is None or roi_affine is None or static_affine is None): raise ValueError( "If using an affine to transform an ROI, " "need to also specify all of the following", "inputs: `static_img`, `roi_affine`, ", "`static_affine`") roi = reg.resample(roi, static_img, roi_affine, static_affine) else: # Assume it is a mapping: if (isinstance(affine_or_mapping, str) or isinstance(affine_or_mapping, nib.Nifti1Image)): if reg_template is None or static_img is None: raise ValueError( "If using a mapping to transform an ROI, need to ", "also specify all of the following inputs: ", "`reg_template`, `static_img`") affine_or_mapping = reg.read_mapping(affine_or_mapping, static_img, reg_template) roi = auv.patch_up_roi( affine_or_mapping.transform_inverse( roi, interpolation='nearest')).astype(bool) if scene is None: scene = window.Scene() roi_actor = actor.contour_from_roi(roi, color=color, opacity=opacity) scene.add(roi_actor) if inline: tdir = tempfile.gettempdir() fname = op.join(tdir, "fig.png") window.snapshot(scene, fname=fname) display.display_png(display.Image(fname)) return _inline_interact(scene, inline, interact)
def create_roi_actor(roi_list, affine, opacity=0.8): roi_actor_list = [] for i in xrange(len(roi_list)): random = np.random.RandomState(i) color = random.uniform(0., 1., size=3) print color i_actor = actor.contour_from_roi(roi_list[i], affine=affine, color=color, opacity=opacity) roi_actor_list.append(i_actor) return roi_actor_list
def left_button_clicked(i_ren, obj, file_select_text): """ A callback to handle left click for this UI element. Parameters ---------- i_ren: :class:`CustomInteractorStyle` obj: :class:`vtkActor` The picked actor file_select_text: :class:`FileSelectMenuText2D` """ if file_select_text.file_type == "directory": file_select_text.file_select.select_file(file_name="") file_select_text.file_select.window_offset = 0 file_select_text.file_select.current_directory = os.path.abspath( os.path.join(file_select_text.file_select.current_directory, file_select_text.text_actor.message)) file_select_text.file_select.window = 0 file_select_text.file_select.fill_text_actors() print "----------------------" else: file_select_text.file_select.select_file( file_name=file_select_text.file_name) file_select_text.file_select.fill_text_actors() file_select_text.mark_selected() print "+++++++++++++++++++++++" data_path = os.path.join( file_select_text.file_select.current_directory, file_select_text.file_name) suffix = os.path.split(data_path)[-1].split('.')[-1] print if suffix == 'tck': fibs = nib.streamlines.tck.TckFile.load(data_path) ac = actor.line(fibs.streamlines) ren.add(ac) if suffix == 'gz': img = nib.load(data_path) im = actor.contour_from_roi(img.get_data(), affine=img.affine) ren.add(im) i_ren.force_render() i_ren.event.abort() # Stop propagating the event.
""" We will create a streamline actor from the streamlines. """ streamlines_actor = actor.line(streamlines, cmap.line_colors(streamlines)) """ Next, we create a surface actor from the corpus callosum seed ROI. We provide the ROI data, the affine, the color in [R,G,B], and the opacity as a decimal between zero and one. Here, we set the color as blue/green with 50% opacity. """ surface_opacity = 0.5 surface_color = [0, 1, 1] seedroi_actor = actor.contour_from_roi(seed_mask, affine, surface_color, surface_opacity) """ Next, we initialize a ''Renderer'' object and add both actors to the rendering. """ ren = window.ren() ren.add(streamlines_actor) ren.add(seedroi_actor) """ If you uncomment the following line, the rendering will pop up in an interactive window. """ interactive = False if interactive:
""" We can use some of DIPY_'s visualization tools to display the ROI we targeted above and all the streamlines that pass though that ROI. The ROI is the yellow region near the center of the axial image. """ from dipy.viz import window, actor, colormap as cmap # Enables/disables interactive visualization interactive = False # Make display objects color = cmap.line_colors(cc_streamlines) cc_streamlines_actor = actor.line(cc_streamlines, cmap.line_colors(cc_streamlines)) cc_ROI_actor = actor.contour_from_roi(cc_slice, color=(1., 1., 0.), opacity=0.5) vol_actor = actor.slicer(t1_data) vol_actor.display(x=40) vol_actor2 = vol_actor.copy() vol_actor2.display(z=35) # Add display objects to canvas r = window.Renderer() r.add(vol_actor) r.add(vol_actor2) r.add(cc_streamlines_actor) r.add(cc_ROI_actor) # Save figures
# Make a corpus callosum seed mask for tracking seed_mask = labels == 2 seeds = utils.seeds_from_mask(seed_mask, density=[1, 1, 1], affine=affine) # Make a streamline bundle model of the corpus callosum ROI connectivity streamlines = LocalTracking(csa_peaks, classifier, seeds, affine, step_size=2) streamlines = Streamlines(streamlines) # Visualize the streamlines and the Path Length Map base ROI # (in this case also the seed ROI) streamlines_actor = actor.line(streamlines, cmap.line_colors(streamlines)) surface_opacity = 0.5 surface_color = [0, 1, 1] seedroi_actor = actor.contour_from_roi(seed_mask, affine, surface_color, surface_opacity) ren = window.Renderer() ren.add(streamlines_actor) ren.add(seedroi_actor) """ If you set interactive to True (below), the rendering will pop up in an interactive window. """ interactive = False if interactive: window.show(ren) window.record(ren, n_frames=1, out_path='plm_roi_sls.png',
def visualize_roi(roi, affine_or_mapping=None, static_img=None, roi_affine=None, static_affine=None, reg_template=None, name='ROI', figure=None, color=np.array([1, 0, 0]), flip_axes=None, opacity=1.0, inline=False, interact=False): """ Render a region of interest into a VTK viz as a volume Parameters ---------- roi : str or Nifti1Image The ROI information affine_or_mapping : ndarray, Nifti1Image, or str, optional An affine transformation or mapping to apply to the ROIs before visualization. Default: no transform. static_img: str or Nifti1Image, optional Template to resample roi to. Default: None roi_affine: ndarray, optional Default: None static_affine: ndarray, optional Default: None reg_template: str or Nifti1Image, optional Template to use for registration. Default: None name: str, optional Name of ROI for the legend. Default: 'ROI' color : ndarray, optional RGB color for ROI. Default: np.array([1, 0, 0]) flip_axes : None This parameter is to conform fury and plotly APIs. opacity : float, optional Opacity of ROI. Default: 1.0 figure : fury Scene object, optional If provided, the visualization will be added to this Scene. Default: Initialize a new Scene. interact : bool Whether to provide an interactive VTK window for interaction. Default: False inline : bool Whether to embed the visualization inline in a notebook. Only works in the notebook context. Default: False. Returns ------- Fury Scene object """ roi = vut.prepare_roi(roi, affine_or_mapping, static_img, roi_affine, static_affine, reg_template) if figure is None: figure = window.Scene() roi_actor = actor.contour_from_roi(roi, color=color, opacity=opacity) figure.add(roi_actor) return _inline_interact(figure, inline, interact)
""" We can use some of dipy_'s visualization tools to display the ROI we targeted above and all the streamlines that pass though that ROI. The ROI is the yellow region near the center of the axial image. """ from dipy.viz import window, actor from dipy.viz.colormap import line_colors # Enables/disables interactive visualization interactive = False # Make display objects color = line_colors(cc_streamlines) cc_streamlines_actor = actor.line(cc_streamlines, line_colors(cc_streamlines)) cc_ROI_actor = actor.contour_from_roi(cc_slice, color=(1., 1., 0.), opacity=0.5) vol_actor = actor.slicer(t1_data) vol_actor.display(x=40) vol_actor2 = vol_actor.copy() vol_actor2.display(z=35) # Add display objects to canvas r = window.Renderer() r.add(vol_actor) r.add(vol_actor2) r.add(cc_streamlines_actor) r.add(cc_ROI_actor) # Save figures
def build_show(self, scene): title = 'Horizon ' + horizon_version self.show_m = window.ShowManager( scene, title=title, size=(1200, 900), order_transparent=self.order_transparent, reset_camera=False) self.show_m.initialize() if self.cluster and self.tractograms: lengths = np.array([self.cla[c]['length'] for c in self.cla]) szs = [self.cla[c]['size'] for c in self.cla] sizes = np.array(szs) # global self.panel2, slider_length, slider_size self.panel2 = ui.Panel2D(size=(320, 200), position=(870, 520), color=(1, 1, 1), opacity=0.1, align="right") cluster_panel_label = build_label(text="Cluster panel", bold=True) slider_label_threshold = build_label(text="Threshold") print("Cluster threshold", self.cluster_thr) slider_threshold = ui.LineSlider2D(min_value=5, max_value=25, initial_value=self.cluster_thr, text_template="{value:.0f}", length=140, shape='square') _color_slider(slider_threshold) slider_label_length = build_label(text="Length") slider_length = ui.LineSlider2D( min_value=lengths.min(), max_value=np.percentile(lengths, 98), initial_value=np.percentile(lengths, 25), text_template="{value:.0f}", length=140) _color_slider(slider_length) slider_label_size = build_label(text="Size") slider_size = ui.LineSlider2D(min_value=sizes.min(), max_value=np.percentile(sizes, 98), initial_value=np.percentile( sizes, 50), text_template="{value:.0f}", length=140) _color_slider(slider_size) # global self.length_min, size_min self.size_min = sizes.min() self.length_min = lengths.min() def change_threshold(istyle, obj, slider): sv = np.round(slider.value, 0) self.remove_cluster_actors(scene) self.add_cluster_actors(scene, self.tractograms, threshold=sv) # TODO need to double check if this section is still needed lengths = np.array([self.cla[c]['length'] for c in self.cla]) szs = [self.cla[c]['size'] for c in self.cla] sizes = np.array(szs) slider_length.min_value = lengths.min() slider_length.max_value = lengths.max() slider_length.value = lengths.min() slider_length.update() slider_size.min_value = sizes.min() slider_size.max_value = sizes.max() slider_size.value = sizes.min() slider_size.update() self.length_min = min(lengths) self.size_min = min(sizes) self.show_m.render() slider_threshold.handle_events(slider_threshold.handle.actor) slider_threshold.on_left_mouse_button_released = change_threshold def hide_clusters_length(slider): self.length_min = np.round(slider.value) for k in self.cla: if (self.cla[k]['length'] < self.length_min or self.cla[k]['size'] < self.size_min): self.cla[k]['centroid_actor'].SetVisibility(0) if k.GetVisibility() == 1: k.SetVisibility(0) else: self.cla[k]['centroid_actor'].SetVisibility(1) self.show_m.render() def hide_clusters_size(slider): self.size_min = np.round(slider.value) for k in self.cla: if (self.cla[k]['length'] < self.length_min or self.cla[k]['size'] < self.size_min): self.cla[k]['centroid_actor'].SetVisibility(0) if k.GetVisibility() == 1: k.SetVisibility(0) else: self.cla[k]['centroid_actor'].SetVisibility(1) self.show_m.render() slider_length.on_change = hide_clusters_length # Clustering panel self.panel2.add_element(slider_label_threshold, coords=(0.1, 0.15)) self.panel2.add_element(slider_threshold, coords=(0.42, 0.15)) self.panel2.add_element(slider_label_length, coords=(0.1, 0.4)) self.panel2.add_element(slider_length, coords=(0.42, 0.4)) slider_size.on_change = hide_clusters_size self.panel2.add_element(slider_label_size, coords=(0.1, 0.65)) self.panel2.add_element(slider_size, coords=(0.42, 0.65)) self.panel2.add_element(cluster_panel_label, coords=(0.05, 0.85)) scene.add(self.panel2) # Information panel text_block = build_label(HELP_MESSAGE, 18) text_block.message = HELP_MESSAGE self.help_panel = ui.Panel2D(size=(320, 200), position=(10, 10), color=(0.8, 0.8, 1), opacity=0.2, align="left") self.help_panel.add_element(text_block, coords=(0.05, 0.1)) scene.add(self.help_panel) if len(self.images) > 0: # Only first non-binary image loading supported for now first_img = True first_roi = True if self.roi_images: roi_color = self.roi_colors for img in self.images: img_data, img_affine = img dim = np.unique(img_data).shape[0] if dim == 2: if 'rois' in self.random_colors: roi_color = next(self.color_gen) roi_actor = actor.contour_from_roi( img_data, affine=img_affine, color=roi_color, opacity=self.mem.roi_opacity) self.mem.slicer_roi_actor.append(roi_actor) scene.add(roi_actor) if first_roi: self.panel3 = ui.Panel2D(size=(320, 100), position=(870, 730), color=(1, 1, 1), opacity=0.1, align="right") rois_panel_label = build_label(text="ROIs panel", bold=True) slider_label_opacity = build_label(text="Opacity") slider_opacity = ui.LineSlider2D( min_value=0.0, max_value=1.0, initial_value=self.mem.roi_opacity, length=140, text_template="{ratio:.0%}") _color_slider(slider_opacity) def change_opacity(slider): roi_opacity = slider.value self.mem.roi_opacity = roi_opacity for contour in self.mem.slicer_roi_actor: contour.GetProperty().SetOpacity( roi_opacity) slider_opacity.on_change = change_opacity self.panel3.add_element(slider_label_opacity, coords=(0.1, 0.3)) self.panel3.add_element(slider_opacity, coords=(0.42, 0.3)) self.panel3.add_element(rois_panel_label, coords=(0.05, 0.7)) scene.add(self.panel3) first_roi = False else: if first_img: data, affine = img self.vox2ras = affine if len(self.pams) > 0: pam = self.pams[0] else: pam = None self.panel = slicer_panel(scene, self.show_m.iren, data, affine, self.world_coords, pam=pam, mem=self.mem) first_img = False else: data, affine = self.images[0] self.vox2ras = affine if len(self.pams) > 0: pam = self.pams[0] else: pam = None self.panel = slicer_panel(scene, self.show_m.iren, data, affine, self.world_coords, pam=pam, mem=self.mem) else: data = None affine = None pam = None self.win_size = scene.GetSize() def win_callback(obj, event): if self.win_size != obj.GetSize(): size_old = self.win_size self.win_size = obj.GetSize() size_change = [self.win_size[0] - size_old[0], 0] if data is not None: self.panel.re_align(size_change) if self.cluster: self.panel2.re_align(size_change) self.help_panel.re_align(size_change) if self.roi_images: self.panel3.re_align(size_change) self.show_m.initialize() self.hide_centroids = True self.select_all = False def hide(): if self.hide_centroids: for ca in self.cea: if (self.cea[ca]['length'] >= self.length_min or self.cea[ca]['size'] >= self.size_min): if self.cea[ca]['selected'] == 0: ca.VisibilityOff() else: for ca in self.cea: if (self.cea[ca]['length'] >= self.length_min and self.cea[ca]['size'] >= self.size_min): if self.cea[ca]['selected'] == 0: ca.VisibilityOn() self.hide_centroids = not self.hide_centroids self.show_m.render() def invert(): for ca in self.cea: if (self.cea[ca]['length'] >= self.length_min and self.cea[ca]['size'] >= self.size_min): self.cea[ca]['selected'] = \ not self.cea[ca]['selected'] cas = self.cea[ca]['cluster_actor'] self.cla[cas]['selected'] = \ self.cea[ca]['selected'] self.show_m.render() def save(): saving_streamlines = Streamlines() for bundle in self.cla.keys(): if bundle.GetVisibility(): t = self.cla[bundle]['tractogram'] c = self.cla[bundle]['cluster'] indices = self.tractogram_clusters[t][c] saving_streamlines.extend(Streamlines(indices)) print('Saving result in tmp.trk') # Using the header of the first of the tractograms sft_new = StatefulTractogram(saving_streamlines, self.tractograms[0], Space.RASMM) save_tractogram(sft_new, 'tmp.trk', bbox_valid_check=False) print('Saved!') def new_window(): active_streamlines = Streamlines() for bundle in self.cla.keys(): if bundle.GetVisibility(): t = self.cla[bundle]['tractogram'] c = self.cla[bundle]['cluster'] indices = self.tractogram_clusters[t][c] active_streamlines.extend(Streamlines(indices)) # Using the header of the first of the tractograms active_sft = StatefulTractogram(active_streamlines, self.tractograms[0], Space.RASMM) hz2 = Horizon([active_sft], self.images, cluster=True, cluster_thr=self.cluster_thr / 2., random_colors=self.random_colors, length_lt=np.inf, length_gt=0, clusters_lt=np.inf, clusters_gt=0, world_coords=True, interactive=True) ren2 = hz2.build_scene() hz2.build_show(ren2) def show_all(): if self.select_all is False: for ca in self.cea: if (self.cea[ca]['length'] >= self.length_min and self.cea[ca]['size'] >= self.size_min): self.cea[ca]['selected'] = 1 cas = self.cea[ca]['cluster_actor'] self.cla[cas]['selected'] = \ self.cea[ca]['selected'] self.show_m.render() self.select_all = True else: for ca in self.cea: if (self.cea[ca]['length'] >= self.length_min and self.cea[ca]['size'] >= self.size_min): self.cea[ca]['selected'] = 0 cas = self.cea[ca]['cluster_actor'] self.cla[cas]['selected'] = \ self.cea[ca]['selected'] self.show_m.render() self.select_all = False def expand(): for c in self.cea: if self.cea[c]['selected']: if not self.cea[c]['expanded']: len_ = self.cea[c]['length'] sz_ = self.cea[c]['size'] if (len_ >= self.length_min and sz_ >= self.size_min): self.cea[c]['cluster_actor']. \ VisibilityOn() c.VisibilityOff() self.cea[c]['expanded'] = 1 self.show_m.render() def reset(): for c in self.cea: if (self.cea[c]['length'] >= self.length_min and self.cea[c]['size'] >= self.size_min): self.cea[c]['cluster_actor'].VisibilityOff() c.VisibilityOn() self.cea[c]['expanded'] = 0 self.show_m.render() def key_press(obj, event): key = obj.GetKeySym() if self.cluster: # hide on/off unselected centroids if key == 'h' or key == 'H': hide() # invert selection if key == 'i' or key == 'I': invert() # retract help panel if key == 'o' or key == 'O': self.help_panel._set_position((-300, 0)) self.show_m.render() # save current result if key == 's' or key == 'S': save() if key == 'y' or key == 'Y': new_window() if key == 'a' or key == 'A': show_all() if key == 'e' or key == 'E': expand() if key == 'r' or key == 'R': reset() options = [ r'un\hide centroids', 'invert selection', r'un\select all', 'expand clusters', 'collapse clusters', 'save streamlines', 'recluster' ] listbox = ui.ListBox2D(values=options, position=(10, 300), size=(200, 270), multiselection=False, font_size=18) def display_element(): action = listbox.selected[0] if action == r'un\hide centroids': hide() if action == 'invert selection': invert() if action == r'un\select all': show_all() if action == 'expand clusters': expand() if action == 'collapse clusters': reset() if action == 'save streamlines': save() if action == 'recluster': new_window() listbox.on_change = display_element listbox.panel.opacity = 0.2 listbox.set_visibility(0) self.show_m.scene.add(listbox) def left_click_centroid_callback(obj, event): self.cea[obj]['selected'] = not self.cea[obj]['selected'] self.cla[self.cea[obj]['cluster_actor']]['selected'] = \ self.cea[obj]['selected'] self.show_m.render() def right_click_centroid_callback(obj, event): for lactor in listbox._get_actors(): lactor.SetVisibility(not lactor.GetVisibility()) listbox.scroll_bar.set_visibility(False) self.show_m.render() def left_click_cluster_callback(obj, event): if self.cla[obj]['selected']: self.cla[obj]['centroid_actor'].VisibilityOn() ca = self.cla[obj]['centroid_actor'] self.cea[ca]['selected'] = 0 obj.VisibilityOff() self.cea[ca]['expanded'] = 0 self.show_m.render() def right_click_cluster_callback(obj, event): print('Cluster Area Selected') self.show_m.render() for cl in self.cla: cl.AddObserver('LeftButtonPressEvent', left_click_cluster_callback, 1.0) cl.AddObserver('RightButtonPressEvent', right_click_cluster_callback, 1.0) self.cla[cl]['centroid_actor'].AddObserver( 'LeftButtonPressEvent', left_click_centroid_callback, 1.0) self.cla[cl]['centroid_actor'].AddObserver( 'RightButtonPressEvent', right_click_centroid_callback, 1.0) self.mem.window_timer_cnt = 0 def timer_callback(obj, event): self.mem.window_timer_cnt += 1 # TODO possibly add automatic rotation option # self.show_m.scene.azimuth(0.01 * self.mem.window_timer_cnt) # self.show_m.render() scene.reset_camera() scene.zoom(1.5) scene.reset_clipping_range() if self.interactive: self.show_m.add_window_callback(win_callback) self.show_m.add_timer_callback(True, 200, timer_callback) self.show_m.iren.AddObserver('KeyPressEvent', key_press) if self.return_showm: return self.show_m if self.recorded_events is None: self.show_m.render() self.show_m.start() else: # set to True if event recorded file needs updating recording = False recording_filename = self.recorded_events if recording: self.show_m.record_events_to_file(recording_filename) else: self.show_m.play_events_from_file(recording_filename) else: window.record(scene, out_path=self.out_png, size=(1200, 900), reset_camera=False)
def test_contour_from_roi(): # Render volume renderer = window.renderer() data = np.zeros((50, 50, 50)) data[20:30, 25, 25] = 1. data[25, 20:30, 25] = 1. affine = np.eye(4) surface = actor.contour_from_roi(data, affine, color=np.array([1, 0, 1]), opacity=.5) renderer.add(surface) renderer.reset_camera() renderer.reset_clipping_range() # window.show(renderer) # Test binarization renderer2 = window.renderer() data2 = np.zeros((50, 50, 50)) data2[20:30, 25, 25] = 1. data2[35:40, 25, 25] = 1. affine = np.eye(4) surface2 = actor.contour_from_roi(data2, affine, color=np.array([0, 1, 1]), opacity=.5) renderer2.add(surface2) renderer2.reset_camera() renderer2.reset_clipping_range() # window.show(renderer2) arr = window.snapshot(renderer, 'test_surface.png', offscreen=True) arr2 = window.snapshot(renderer2, 'test_surface2.png', offscreen=True) report = window.analyze_snapshot(arr, find_objects=True) report2 = window.analyze_snapshot(arr2, find_objects=True) npt.assert_equal(report.objects, 1) npt.assert_equal(report2.objects, 2) # test on real streamlines using tracking example from dipy.data import read_stanford_labels from dipy.reconst.shm import CsaOdfModel from dipy.data import default_sphere from dipy.direction import peaks_from_model from dipy.tracking.local import ThresholdTissueClassifier from dipy.tracking import utils from dipy.tracking.local import LocalTracking from dipy.viz.colormap import line_colors hardi_img, gtab, labels_img = read_stanford_labels() data = hardi_img.get_data() labels = labels_img.get_data() affine = hardi_img.get_affine() white_matter = (labels == 1) | (labels == 2) csa_model = CsaOdfModel(gtab, sh_order=6) csa_peaks = peaks_from_model(csa_model, data, default_sphere, relative_peak_threshold=.8, min_separation_angle=45, mask=white_matter) classifier = ThresholdTissueClassifier(csa_peaks.gfa, .25) seed_mask = labels == 2 seeds = utils.seeds_from_mask(seed_mask, density=[1, 1, 1], affine=affine) # Initialization of LocalTracking. # The computation happens in the next step. streamlines = LocalTracking(csa_peaks, classifier, seeds, affine, step_size=2) # Compute streamlines and store as a list. streamlines = list(streamlines) # Prepare the display objects. streamlines_actor = actor.line(streamlines, line_colors(streamlines)) seedroi_actor = actor.contour_from_roi(seed_mask, affine, [0, 1, 1], 0.5) # Create the 3d display. r = window.ren() r2 = window.ren() r.add(streamlines_actor) arr3 = window.snapshot(r, 'test_surface3.png', offscreen=True) report3 = window.analyze_snapshot(arr3, find_objects=True) r2.add(streamlines_actor) r2.add(seedroi_actor) arr4 = window.snapshot(r2, 'test_surface4.png', offscreen=True) report4 = window.analyze_snapshot(arr4, find_objects=True) # assert that the seed ROI rendering is not far # away from the streamlines (affine error) npt.assert_equal(report3.objects, report4.objects)
native_streamlines = "native_streamline_%s_bin-%d.vtk" % (subs_strings[s], i) unfold_streamlines = "unfold_streamlines_%s_bin-%d.vtk" % (subs_strings[s], i) from_unfold_streamlines = "from_unfold_streamlines_%s_bin-%d.vtk" % ( subs_strings[s], i) roi_nii = nib.load('data/oldUnfold/U.nii.gz') roi = roi_nii.get_fdata() nlines = load_vtk_streamlines('data/oldUnfold/' + native_streamlines) ulines = load_vtk_streamlines('data/oldUnfold/' + from_unfold_streamlines) #unfoldlines=load_vtk_streamlines('data/oldUnfold/Unfolded/'+unfold_streamlines) surface_opacity = 0.05 surface_color = [0, 1, 1] roi_actor = actor.contour_from_roi(roi, roi_nii.affine, surface_color, surface_opacity) def plot_streamlines(streamlines, roi_actor): if has_fury: # Prepare the display objects. color = colormap.line_colors(streamlines) streamlines_actor = actor.line(streamlines, colormap.line_colors(streamlines)) # Create the 3D display. scene = window.Scene() scene.add(roi_actor) scene.add(streamlines_actor)
def test_contour_from_roi(): # Render volume renderer = window.renderer() data = np.zeros((50, 50, 50)) data[20:30, 25, 25] = 1. data[25, 20:30, 25] = 1. affine = np.eye(4) surface = actor.contour_from_roi(data, affine, color=np.array([1, 0, 1]), opacity=.5) renderer.add(surface) renderer.reset_camera() renderer.reset_clipping_range() # window.show(renderer) # Test binarization renderer2 = window.renderer() data2 = np.zeros((50, 50, 50)) data2[20:30, 25, 25] = 1. data2[35:40, 25, 25] = 1. affine = np.eye(4) surface2 = actor.contour_from_roi(data2, affine, color=np.array([0, 1, 1]), opacity=.5) renderer2.add(surface2) renderer2.reset_camera() renderer2.reset_clipping_range() # window.show(renderer2) arr = window.snapshot(renderer, 'test_surface.png', offscreen=True) arr2 = window.snapshot(renderer2, 'test_surface2.png', offscreen=True) report = window.analyze_snapshot(arr, find_objects=True) report2 = window.analyze_snapshot(arr2, find_objects=True) npt.assert_equal(report.objects, 1) npt.assert_equal(report2.objects, 2) # test on real streamlines using tracking example from dipy.data import read_stanford_labels from dipy.reconst.shm import CsaOdfModel from dipy.data import default_sphere from dipy.direction import peaks_from_model from dipy.tracking.local import ThresholdTissueClassifier from dipy.tracking import utils from dipy.tracking.local import LocalTracking from dipy.viz.colormap import line_colors hardi_img, gtab, labels_img = read_stanford_labels() data = hardi_img.get_data() labels = labels_img.get_data() affine = hardi_img.get_affine() white_matter = (labels == 1) | (labels == 2) csa_model = CsaOdfModel(gtab, sh_order=6) csa_peaks = peaks_from_model(csa_model, data, default_sphere, relative_peak_threshold=.8, min_separation_angle=45, mask=white_matter) classifier = ThresholdTissueClassifier(csa_peaks.gfa, .25) seed_mask = labels == 2 seeds = utils.seeds_from_mask(seed_mask, density=[1, 1, 1], affine=affine) # Initialization of LocalTracking. # The computation happens in the next step. streamlines = LocalTracking(csa_peaks, classifier, seeds, affine, step_size=2) # Compute streamlines and store as a list. streamlines = list(streamlines) # Prepare the display objects. streamlines_actor = actor.line(streamlines, line_colors(streamlines)) seedroi_actor = actor.contour_from_roi(seed_mask, affine, [0, 1, 1], 0.5) # Create the 3d display. r = window.ren() r2 = window.ren() r.add(streamlines_actor) arr3 = window.snapshot(r, 'test_surface3.png', offscreen=True) report3 = window.analyze_snapshot(arr3, find_objects=True) r2.add(streamlines_actor) r2.add(seedroi_actor) arr4 = window.snapshot(r2, 'test_surface4.png', offscreen=True) report4 = window.analyze_snapshot(arr4, find_objects=True) # assert that the seed ROI rendering is not far # away from the streamlines (affine error) npt.assert_equal(report3.objects, report4.objects)
fib = nib.streamlines.tck.TckFile.load(fib_file) streamlines = fib.streamlines from pyfat.algorithm.fiber_selection import select_by_vol_roi print len(streamlines) # # create a rendering renderer # ren = window.Renderer() # stream_actor = actor.line(streamlines) roi = nib.load(roi_file) roi_data = roi.get_data() roi1 = nib.load(roi_file1) roi1_data = roi1.get_data() ROI_actor = actor.contour_from_roi(roi_data, affine=roi.affine, color=(1., 1., 0.), opacity=0.8) ROI_actor1 = actor.contour_from_roi(roi1_data, affine=roi1.affine, color=(1., 1., 0.), opacity=0.8) #################################################### roi_vis = nib.load(roi_vis) roi_vis_data = roi_vis.get_data() label = list(set(roi_vis_data[roi_vis_data.nonzero()])) roi_vis_data0 = np.zeros(roi_vis_data.shape) roi_vis_data0[roi_vis_data == label[0]] = 1.0 roi_vis_data1 = np.zeros(roi_vis_data.shape) roi_vis_data1[roi_vis_data == label[1]] = 1.0 roi_vis_data2 = np.zeros(roi_vis_data.shape)