def on_selected_index(change): if change.new == 1 and isinstance(change.owner.children[1], widgets.HTML): slider = widgets.IntSlider(value=0, min=0, max=lfp.data.shape[1] - 1, description='Channel', orientation='horizontal') def create_spectrogram(channel=0): f, t, Zxx = stft(lfp.data[:, channel], lfp.rate, nperseg=128) spect = np.log(np.abs(Zxx)) image = itk.GetImageFromArray(spect) image.SetSpacing([(f[1] - f[0]), (t[1] - t[0]) * 1e-1]) direction = image.GetDirection() vnl_matrix = direction.GetVnlMatrix() vnl_matrix.set(0, 0, 0.0) vnl_matrix.set(0, 1, -1.0) vnl_matrix.set(1, 0, 1.0) vnl_matrix.set(1, 1, 0.0) return image spectrogram = create_spectrogram(0) viewer = itkwidgets.view(spectrogram, ui_collapsed=True, select_roi=True, annotations=False) spect_vbox = widgets.VBox([slider, viewer]) children[1] = spect_vbox change.owner.children = children channel_to_spectrogram = {0: spectrogram} def on_change_channel(change): channel = change.new if channel not in channel_to_spectrogram: channel_to_spectrogram[channel] = create_spectrogram(channel) viewer.image = channel_to_spectrogram[channel] slider.observe(on_change_channel, names='value')
def __init__(self): super().__init__() self.addInputPort("array") self.addInputPort("dataset") self.view = view() self.view.ui_collapsed = True self._bounds = None self.view.observe(self.camera_changed, ['camera'])
def gui(self, **kwargs ): if self._gui is None: self.init_data() bin_colors = self.get_bin_colors("gist_rainbow") # self.get_bin_colors("jet",True) ptcolors = [ [1.0, 1.0, 1.0, 1.0], ] + bin_colors + LabelsManager.instance().colors[::-1] ptsizes = [1]*(self._n_point_bins+1) + [8]*LabelsManager.instance().nLabels self._gui = view( point_sets = self.point_sets, point_set_sizes=ptsizes, point_set_colors=ptcolors, background=[0,0,0] ) self._gui.layout = { 'width': 'auto', 'flex': '1 1 auto' } return self._gui
def mesh(self, **kwargs): x = kwargs.get("x", self._obj.SCHISM_hgrid_node_x[:].values) y = kwargs.get("y", self._obj.SCHISM_hgrid_node_y[:].values) try: t = kwargs.get("t", self._obj.time.values) except: pass tri3 = kwargs.get("tes", self._obj.SCHISM_hgrid_face_nodes.values[:, :3].astype(int)) dim = kwargs.get("dim", "2D") R = kwargs.get("R", 1.0) if dim == "3D": px, py, pz = to_3d(x, y, R=R) else: px = x py = y pz = np.zeros(x.shape[0]) mlab.figure(1, size=(3840 / 2, 2160 / 2), bgcolor=(0, 0, 0), fgcolor=(1.0, 1.0, 1.0)) mlab.clf() bcolor = kwargs.get("bcolor", (0.0, 0.0, 0.0)) if dim == "3D": self.globe(R - 0.002, bcolor=bcolor) # 3D triangular mesh surface (like trisurf) grd = mlab.triangular_mesh(px, py, pz, tri3, representation="wireframe", opacity=1.0) # grd.scalar.name = 'depth' coast = kwargs.get("coastlines", None) if coast is not None: try: del kwargs["coastlines"] except: pass try: del kwargs["R"] except: pass src, lines = self.c3d(coast, R=R, **kwargs) mlab.pipeline.surface(src, color=(1, 0, 0), line_width=10, opacity=0.8) engine = mlab.get_engine() scene = engine.scenes[0] scene.scene.z_plus_view() v = view(actors=grd, rotate=False, ui_collapsed=True) v.geometries = [v.geometries[0]] # mlab.show() return v
def show_cad(mesh, emax=1, show_log=False): global mgeoCounter temp_file_name = "tmp_step_" + str(stepCounter) + ".step" val = mesh.val() val.exportStep(temp_file_name) time.sleep(1) stl_file = step2stl(temp_file_name, emax=emax) time.sleep(1) vol = pyvista.read(stl_file) v = view(geometries=[vol]) return v
def Viewer_3D(imgs): ''' :param imgs: array:[D, H, W] :return: the 3D player ''' itk_img = itk.image_view_from_array(imgs) viewer = view(itk_img, rotate=True, axes=True, vmin=0, vmax=255, gradient_opacity=0.9) return viewer
def show_volume(self, renderer: str = 'itkwidgets', **kwargs) -> None: """Show volume using `itkwidgets` or `ipyvolume`. Extra keyword arguments (`kwargs`) are passed to `itkwidgets.view` or `ipyvolume.quickvolshow`. """ if renderer in ('ipyvolume', 'ipv'): import ipyvolume as ipv return ipv.quickvolshow(self.image, **kwargs) elif renderer in ('itkwidgets', 'itk', 'itkw'): import itkwidgets as itkw return itkw.view(self.image) else: raise ValueError(f'No such renderer: {renderer!r}')
def figure_9(): """ Notes ----- You should run this code inside a Jupyter Notebook. """ # reading all images from the sample. pattern = 'unet/rec20160318_191511_232p3_2cm_cont__4097im_1500ms_ML17keV_6.h5/predict/*.png' images = io.ImageCollection(pattern) images = images.concatenate()[:, ::2, ::2] # slicing the outer part to show inside fibers. images = images[:, :1000, :] images = itk.GetImageFromArray(images) view(images, label_image_blend=0, gradient_opacity=0, shadow=False, interpolation=False) return None
def plot(self, stance, unit='rad', itkwidget=False): """ Plots the SerialLink object in a desired stance. :param stance: list of joint angles for SerialLink object. :param unit: unit of input angles. :return: null. """ assert type(stance) is np.matrix if unit == 'deg': stance = stance * (pi / 180) self.pipeline = VtkPipeline() self.pipeline.reader_list, self.pipeline.actor_list, self.pipeline.mapper_list = self.__setup_pipeline_objs( ) self.fkine(stance, apply_stance=True, actor_list=self.pipeline.actor_list) if itkwidget: from itkwidgets import view viewer = view(axes=False, ui_collapsed=True, actors=self.pipeline.actor_list, geometries=[], geometry_colors=[], geometry_opacities=[]) return viewer else: cube_axes = axesCubeFloor(self.pipeline.ren, self.param.get("cube_axes_x_bounds"), self.param.get("cube_axes_y_bounds"), self.param.get("cube_axes_z_bounds"), self.param.get("floor_position")) self.pipeline.add_actor(cube_axes) # for each in self.pipeline.actor_list: # each.SetScale(self.scale) self.pipeline.render()
def getNotebookBackend(actors2show, zoom, viewup): vp = settings.plotter_instance if isinstance(vp.shape, str) or sum(vp.shape) > 2: colors.printc("Multirendering is not supported in jupyter.", c=1) return #################################################################################### # https://github.com/InsightSoftwareConsortium/itkwidgets # /blob/master/itkwidgets/widget_viewer.py if 'itk' in settings.notebookBackend: from itkwidgets import view settings.notebook_plotter = view(actors=actors2show, cmap='jet', ui_collapsed=True, gradient_opacity=False) #################################################################################### elif settings.notebookBackend == 'k3d': try: import k3d # https://github.com/K3D-tools/K3D-jupyter except: print("Cannot find k3d, install with: pip install k3d") return actors2show2 = [] for ia in actors2show: if not ia: continue if isinstance(ia, vtk.vtkAssembly): #unpack assemblies acass = ia.unpack() actors2show2 += acass else: actors2show2.append(ia) # vbb, sizes, _, _ = addons.computeVisibleBounds() # kgrid = vbb[0], vbb[2], vbb[4], vbb[1], vbb[3], vbb[5] settings.notebook_plotter = k3d.plot(axes=[vp.xtitle, vp.ytitle, vp.ztitle], menu_visibility=True, # height=int(vp.size[1]/2), ) # settings.notebook_plotter.grid = kgrid settings.notebook_plotter.lighting = 1.2 # set k3d camera settings.notebook_plotter.camera_auto_fit = True if settings.plotter_instance and settings.plotter_instance.camera: k3dc = utils.vtkCameraToK3D(settings.plotter_instance.camera) if zoom: k3dc[0] /= zoom k3dc[1] /= zoom k3dc[2] /= zoom settings.notebook_plotter.camera = k3dc # else: # vsx, vsy, vsz = vbb[0]-vbb[1], vbb[2]-vbb[3], vbb[4]-vbb[5] # vss = numpy.linalg.norm([vsx, vsy, vsz]) # if zoom: # vss /= zoom # vfp = (vbb[0]+vbb[1])/2, (vbb[2]+vbb[3])/2, (vbb[4]+vbb[5])/2 # camera target # if viewup == 'z': # vup = (0,0,1) # camera up vector # vpos= vfp[0] + vss/1.9, vfp[1] + vss/1.9, vfp[2]+vss*0.01 # camera position # elif viewup == 'x': # vup = (1,0,0) # vpos= vfp[0]+vss*0.01, vfp[1] + vss/1.5, vfp[2] # camera position # else: # vup = (0,1,0) # vpos= vfp[0]+vss*0.01, vfp[1]+vss*0.01, vfp[2] + vss/1.5 # camera position # settings.notebook_plotter.camera = [vpos[0], vpos[1], vpos[2], # vfp[0], vfp[1], vfp[2], # vup[0], vup[1], vup[2] ] if not vp.axes: settings.notebook_plotter.grid_visible = False for ia in actors2show2: if isinstance(ia, (vtk.vtkCornerAnnotation, vtk.vtkAssembly)): continue kobj = None kcmap= None name = None if hasattr(ia, 'filename'): if ia.filename: name = os.path.basename(ia.filename) if ia.name: name = os.path.basename(ia.name) #####################################################################scalars # work out scalars first, Points Lines are also Mesh objs if isinstance(ia, (Mesh, shapes.Line, Points)): # print('scalars', ia.name, ia.N()) iap = ia.GetProperty() if isinstance(ia, (shapes.Line, Points)): iapoly = ia.polydata() else: iapoly = ia.clone().clean().triangulate().computeNormals().polydata() vtkscals = None color_attribute = None if ia.mapper().GetScalarVisibility(): vtkdata = iapoly.GetPointData() vtkscals = vtkdata.GetScalars() if vtkscals is None: vtkdata = iapoly.GetCellData() vtkscals = vtkdata.GetScalars() if vtkscals is not None: c2p = vtk.vtkCellDataToPointData() c2p.SetInputData(iapoly) c2p.Update() iapoly = c2p.GetOutput() vtkdata = iapoly.GetPointData() vtkscals = vtkdata.GetScalars() if vtkscals is not None: if not vtkscals.GetName(): vtkscals.SetName('scalars') scals_min, scals_max = ia.mapper().GetScalarRange() color_attribute = (vtkscals.GetName(), scals_min, scals_max) lut = ia.mapper().GetLookupTable() lut.Build() kcmap=[] nlut = lut.GetNumberOfTableValues() for i in range(nlut): r,g,b,a = lut.GetTableValue(i) kcmap += [i/(nlut-1), r,g,b] #####################################################################Volume if isinstance(ia, Volume): # print('Volume', ia.name, ia.dimensions()) kx, ky, kz = ia.dimensions() arr = ia.getPointArray() kimage = arr.reshape(-1, ky, kx) colorTransferFunction = ia.GetProperty().GetRGBTransferFunction() kcmap=[] for i in range(128): r,g,b = colorTransferFunction.GetColor(i/127) kcmap += [i/127, r,g,b] kbounds = numpy.array(ia.imagedata().GetBounds()) \ + numpy.repeat(numpy.array(ia.imagedata().GetSpacing()) / 2.0, 2)\ * numpy.array([-1,1] * 3) kobj = k3d.volume(kimage.astype(numpy.float32), color_map=kcmap, #color_range=ia.imagedata().GetScalarRange(), alpha_coef=10, bounds=kbounds, name=name, ) settings.notebook_plotter += kobj #####################################################################text elif hasattr(ia, 'info') and 'formula' in ia.info.keys(): pos = (ia.GetPosition()[0],ia.GetPosition()[1]) kobj = k3d.text2d(ia.info['formula'], position=pos) settings.notebook_plotter += kobj #####################################################################Mesh elif isinstance(ia, Mesh) and ia.N() and len(ia.faces()): # print('Mesh', ia.name, ia.N(), len(ia.faces())) kobj = k3d.vtk_poly_data(iapoly, name=name, # color=_rgb2int(iap.GetColor()), color_attribute=color_attribute, color_map=kcmap, opacity=iap.GetOpacity(), wireframe=(iap.GetRepresentation()==1)) if iap.GetInterpolation() == 0: kobj.flat_shading = True settings.notebook_plotter += kobj #####################################################################Points elif isinstance(ia, Points) or ia.NPoints() == ia.NCells(): # print('Points', ia.name, ia.N()) kcols=[] if color_attribute is not None: scals = utils.vtk2numpy(vtkscals) kcols = k3d.helpers.map_colors(scals, kcmap, [scals_min,scals_max]).astype(numpy.uint32) # sqsize = numpy.sqrt(numpy.dot(sizes, sizes)) kobj = k3d.points(ia.points().astype(numpy.float32), color=_rgb2int(iap.GetColor()), colors=kcols, opacity=iap.GetOpacity(), shader="dot", point_size=3, # point_size=iap.GetPointSize()*sqsize/800, name=name, ) settings.notebook_plotter += kobj #####################################################################Line elif ia.polydata(False).GetNumberOfLines(): # print('Line', ia.name, ia.N(), len(ia.faces()), # ia.polydata(False).GetNumberOfLines(), len(ia.lines()), # color_attribute, [vtkscals]) # kcols=[] # if color_attribute is not None: # scals = utils.vtk2numpy(vtkscals) # kcols = k3d.helpers.map_colors(scals, kcmap, # [scals_min,scals_max]).astype(numpy.uint32) # sqsize = numpy.sqrt(numpy.dot(sizes, sizes)) for i, ln_idx in enumerate(ia.lines()): if i>200: print('WARNING: K3D nr of line segments is limited to 200.') break pts = ia.points()[ln_idx] kobj = k3d.line(pts.astype(numpy.float32), color=_rgb2int(iap.GetColor()), # colors=kcols, opacity=iap.GetOpacity(), shader="thick", # width=iap.GetLineWidth()*sqsize/1000, name=name, ) settings.notebook_plotter += kobj #################################################################################### elif settings.notebookBackend == 'panel' and hasattr(vp, 'window') and vp.window: import panel # https://panel.pyviz.org/reference/panes/VTK.html vp.renderer.ResetCamera() settings.notebook_plotter = panel.pane.VTK(vp.window, width=int(vp.size[0]/1.5), height=int(vp.size[1]/2)) #################################################################################### elif 'ipyvtk' in settings.notebookBackend and hasattr(vp, 'window') and vp.window: from ipyvtklink.viewer import ViewInteractiveWidget vp.renderer.ResetCamera() settings.notebook_plotter = ViewInteractiveWidget(vp.window) #################################################################################### elif '2d' in settings.notebookBackend.lower() and hasattr(vp, 'window') and vp.window: import PIL.Image try: import IPython except ImportError: raise Exception('IPython not available.') from vedo.io import screenshot settings.screeshotLargeImage = True nn = screenshot(returnNumpy=True, scale=settings.screeshotScale+2) pil_img = PIL.Image.fromarray(nn) settings.notebook_plotter = IPython.display.display(pil_img) return settings.notebook_plotter
index_matrix = ss_airway_modeling(index_matrix, ssl8) index_matrix = ss_airway_modeling(index_matrix, ssl9) index_matrix = ss_airway_modeling(index_matrix, ssl10) print("swaping axes") index_matrix = np.array(index_matrix, dtype="f") index_matrix = np.swapaxes(index_matrix, 0, 2).copy() end = time.time() print(end - start, 's') return index_matrix # In[19]: def image_generation(index_matrix): index_matrix = generating_test_image(index_matrix) print("generating Image") image = itk.GetImageFromArray(index_matrix) return image # In[20]: image = image_generation(index_matrix) # In[21]: view(image) # In[ ]:
def getNotebookBackend(actors2show, zoom, viewup): vp = settings.plotter_instance #################################################################################### # https://github.com/InsightSoftwareConsortium/itkwidgets # /blob/master/itkwidgets/widget_viewer.py if 'itk' in settings.notebookBackend: from itkwidgets import view if sum(vp.shape) != 2: colors.printc("Warning: multirendering is not supported in jupyter.", c=1) settings.notebook_plotter = view(actors=actors2show, cmap='jet', ui_collapsed=True, gradient_opacity=False) #################################################################################### elif settings.notebookBackend == 'k3d': import k3d # https://github.com/K3D-tools/K3D-jupyter if vp.shape[0] != 1 or vp.shape[1] != 1: colors.printc("Warning: multirendering is not supported in jupyter.", c=1) actors2show2 = [] for ia in actors2show: if isinstance(ia, vtk.vtkAssembly): #unpack assemblies acass = ia.unpack() #for a in acass: # a.SetScale(ia.GetScale()) actors2show2 += acass else: actors2show2.append(ia) vbb, sizes, min_bns, max_bns = addons.computeVisibleBounds() kgrid = vbb[0], vbb[2], vbb[4], vbb[1], vbb[3], vbb[5] settings.notebook_plotter = k3d.plot(axes=[vp.xtitle, vp.ytitle, vp.ztitle], menu_visibility=True, height=int(vp.size[1]/2) ) settings.notebook_plotter.grid = kgrid settings.notebook_plotter.lighting = 1.2 # set k3d camera settings.notebook_plotter.camera_auto_fit = False eps = 1 + numpy.random.random()*1.0e-04 # workaround to bug in k3d # https://github.com/K3D-tools/K3D-jupyter/issues/180 if settings.plotter_instance and settings.plotter_instance.camera: k3dc = utils.vtkCameraToK3D(settings.plotter_instance.camera) k3dc[2] = k3dc[2]*eps settings.notebook_plotter.camera = k3dc else: vsx, vsy, vsz = vbb[0]-vbb[1], vbb[2]-vbb[3], vbb[4]-vbb[5] vss = numpy.linalg.norm([vsx, vsy, vsz]) if zoom: vss /= zoom vfp = (vbb[0]+vbb[1])/2, (vbb[2]+vbb[3])/2, (vbb[4]+vbb[5])/2 # camera target if viewup == 'z': vup = (0,0,1) # camera up vector vpos= vfp[0] + vss/1.9, vfp[1] + vss/1.9, vfp[2]+vss*0.01 # camera position elif viewup == 'x': vup = (1,0,0) vpos= vfp[0]+vss*0.01, vfp[1] + vss/1.5, vfp[2] # camera position else: vup = (0,1,0) vpos= vfp[0]+vss*0.01, vfp[1]+vss*0.01, vfp[2] + vss/1.5 # camera position settings.notebook_plotter.camera = [vpos[0], vpos[1], vpos[2]*eps, vfp[0], vfp[1], vfp[2], vup[0], vup[1], vup[2] ] if not vp.axes: settings.notebook_plotter.grid_visible = False for ia in actors2show2: kobj = None kcmap= None if isinstance(ia, Mesh) and ia.N(): iap = ia.GetProperty() #ia.clean().triangulate().computeNormals() #ia.triangulate()) iapoly = ia.clone().clean().triangulate().computeNormals().polydata() vtkscals = None color_attribute = None if ia.mapper().GetScalarVisibility(): vtkdata = iapoly.GetPointData() vtkscals = vtkdata.GetScalars() if vtkscals is None: vtkdata = iapoly.GetCellData() vtkscals = vtkdata.GetScalars() if vtkscals is not None: c2p = vtk.vtkCellDataToPointData() c2p.SetInputData(iapoly) c2p.Update() iapoly = c2p.GetOutput() vtkdata = iapoly.GetPointData() vtkscals = vtkdata.GetScalars() if vtkscals is not None: if not vtkscals.GetName(): vtkscals.SetName('scalars') scals_min, scals_max = ia.mapper().GetScalarRange() color_attribute = (vtkscals.GetName(), scals_min, scals_max) lut = ia.mapper().GetLookupTable() lut.Build() kcmap=[] nlut = lut.GetNumberOfTableValues() for i in range(nlut): r,g,b,a = lut.GetTableValue(i) kcmap += [i/(nlut-1), r,g,b] if iapoly.GetNumberOfPolys() > 0: name = None if ia.filename: name = os.path.basename(ia.filename) kobj = k3d.vtk_poly_data(iapoly, name=name, color=colors.rgb2int(iap.GetColor()), color_attribute=color_attribute, color_map=kcmap, opacity=iap.GetOpacity(), wireframe=(iap.GetRepresentation()==1)) if iap.GetInterpolation() == 0: kobj.flat_shading = True else: kcols=[] if color_attribute is not None: scals = vtk_to_numpy(vtkscals) kcols = k3d.helpers.map_colors(scals, kcmap, [scals_min,scals_max]).astype(numpy.uint32) sqsize = numpy.sqrt(numpy.dot(sizes, sizes)) if ia.NPoints() == ia.NCells(): kobj = k3d.points(ia.points().astype(numpy.float32), color=colors.rgb2int(iap.GetColor()), colors=kcols, opacity=iap.GetOpacity(), shader="3d", point_size=iap.GetPointSize()*sqsize/400, #compression_level=9, ) else: kobj = k3d.line(ia.points().astype(numpy.float32), color=colors.rgb2int(iap.GetColor()), colors=kcols, opacity=iap.GetOpacity(), shader="thick", width=iap.GetLineWidth()*sqsize/1000, ) settings.notebook_plotter += kobj elif isinstance(ia, Volume): kx, ky, kz = ia.dimensions() arr = ia.getPointArray() kimage = arr.reshape(-1, ky, kx) colorTransferFunction = ia.GetProperty().GetRGBTransferFunction() kcmap=[] for i in range(128): r,g,b = colorTransferFunction.GetColor(i/127) kcmap += [i/127, r,g,b] #print('vol scal range', ia.imagedata().GetScalarRange()) #print(numpy.min(kimage), numpy.max(kimage)) kbounds = numpy.array(ia.imagedata().GetBounds()) \ + numpy.repeat(numpy.array(ia.imagedata().GetSpacing()) / 2.0, 2)\ * numpy.array([-1,1] * 3) kobj = k3d.volume(kimage.astype(numpy.float32), color_map=kcmap, #color_range=ia.imagedata().GetScalarRange(), alpha_coef=10, bounds=kbounds, ) settings.notebook_plotter += kobj elif hasattr(ia, 'info') and 'formula' in ia.info.keys(): pos = (ia.GetPosition()[0],ia.GetPosition()[1]) kobj = k3d.text2d(ia.info['formula'], position=pos) settings.notebook_plotter += kobj #################################################################################### elif settings.notebookBackend == 'panel' and hasattr(vp, 'window') and vp.window: import panel # https://panel.pyviz.org/reference/panes/VTK.html vp.renderer.ResetCamera() settings.notebook_plotter = panel.pane.VTK(vp.window, width=int(vp.size[0]/1.5), height=int(vp.size[1]/2)) #################################################################################### elif '2d' in settings.notebookBackend.lower() and hasattr(vp, 'window') and vp.window: import PIL.Image try: import IPython except ImportError: raise Exception('IPython not available.') return from vtkplotter.vtkio import screenshot settings.screeshotLargeImage = True nn = screenshot(returnNumpy=True, scale=settings.screeshotScale+2) pil_img = PIL.Image.fromarray(nn) settings.notebook_plotter = IPython.display.display(pil_img) return settings.notebook_plotter
import math import numpy as np import itk import itkwidgets from itkwidgets import view from ipywidgets import interactive import ipywidgets as widgets # 加载原始体数据并显示 input_name = '/home/hja/Projects/3D2DRegister/ASOCA/Train_Masks/0.nrrd' volume_lung = itk.imread(input_name, itk.ctype('float')) # 读取影像文件,并将数据格式转换为float print(volume_lung.GetLargestPossibleRegion().GetSize()) print(volume_lung.GetBufferedRegion().GetSize()) print(volume_lung.GetSpacing()) print(volume_lung.GetOrigin()) view(volume_lung, gradient_opacity=0.5, cmp=itkwidgets.cm.bone) output_image_pixel_spacing = [0.37, 0.37, 1] output_image_size = [512, 512, 1] # [501, 501, 1] InputImageType = type(volume_lung) FilterType = itk.ResampleImageFilter[InputImageType, InputImageType] filter = FilterType.New() filter.SetInput(volume_lung) filter.SetDefaultPixelValue(0) filter.SetSize(output_image_size) filter.SetOutputSpacing(output_image_pixel_spacing) TransformType = itk.CenteredEuler3DTransform[itk.D] transform = TransformType.New() transform.SetComputeZYX(True)
from skimage.util import montage as montage2d # for showing results import dask.diagnostics as diag foam_stack = imread("../common/data/plateau_border.tif")[:-54, 52:-52, 52:-52] fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 10)) ax1.imshow(np.sum(foam_stack, 0), cmap="bone_r") ax2.imshow(montage2d(foam_stack[::10]), cmap="bone_r") # In[18]: from itkwidgets import view import itk view(itk.GetImageFromArray(foam_stack.copy())) # In[19]: da_foam = da.from_array(foam_stack / 255.0, chunks=(20, 400, 400), name="FoamImage") dot_graph(da_foam.dask) # In[20]: import dask_ndfilters as da_ndfilt image_filt = da_ndfilt.gaussian_filter(1 - da_foam, (3, 6, 6)) dot_graph(image_filt.dask)
def DigitallyReconstructedRadiograph( ray_source_distance=100, camera_tx=0., camera_ty=0., camera_tz=0., rotation_x=0., rotation_y=0., rotation_z=0., projection_normal_p_x=0., projection_normal_p_y=0., rotation_center_rt_volume_center_x=0., rotation_center_rt_volume_center_y=0., rotation_center_rt_volume_center_z=0., threshold=0., ): """ Parameters description: ray_source_distance = 400 # <-sid float> Distance of ray source (focal point) focal point 400mm camera_translation_parameter = [0., 0., 0.] # <-t float float float> Translation parameter of the camera rotation_around_xyz = [0., 0., 0.] # <-rx float> Rotation around x,y,z axis in degrees projection_normal_position = [0, 0] # <-normal float float> The 2D projection normal position [default: 0x0mm] rotation_center_relative_to_volume_center = [0, 0, 0] # <-cor float float float> The centre of rotation relative to centre of volume threshold = 10 # <-threshold float> Threshold [default: 0] """ dgree_to_radius_coef = 1. / 180. * math.pi camera_translation_parameter = [camera_tx, camera_ty, camera_tz] rotation_around_xyz = [rotation_x * dgree_to_radius_coef, rotation_y * dgree_to_radius_coef, rotation_z * dgree_to_radius_coef] projection_normal_position = [projection_normal_p_x, projection_normal_p_y] rotation_center_relative_to_volume_center = [ rotation_center_rt_volume_center_x, rotation_center_rt_volume_center_y, rotation_center_rt_volume_center_z ] imageOrigin = volume_lung.GetOrigin() imageSpacing = volume_lung.GetSpacing() imageRegion = volume_lung.GetBufferedRegion() imageSize = imageRegion.GetSize() imageCenter = [imageOrigin[i] + imageSpacing[i] * imageSize[i] / 2.0 for i in range(3)] transform.SetTranslation(camera_translation_parameter) transform.SetRotation(rotation_around_xyz[0], rotation_around_xyz[1], rotation_around_xyz[2]) center = [c + imageCenter[i] for i, c in enumerate(rotation_center_relative_to_volume_center)] transform.SetCenter(center) interpolator.SetTransform(transform) interpolator.SetThreshold(threshold) focalPoint = [imageCenter[0], imageCenter[1], imageCenter[2] - ray_source_distance / 2.0] interpolator.SetFocalPoint(focalPoint) filter.SetInterpolator(interpolator) filter.SetTransform(transform) origin = [ imageCenter[0] + projection_normal_position[0] - output_image_pixel_spacing[0] * ( output_image_size[0] - 1) / 2., imageCenter[1] + projection_normal_position[1] - output_image_pixel_spacing[1] * ( output_image_size[1] - 1) / 2., imageCenter[2] + imageSpacing[2] * imageSize[2] ] filter.SetOutputOrigin(origin) filter.Update() global viewer if viewer is None: viewer = view(filter.GetOutput(), mode='z') else: print("Update viewer image") viewer.image = filter.GetOutput() # print informations print("Volume image informations:") print("tvolume image origin : ", imageOrigin) print("tvolume image size : ", imageSize) print("tvolume image spacing: ", imageSpacing) print("tvolume image center : ", imageCenter) print("Transform informations:") print("ttranslation : ", camera_translation_parameter) print("trotation : ", rotation_around_xyz) print("tcenter : ", center) print("Interpolator informations: ") print("tthreshold : ", threshold) print("tfocalPoint : ", focalPoint) print("Filter informations:") print("toutput origin : ", origin)
def getNotebookBackend(actors2show, zoom, viewup): vp = settings.plotter_instance if zoom == 'tight': zoom=1 # disable it if isinstance(vp.shape, str) or sum(vp.shape) > 2: colors.printc("Multirendering is not supported in jupyter.", c=1) return #################################################################################### # https://github.com/InsightSoftwareConsortium/itkwidgets # /blob/master/itkwidgets/widget_viewer.py if 'itk' in settings.notebookBackend: from itkwidgets import view settings.notebook_plotter = view(actors=actors2show, cmap='jet', ui_collapsed=True, gradient_opacity=False) #################################################################################### elif settings.notebookBackend == 'k3d': try: import k3d # https://github.com/K3D-tools/K3D-jupyter except: print("Cannot find k3d, install with: pip install k3d") return actors2show2 = [] for ia in actors2show: if not ia: continue if isinstance(ia, vtk.vtkAssembly): #unpack assemblies acass = ia.unpack() actors2show2 += acass else: actors2show2.append(ia) # vbb, sizes, _, _ = addons.computeVisibleBounds() # kgrid = vbb[0], vbb[2], vbb[4], vbb[1], vbb[3], vbb[5] settings.notebook_plotter = k3d.plot(axes=[vp.xtitle, vp.ytitle, vp.ztitle], menu_visibility=settings.k3dMenuVisibility, height=settings.k3dPlotHeight, antialias=settings.k3dAntialias, ) # settings.notebook_plotter.grid = kgrid settings.notebook_plotter.lighting = settings.k3dLighting # set k3d camera settings.notebook_plotter.camera_auto_fit = settings.k3dCameraAutoFit settings.notebook_plotter.grid_auto_fit = settings.k3dGridAutoFit settings.notebook_plotter.axes_helper = settings.k3dAxesHelper if settings.plotter_instance and settings.plotter_instance.camera: k3dc = utils.vtkCameraToK3D(settings.plotter_instance.camera) if zoom: k3dc[0] /= zoom k3dc[1] /= zoom k3dc[2] /= zoom settings.notebook_plotter.camera = k3dc # else: # vsx, vsy, vsz = vbb[0]-vbb[1], vbb[2]-vbb[3], vbb[4]-vbb[5] # vss = numpy.linalg.norm([vsx, vsy, vsz]) # if zoom: # vss /= zoom # vfp = (vbb[0]+vbb[1])/2, (vbb[2]+vbb[3])/2, (vbb[4]+vbb[5])/2 # camera target # if viewup == 'z': # vup = (0,0,1) # camera up vector # vpos= vfp[0] + vss/1.9, vfp[1] + vss/1.9, vfp[2]+vss*0.01 # camera position # elif viewup == 'x': # vup = (1,0,0) # vpos= vfp[0]+vss*0.01, vfp[1] + vss/1.5, vfp[2] # camera position # else: # vup = (0,1,0) # vpos= vfp[0]+vss*0.01, vfp[1]+vss*0.01, vfp[2] + vss/1.5 # camera position # settings.notebook_plotter.camera = [vpos[0], vpos[1], vpos[2], # vfp[0], vfp[1], vfp[2], # vup[0], vup[1], vup[2] ] if not vp.axes: settings.notebook_plotter.grid_visible = False for ia in actors2show2: if isinstance(ia, (vtk.vtkCornerAnnotation, vtk.vtkAssembly)): continue kobj = None kcmap= None name = None if hasattr(ia, 'filename'): if ia.filename: name = os.path.basename(ia.filename) if ia.name: name = os.path.basename(ia.name) #####################################################################scalars # work out scalars first, Points Lines are also Mesh objs if isinstance(ia, (Mesh, shapes.Line, Points)): # print('scalars', ia.name, ia.N()) iap = ia.GetProperty() if isinstance(ia, (shapes.Line, Points)): iapoly = ia.polydata() else: iapoly = ia.clone().clean().triangulate().computeNormals().polydata() vtkscals = None color_attribute = None if ia.mapper().GetScalarVisibility(): vtkdata = iapoly.GetPointData() vtkscals = vtkdata.GetScalars() if vtkscals is None: vtkdata = iapoly.GetCellData() vtkscals = vtkdata.GetScalars() if vtkscals is not None: c2p = vtk.vtkCellDataToPointData() c2p.SetInputData(iapoly) c2p.Update() iapoly = c2p.GetOutput() vtkdata = iapoly.GetPointData() vtkscals = vtkdata.GetScalars() if vtkscals is not None: if not vtkscals.GetName(): vtkscals.SetName('scalars') scals_min, scals_max = ia.mapper().GetScalarRange() color_attribute = (vtkscals.GetName(), scals_min, scals_max) lut = ia.mapper().GetLookupTable() lut.Build() kcmap=[] nlut = lut.GetNumberOfTableValues() for i in range(nlut): r,g,b,a = lut.GetTableValue(i) kcmap += [i/(nlut-1), r,g,b] #####################################################################Volume if isinstance(ia, Volume): # print('Volume', ia.name, ia.dimensions()) kx, ky, kz = ia.dimensions() arr = ia.pointdata[0] kimage = arr.reshape(-1, ky, kx) colorTransferFunction = ia.GetProperty().GetRGBTransferFunction() kcmap=[] for i in range(128): r,g,b = colorTransferFunction.GetColor(i/127) kcmap += [i/127, r,g,b] kbounds = numpy.array(ia.imagedata().GetBounds()) \ + numpy.repeat(numpy.array(ia.imagedata().GetSpacing()) / 2.0, 2)\ * numpy.array([-1,1] * 3) kobj = k3d.volume(kimage.astype(numpy.float32), color_map=kcmap, #color_range=ia.imagedata().GetScalarRange(), alpha_coef=10, bounds=kbounds, name=name, ) settings.notebook_plotter += kobj #####################################################################text elif hasattr(ia, 'info') and 'formula' in ia.info.keys(): pos = (ia.GetPosition()[0],ia.GetPosition()[1]) kobj = k3d.text2d(ia.info['formula'], position=pos) settings.notebook_plotter += kobj #####################################################################Mesh elif isinstance(ia, Mesh) and ia.N() and len(ia.faces()): # print('Mesh', ia.name, ia.N(), len(ia.faces())) kobj = k3d.vtk_poly_data(iapoly, name=name, # color=_rgb2int(iap.GetColor()), color_attribute=color_attribute, color_map=kcmap, opacity=iap.GetOpacity(), wireframe=(iap.GetRepresentation()==1)) if iap.GetInterpolation() == 0: kobj.flat_shading = True settings.notebook_plotter += kobj #####################################################################Points elif isinstance(ia, Points): # print('Points', ia.name, ia.N()) kcols=[] if color_attribute is not None: scals = utils.vtk2numpy(vtkscals) kcols = k3d.helpers.map_colors(scals, kcmap, [scals_min,scals_max]).astype(numpy.uint32) # sqsize = numpy.sqrt(numpy.dot(sizes, sizes)) kobj = k3d.points(ia.points().astype(numpy.float32), color=_rgb2int(iap.GetColor()), colors=kcols, opacity=iap.GetOpacity(), shader=settings.k3dPointShader, point_size=iap.GetPointSize(), name=name, ) settings.notebook_plotter += kobj #####################################################################Lines elif ia.polydata(False).GetNumberOfLines(): # print('Line', ia.name, ia.N(), len(ia.faces()), # ia.polydata(False).GetNumberOfLines(), len(ia.lines()), # color_attribute, [vtkscals]) # kcols=[] # if color_attribute is not None: # scals = utils.vtk2numpy(vtkscals) # kcols = k3d.helpers.map_colors(scals, kcmap, # [scals_min,scals_max]).astype(numpy.uint32) # sqsize = numpy.sqrt(numpy.dot(sizes, sizes)) for i, ln_idx in enumerate(ia.lines()): if i>200: print('WARNING: K3D nr of line segments is limited to 200.') break pts = ia.points()[ln_idx] kobj = k3d.line(pts.astype(numpy.float32), color=_rgb2int(iap.GetColor()), opacity=iap.GetOpacity(), shader=settings.k3dLineShader, # width=iap.GetLineWidth()*sqsize/1000, name=name, ) settings.notebook_plotter += kobj #################################################################################### elif settings.notebookBackend == 'panel' and hasattr(vp, 'window') and vp.window: import panel # https://panel.pyviz.org/reference/panes/VTK.html vp.renderer.ResetCamera() settings.notebook_plotter = panel.pane.VTK(vp.window, width=int(vp.size[0]/1.5), height=int(vp.size[1]/2)) #################################################################################### elif 'ipyvtk' in settings.notebookBackend and hasattr(vp, 'window') and vp.window: from ipyvtklink.viewer import ViewInteractiveWidget vp.renderer.ResetCamera() settings.notebook_plotter = ViewInteractiveWidget(vp.window) #################################################################################### elif 'ipygany' in settings.notebookBackend: from ipygany import PolyMesh, Scene, IsoColor, RGB, Component from ipygany import Alpha, ColorBar, colormaps, PointCloud from ipywidgets import FloatRangeSlider, Dropdown, VBox, AppLayout, jslink bgcol = colors.rgb2hex(colors.getColor(vp.backgrcol)) actors2show2 = [] for ia in actors2show: if not ia: continue if isinstance(ia, vedo.Assembly): #unpack assemblies assacts = ia.unpack() for ja in assacts: if isinstance(ja, vedo.Assembly): actors2show2 += ja.unpack() else: actors2show2.append(ja) else: actors2show2.append(ia) pmeshes = [] colorbar = None for obj in actors2show2: # print("ipygany processing:", [obj], obj.name) if isinstance(obj, vedo.shapes.Line): lg = obj.diagonalSize()/1000 * obj.GetProperty().GetLineWidth() vmesh = vedo.shapes.Tube(obj.points(), r=lg, res=4).triangulate() vmesh.c(obj.c()) faces = vmesh.faces() # todo: Lines elif isinstance(obj, Mesh): vmesh = obj.triangulate() faces = vmesh.faces() elif isinstance(obj, Points): vmesh = obj faces = [] elif isinstance(obj, Volume): vmesh = obj.isosurface() faces = vmesh.faces() elif isinstance(obj, vedo.TetMesh): vmesh = obj.tomesh(fill=False) faces = vmesh.faces() else: print("ipygany backend: cannot process object type", [obj]) continue vertices = vmesh.points() scals = vmesh.inputdata().GetPointData().GetScalars() if scals and not colorbar: # there is an active array, only pick the first aname = scals.GetName() arr = vmesh.pointdata[aname] parr = Component(name=aname, array=arr) if len(faces): pmesh = PolyMesh(vertices=vertices, triangle_indices=faces, data={aname: [parr]}) else: pmesh = PointCloud(vertices=vertices, data={aname: [parr]}) rng = scals.GetRange() colored_pmesh = IsoColor(pmesh, input=aname, min=rng[0], max=rng[1]) if obj.scalarbar: colorbar = ColorBar(colored_pmesh) colormap_slider_range = FloatRangeSlider(value=rng, min=rng[0], max=rng[1], step=(rng[1] - rng[0]) / 100.) jslink((colored_pmesh, 'range'), (colormap_slider_range, 'value')) colormap = Dropdown( options=colormaps, description='Colormap:' ) jslink((colored_pmesh, 'colormap'), (colormap, 'index')) else: if len(faces): pmesh = PolyMesh(vertices=vertices, triangle_indices=faces) else: pmesh = PointCloud(vertices=vertices) if vmesh.alpha() < 1: colored_pmesh = Alpha(RGB(pmesh, input=tuple(vmesh.color())), input=vmesh.alpha()) else: colored_pmesh = RGB(pmesh, input=tuple(vmesh.color())) pmeshes.append(colored_pmesh) if colorbar: scene = AppLayout( left_sidebar=Scene(pmeshes, background_color=bgcol), right_sidebar=VBox((colormap_slider_range, #not working colorbar, colormap)), pane_widths=[2, 0, 1], ) else: scene = Scene(pmeshes, background_color=bgcol) settings.notebook_plotter = scene #################################################################################### elif '2d' in settings.notebookBackend.lower() and hasattr(vp, 'window') and vp.window: import PIL.Image try: import IPython except ImportError: raise Exception('IPython not available.') from vedo.io import screenshot settings.screeshotLargeImage = True nn = screenshot(returnNumpy=True, scale=settings.screeshotScale+2) pil_img = PIL.Image.fromarray(nn) settings.notebook_plotter = IPython.display.display(pil_img) return settings.notebook_plotter
def contourf(self, **kwargs): x = kwargs.get("x", self._obj.SCHISM_hgrid_node_x[:].values) y = kwargs.get("y", self._obj.SCHISM_hgrid_node_y[:].values) try: t = kwargs.get("t", self._obj.time.values) except: pass tri3 = kwargs.get("tes", self._obj.SCHISM_hgrid_face_nodes.values[:, :3].astype(int)) it = kwargs.get("it", None) var = kwargs.get("var", "depth") z = kwargs.get("z", self._obj[var].values[it, :].flatten()) name = kwargs.get("name", self._obj[var].name) vmin = kwargs.get("vmin", z.min()) vmax = kwargs.get("vmax", z.max()) R = kwargs.get("R", 1.0) dim = kwargs.get("dim", "2D") if dim == "3D": px, py, pz = to_3d(x, y, R=R) else: px = x py = y pz = np.zeros(x.shape[0]) rep = kwargs.get("representation", "surface") cmap = kwargs.get("cmap", "gist_earth") mlab.figure(1, size=(3840, 2160), bgcolor=(0, 0, 0), fgcolor=(1.0, 1.0, 1.0)) mlab.clf() bcolor = kwargs.get("bcolor", (0.0, 0.0, 0.0)) # self.globe(R - 0.002, bcolor=bcolor) # 3D triangular mesh surface (like trisurf) grd = mlab.triangular_mesh( px, py, pz, tri3, representation=rep, opacity=1.0, scalars=z, colormap=cmap, vmin=vmin, vmax=vmax, ) grd.actor.mapper.scalar_visibility = True mlab.view(azimuth=0, distance=4) title = kwargs.get("title", "{}".format(var)) mlab.colorbar(grd, title=name, orientation="vertical") coast = kwargs.get("coastlines", None) if coast is not None: src, lines = self.c3d(coast, R=R) mlab.pipeline.surface(src, color=(1, 0, 0), line_width=10, opacity=0.8) v = view(actors=grd, rotate=False, ui_collapsed=True) v.geometries = [v.geometries[0]] # print(v.geometries) # print(v.geometries[0].keys()) # print(v.geometries[0]['points']) # v.geometries[0]['pointData']['arrays'][1]['data']['name'] = 'elevation' # v.geometries[0]['metadata'] = {"name":"earth"} # print(v.geometries) return v
def __init__(self, tree=None, swc_morphologies=[], markers=[], marker_sizes=[], marker_opacities=[], marker_colors=[], selected_allen_ids=None, selected_acronyms=None, rotate=False, **kwargs): """Create a 3D CCF visualization ipywidget. Parameters ---------- tree: None or 'ipytree', optional, default: None Structure tree visualization to include. swc_morphologies: List, optional, default: [] List of Allen SWC morphologies to render. markers: List of Nx3 arrays, optional, default: [] Points locations to visualize in the CCF. Each element in the list corresponds to a different set of markers. Each marker set has N points, with point locations in CCF coordinates: [anterior_posterior, dorsal_ventral, left_right] marker_sizes: List of integers in [1, 10], optional, default: [] Size of the markers. marker_opacities: array of floats, default: [1.0,]*n Opacity for the markers, in the range (0.0, 1.0]. marker_colors: list of (r, g, b) colors Colors for the N markers. See help(matplotlib.colors) for specification. Defaults to the Glasbey series of categorical colors. selected_allen_ids: List of Allen ids to highlight, optional, default: None List of integer Allen Structure Graph ids to highlight. Specify selected_allen_ids or selected_acronyms. selected_acronyms: List of Allen acronyms to highlight, optional, default: None List of string Allen Structure Graph acronyms to highlight. Specify selected_allen_ids or selected_acronyms. rotate: bool, optional, default: False Make the CCF continuously rotate. """ self._image = itk.image_from_xarray(_image_da) self._label_image = itk.image_from_xarray(_label_image_da) self.swc_point_sets = [] self.swc_geometries = [] opacity_gaussians = [[{ 'position': 0.28094135802469133, 'height': 0.3909090909090909, 'width': 0.44048611111111113, 'xBias': 0.21240499194846996, 'yBias': 0.5416908212560397 }, { 'position': 0.2787808641975309, 'height': 1, 'width': 0.1, 'xBias': 0, 'yBias': 0 }]] opacity_gaussians = [[{ 'position': 0.32816358024691356, 'height': 0.5, 'width': 0.29048611111111106, 'xBias': 0.20684943639291442, 'yBias': 1.1235090030742216 }]] camera = np.array([[1.3441567e+03, -2.1723846e+04, 1.7496496e+04], [6.5500000e+03, 3.9750000e+03, 5.6750000e+03], [3.6606243e-01, -4.4908229e-01, -8.1506038e-01]], dtype=np.float32) size_limit_3d = [256, 256, 256] self.itk_viewer = view(image=self._image, label_image=self._label_image, opacity_gaussians=opacity_gaussians, label_image_blend=0.65, point_sets=markers.copy(), camera=camera, ui_collapsed=True, shadow=False, size_limit_3d=size_limit_3d, background=(0.85, ) * 3, units="μm", gradient_opacity=0.1) # Todo: initialization should work self.itk_viewer.opacity_gaussians = opacity_gaussians self.itk_viewer.rotate = rotate self.itk_viewer.label_image_blend = 0.65 mode_buttons = RadioButtons(options=['x', 'y', 'z', 'v'], value='v', description='View mode:') link((mode_buttons, 'value'), (self.itk_viewer, 'mode')) rotate_checkbox = Checkbox(value=rotate, description='Rotate') link((rotate_checkbox, 'value'), (self.itk_viewer, 'rotate')) viewer_controls = HBox([mode_buttons, rotate_checkbox]) viewer = VBox([self.itk_viewer, viewer_controls]) children = [viewer] self._validating_allen_ids = False self._validating_acronyms = False self._validating_tree = False self.tree_widget = None if tree is not None: if tree == 'ipytree': from .ipytree_widget import IPyTreeWidget self.tree_widget = IPyTreeWidget(structure_graph) children.append(self.tree_widget) self.tree_widget.observe(self._ipytree_on_selected_change, names=['selected_nodes']) def open_parent(node): if hasattr(node, 'parent_structure_id') and \ node.parent_structure_id in self.tree_widget.allen_id_to_node: parent = self.tree_widget.allen_id_to_node[ node.parent_structure_id] open_parent(parent) else: node.opened = True self.last_selected_tree_nodes = [] def ipytree_on_allen_ids_changed(change): self._validating_tree = True with self.tree_widget.hold_sync(): for node in self.last_selected_tree_nodes: node.selected = False tree_nodes = [ self.tree_widget.allen_id_to_node[allen_id] for allen_id in change.new ] for node in tree_nodes: open_parent(node) node.selected = True node.opened = True self.last_selected_tree_nodes = tree_nodes self._validating_tree = False # self.observe(ipytree_on_allen_ids_changed, names='selected_allen_ids') else: raise RuntimeError('Invalid tree type') self.labels = np.unique(self.itk_viewer.rendered_label_image) super(CCFWidget, self).__init__(children, **kwargs) for morphology in swc_morphologies: soma_point_set, geometry = swc_morphology_geometry(morphology) self.swc_point_sets.append(soma_point_set) self.swc_geometries.append(geometry) if swc_morphologies: self.itk_viewer.point_sets = self.swc_point_sets self.itk_viewer.point_set_sizes = [ 3, ] * len(self.swc_point_sets) self.itk_viewer.point_set_opacities = [ 1.0, ] * len(self.swc_point_sets) self.itk_viewer.point_set_colors = [ (1.0, 0.0, 0.0), ] * len(self.swc_point_sets) self.itk_viewer.geometries = self.swc_geometries if selected_acronyms: self.selected_acronyms = selected_acronyms if selected_allen_ids: self.selected_allen_ids = selected_allen_ids self.markers = markers if marker_sizes: self.marker_sizes = marker_sizes if marker_opacities: self.marker_opacities = marker_opacities if marker_colors: self.marker_colors = marker_colors