def __init__(self, *args, **kwargs): self.dt = kwargs.pop("dt", 100) # update every dt milliseconds self.timerId = None self.isplaying = False self.counter = 0 # frame counter self.plotter = vedo.Plotter(*args, **kwargs) # setup the Plotter object self.timerevt = self.plotter.addCallback('timer', self.handle_timer)
def viz_mean_excitability(sid, rid): regpos, w, obsmask, surfaces, contacts = read_structural_data(sid, rid) vlines, vmeshes, vcontacts = viz_structure(regpos, w, surfaces, contacts) # Load results nreg = regpos.shape[0] res = io.parse_csv([ f"run/solo/INC/vep/id{sid:03d}/output/r{rid:02d}_all/chain_{chain}.csv" for chain in [1, 2] ]) cinf = res['c'] # cmean = np.mean(cinf, axis=0) # pexc = np.mean(cinf > 2.0, axis=0) scalar = np.percentile(cinf, 50, axis=0) # Regions cmap = 'plasma' # vmin = np.min(scalar) # vmax = np.max(scalar) vmin, vmax = -2, 2 vpoints = [] for i in range(nreg): if not obsmask[i]: vpoints.append( vp.Sphere(regpos[i], r=4, c=vp.colorMap(scalar[i], cmap, vmin, vmax))) else: vpoints.append( vp.Cube(regpos[i], side=6, c=vp.colorMap(scalar[i], cmap, vmin, vmax))) vbar = vp.Points(regpos, r=0.01).pointColors(scalar, cmap=cmap, vmin=vmin, vmax=vmax) vbar.addScalarBar(horizontal=True, pos=(0.8, 0.02)) def slider(widget, event): percentile = widget.GetRepresentation().GetValue() scalar = np.percentile(cinf, percentile, axis=0) for i in range(nreg): vpoints[i].color(vp.colorMap(scalar[i], cmap, vmin, vmax)) vplotter = vp.Plotter(axes=0) vplotter.addSlider2D(slider, 0., 100., value=50.0, pos=3, title="Percentile") vplotter.show(vpoints, vlines, vmeshes, vcontacts, vbar)
def viz_network_scalar(centres, scalars, weights, obsmask, surfs, view='topdown', size=(1000, 1000), cmap='viridis', vmin=None, vmax=None): vp.embedWindow(False) if vmin is None: vmin = np.min(scalars) if vmax is None: vmax = np.max(scalars) vlines, vmeshes = viz_structure(centres, weights, surfs, w_perc=3) nreg = centres.shape[0] # Regions vpoints = [] for i in range(nreg): if not obsmask[i]: vpoints.append( vp.Sphere(centres[i], r=4, c=vp.colorMap(scalars[i], cmap, vmin, vmax))) else: vpoints.append( vp.Cube(centres[i], side=6, c=vp.colorMap(scalars[i], cmap, vmin, vmax))) if view == 'topdown': args = dict(elevation=0, azimuth=0, roll=0, zoom=1.4) elif view == 'leftright': args = dict(elevation=0, azimuth=270, roll=90, zoom=1.4) elif view == 'rightleft': args = dict(elevation=0, azimuth=90, roll=270, zoom=1.4) else: raise ValueError(f"Unexpected view: {view}") vplotter = vp.Plotter(axes=0, offscreen=True, size=size) vplotter.show(vpoints, vlines, vmeshes, N=1, **args) img = vp.screenshot(None, scale=1, returnNumpy=True) vp.clear() vp.closePlotter() return img
def viz_excitability(sid, rid): regpos, w, obsmask, surfaces, contacts = read_structural_data(sid, rid) vlines, vmeshes, vcontacts = viz_structure(regpos, w, surfaces, contacts) # Load results nreg = regpos.shape[0] res = io.parse_csv([ f"run/solo/INC/vep/id{sid:03d}/output/r{rid:02d}_all/chain_{chain}.csv" for chain in [1, 2] ]) cinf = res['c'] ctr = 2.0 pexc = np.mean(cinf > ctr, axis=0) # Regions cmap = 'Reds' vmin, vmax = 0, 0.15 # vmin, vmax = -2, 0 vpoints = [] for i in range(nreg): if not obsmask[i]: vpoints.append( vp.Sphere(regpos[i], r=4, c=vp.colorMap(pexc[i], cmap, vmin, vmax))) else: vpoints.append( vp.Cube(regpos[i], side=6, c=vp.colorMap(pexc[i], cmap, vmin, vmax))) vbar = vp.Points(regpos, r=0.01).pointColors(pexc, cmap=cmap, vmin=vmin, vmax=vmax) vbar.addScalarBar(horizontal=True, pos=(0.8, 0.02)) def cslider(widget, event): ctr = widget.GetRepresentation().GetValue() pexc = np.mean(cinf > ctr, axis=0) for i in range(nreg): vpoints[i].color(vp.colorMap(pexc[i], cmap, vmin, vmax)) vplotter = vp.Plotter(axes=0) vplotter.addSlider2D(cslider, -3.0, 3.0, value=2.0, pos=3, title="c") vplotter.show(vpoints, vlines, vmeshes, vcontacts, vbar)
def viz_seizure(sid, rid): regpos, w, obsmask, surfaces, contacts = read_structural_data(sid, rid) vlines, vmeshes, vcontacts = viz_structure(regpos, w, surfaces, contacts) # Load results nreg = regpos.shape[0] res = io.parse_csv([ f"run/solo/INC/vep/id{sid:03d}/output/r{rid:02d}_all/chain_{chain}.csv" for chain in [1, 2] ]) tinf = res['t'] t = 0.0 psz = np.mean(tinf < t, axis=0) # Regions cmap = 'bwr' vmin, vmax = 0, 1 vpoints = [] for i in range(nreg): if not obsmask[i]: vpoints.append( vp.Sphere(regpos[i], r=4, c=vp.colorMap(psz[i], cmap, vmin, vmax))) else: vpoints.append( vp.Cube(regpos[i], side=6, c=vp.colorMap(psz[i], cmap, vmin, vmax))) vbar = vp.Points(regpos, r=0.01).pointColors(psz, cmap=cmap, vmin=vmin, vmax=vmax) vbar.addScalarBar(horizontal=True, pos=(0.8, 0.02)) def tslider(widget, event): t = widget.GetRepresentation().GetValue() psz = np.mean(tinf < t, axis=0) for i in range(nreg): vpoints[i].color(vp.colorMap(psz[i], cmap, vmin, vmax)) vplotter = vp.Plotter(axes=0) vplotter.addSlider2D(tslider, 0, 90.0, value=0.0, pos=3, title="t") vplotter.show(vpoints, vlines, vmeshes, vcontacts, vbar)
def plot_mesh(mesh, arrows, cones, complete=True, mesh2=None): """ Plot mesh. Args: mesh (vedo.pointcloud.Points): Mesh object. arrows (vedo.shapes.Arrows): Load arrows. cones (vedo.shapes.Cones): Cones to represent constrain nodes. complete (:obj:`bool`, optional): If true plot mesh with loads and constrain nodes. Defaults to True. mesh2 (:obj:`vedo.pointcloud.Points`, optional): Mesh without faces. Defaults to None. """ vp = vt.Plotter() vp += mesh if complete: vp += arrows vp += cones if mesh2 is not None: vp += mesh2 return vp
def __init__(self, model, project_parameters): super().__init__(model, project_parameters) ######### GUI attributes self.Continue = True self.timestep = 0 self.slider1 = Slider(0) self.Plot = vedo.Plotter(title="Simulation Results", interactive=False) self.Plot.addSlider2D(self.slider1.GenericSlider, -200, 400, value=0, pos=3, title="Pressure (MPa)") self.Plot += vedo.Text2D( 'Move the slider to change the Pressure on the Face of the Bunny', s=1.2) self.PauseButton = self.Plot.addButton( self.PauseButtonFunc, pos=(0.9, .9), # x,y fraction from bottom left corner states=["PAUSE", "CONTINUE"], c=["w", "w"], bc=["b", "g"], # colors of states font="courier", # arial, courier, times size=25, bold=True, italic=False, ) self.StopButton = self.Plot.addButton( self.StopButtonFunc, pos=(0.1, .9), # x,y fraction from bottom left corner states=["STOP"], c=["w"], bc=["r"], # colors of states font="courier", # arial, courier, times size=25, bold=True, italic=False, ) self.Plot.show()
def animation(coord, connect, amp, disp_vector): """ Plot deformed mesh animation. Args: coord (:obj:`numpy.array`): Coordinates of the element. connect (:obj:`numpy.array`): Element connectivity. amp (:obj:`int`): Amplitude. disp_vector (:obj:`numpy.array`): Displacement. """ vt.printc("Press F1 to exit.", c="red", invert=1) vp = vt.Plotter(axes=0, interactive=0) vp += __doc__ ind_faces_U = free_faces(coord, connect) aux = np.linspace(-1, 1, num=400) factor = amp * np.sin(aux * 2 * np.pi) while True: for f in factor: coord3D_U = fc.apply_U(disp_vector, coord, factor=f) verts_U = coord3D_U[:, 1:] mesh = build_mesh(verts_U, ind_faces_U) vp.clear() vp.add(mesh) vp.show()
def viz_param_manifold(filename, size): data = np.load(filename) vline = vp.Tube(data['boundary_hns'], r=0.08) vline.color('g') # HNS manifold vmesh_hns = vp.Mesh([data['verts_hns'], data['triangs_hns']]) k = 3 prior = (2 * np.pi)**(-k / 2) * (np.exp( -0.5 * np.sum(vmesh_hns.points()**2, axis=1))) vmesh_hns.pointColors(prior, cmap='Reds', vmin=0) vmesh_hns.addScalarBar(horizontal=True, nlabels=6, c='k', pos=(0.74, 0.01), titleFontSize=44) vmesh_hns.scalarbar.SetLabelFormat("%.2g") vmesh_hns.scalarbar.SetBarRatio(1.0) # Inverted HNS manifold vmesh_hnsi = vp.Mesh([data['verts_hnsi'], data['triangs_hnsi']]) # vmesh_hnsi.color([0.68, 0.68, 0.68]) vmesh_hnsi.color([0.9, 0.9, 0.9]).alpha(0.0) # Invisible points to set the extent vpoints = vp.Points([(-5.01, -5.01, -5.01), (5.01, 5.01, 5.01)]).alpha(0.0) vplotter = vp.Plotter(offscreen=True, size=size, axes=dict(xyGrid=True, yzGrid=True, zxGrid=True, xTitleSize=0, yTitleSize=0, zTitleSize=0, xHighlightZero=True, yHighlightZero=True, zHighlightZero=True, xHighlightZeroColor='b', yHighlightZeroColor='b', zHighlightZeroColor='b', numberOfDivisions=10, axesLineWidth=5, tipSize=0.02, gridLineWidth=2, xLabelSize=0.05, yLabelSize=0.05, zLabelSize=0.05, xLabelOffset=0.05, yLabelOffset=0.05, zLabelOffset=0.0, zTitleRotation=225)) vlabels = [ vp.Text2D("H", (0.09 * size[0], 0.10 * size[1]), s=3, font='Arial'), vp.Text2D("N", (0.87 * size[0], 0.16 * size[1]), s=3, font='Arial'), vp.Text2D("S", (0.49 * size[0], 0.90 * size[1]), s=3, font='Arial') ] k = 2 vecs = np.array([[[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]], [[k, -k, 0, 0, 0, 0], [0, 0, k, -k, 0, 0], [0, 0, 0, 0, k, -k]]]) varrows = vp.Arrows(vecs[0].T, vecs[1].T, s=1.2, c='k') vp.show([vline, vmesh_hns, vmesh_hnsi, vpoints, varrows] + vlabels, camera=dict(pos=(16, 13, 20), focalPoint=(0, 0, 1.5), viewup=(0, 0, 1))) img = vp.screenshot(None, scale=1, returnNumpy=True) vp.clear() vp.closePlotter() return img
"""Create a simple Play/Pause app with a timer event You can interact with the scene during the loop! ..press q to quit""" import vedo def buttonfunc(): global timerId plotter.timerCallback("destroy", timerId) if "Play" in button.status(): # instruct to call handle_timer() every 10 msec: timerId = plotter.timerCallback("create", dt=10) button.switch() def handle_timer(event): ### Animate your stuff here ###################################### earth.rotateZ(1) # rotate the Earth by 1 deg plotter.render() plotter = vedo.Plotter() timerId = None button = plotter.addButton(buttonfunc, states=[" Play ","Pause"], size=40) evntId = plotter.addCallback("timer", handle_timer) earth = vedo.Earth() plotter.show(earth, __doc__, axes=1, bg2='b9', viewup='z')
meshes.append(mesh) displacements.append(displacement) # plot things: txt = vedo.Text2D(f"step{i}") arrow = vedo.Arrow2D([0, 0], F * 20).z(1) vedo.dolfin.plot(mesh, arrow, txt, c='grey5', at=i, N=N, zoom=1.1) #PRESS q dmesh_i = meshes[0] # initial mesh dmesh_f = meshes[-1] # final mesh vmesh_i = vedo.Mesh([dmesh_i.coordinates(), dmesh_i.cells()], c='grey5').z(-1) vmesh_f = vedo.Mesh( [dmesh_f.coordinates(), dmesh_f.cells()], c='grey3').wireframe() plt = vedo.Plotter() # move a few points along the deformation of the circle seeds = vedo.Circle(r=50, res=res).points()[:, (0, 1)] # make points 2d with [:,(0,1)] endpoints = [] for i, p in enumerate(seeds): line = [p] for u in displacements: p = p + u(p) line.append(p) plt += vedo.Line(line, c=i, lw=4).z(1) endpoints.append(p) plt += [vmesh_i, vmesh_f, __doc__]
plt.add(objs, resetcam=False) return [x, y] # Load some 2D shape and make it symmetric shape = vedo.load(vedo.dataurl + 'timecourse1d.npy')[55] shaper = vedo.Line(shape).mirror('x').reverse() shape = vedo.merge(shape, shaper) x, y, _ = shape.points().T # Compute Fourier Discrete Transform in x and y separately: fourierX = DFT(x) fourierY = DFT(y) vedo.settings.defaultFont = 'Glasgo' plt = vedo.Plotter(size=(1500, 750), bg='black', axes=1, interactive=False) txt = vedo.Text2D(f"{__doc__} (order={order})", c='red9', bg='white', pos='bottom-center') plt.show(shape, txt, mode='image', zoom=1.9) objs, points = [], [] times = np.linspace(0, 2 * np.pi, len(fourierX), endpoint=False) for time in times: x, _ = epicycles(time, 0, fourierX, order) _, y = epicycles(time, np.pi / 2, fourierY, order) points.append([x, y]) plt.interactive()
def make_video(sid, rid, video_file): regpos, w, obsmask, surfaces, contacts = read_structural_data(sid, rid) vlines, vmeshes, vcontacts = viz_structure(regpos, w, surfaces, contacts) # Load results res = io.parse_csv([ f"run/solo/INC/vep/id{sid:03d}/output/r{rid:02d}_all/chain_{chain}.csv" for chain in [1, 2] ]) tinf = res['t'] t = 0.0 psz = np.mean(tinf < t, axis=0) nreg = regpos.shape[0] # Regions cmap = 'bwr' vpoints = [] for i in range(nreg): if not obsmask[i]: vpoints.append( vp.Sphere(regpos[i], r=4, c=vp.colorMap(psz[i], cmap, 0, 1))) else: vpoints.append( vp.Cube(regpos[i], side=6, c=vp.colorMap(psz[i], cmap, 0, 1))) vbar = vp.Points(regpos, r=0.01).pointColors(psz, cmap=cmap, vmin=0, vmax=1) vbar.addScalarBar(horizontal=True, pos=(0.8, 0.02)) vtext = vp.Text2D(f"t = {t:4.1f} s", pos=0, s=2, c='black') center = np.mean(regpos, axis=0) dist = 2.5 * (np.max(regpos[:, 1]) - np.min(regpos[:, 1])) # Video ------------------------------------------------------- vplotter = vp.Plotter(axes=0, interactive=0, offscreen=True, size=(1800, 1800)) nframes = 3000 vplotter += vpoints vplotter += vlines vplotter += vmeshes video = vp.Video(name=video_file, duration=90) ratios = np.array([30, 3, 5, 30, 5, 3, 30, 10]) frames = (nframes * ratios / np.sum(ratios)).astype(int) # Run and pause animate(vplotter, video, frames[0], vpoints, tinf, pos=center + dist * np.r_[0, 0, 1], foc=center, viewup=(0, 1, 1), prange=(0, 45), time=lambda p: p) animate(vplotter, video, frames[1], vpoints, tinf, pos=center + dist * np.r_[0, 0, 1], foc=center, viewup=(0, 1, 1), time=45.) ## Fly around pos = lambda angle: center + dist * np.array( [0, -np.sin(angle), np.cos(angle)]) animate(vplotter, video, frames[2], vpoints, tinf, pos=pos, foc=center, viewup=(0, 1, 1), prange=(0, np.pi / 2), time=45., endpoint=False) pos = lambda angle: center + dist * np.array( [-np.sin(angle), -np.cos(angle), 0]) animate(vplotter, video, frames[3], vpoints, tinf, pos=pos, foc=center, viewup=(0, 0, 1), prange=(0, 2 * np.pi), time=45.) pos = lambda angle: center + dist * np.array( [0, -np.sin(angle), np.cos(angle)]) animate(vplotter, video, frames[4], vpoints, tinf, pos=pos, foc=center, viewup=(0, 1, 1), prange=(np.pi / 2, 0), time=45., startpoint=False) # Pause + run + pause animate(vplotter, video, frames[5], vpoints, tinf, pos=center + dist * np.r_[0, 0, 1], foc=center, viewup=(0, 1, 1), time=45.) animate(vplotter, video, frames[6], vpoints, tinf, pos=center + dist * np.r_[0, 0, 1], foc=center, viewup=(0, 1, 1), prange=(45, 90), time=lambda p: p) animate(vplotter, video, frames[7], vpoints, tinf, pos=center + dist * np.r_[0, 0, 1], foc=center, viewup=(0, 1, 1), time=90.) video.close()
if key == 'Left' and data_idx > 0: data_idx -= 1 elif key == 'Right' and data_idx < data_length - 1: data_idx += 1 pos, path = getpos(data_idx) plt.clear() plt.add(vedo.Points(pos, c='b')) plt.add(vedo.Text2D(path, pos=(.02, .02), c='k')) plt.add(boundary_mesh) plt.render() plt = vedo.Plotter(interactive=False) pos, path = getpos(data_idx) pts = vedo.Points(pos, c='b') plt.keyPressFunction = keyfunc data_info = vedo.Text2D(path, pos=(.02, .02), c='k') verts = [(-1.5, 0, -1.5), (-1.5, 0, 1.5), (1.5, 0, 1.5), (1.5, 0, -1.5), (-1.5, 5, -1.5), (-1.5, 5, 1.5), (1.5, 5, 1.5), (1.5, 5, -1.5)] # faces = [(3,2,1,0),(0,1,5,4),(4,5,6,7),(2,3,7,6),(1,2,6,5),(4,7,3,0)] faces = [(3, 2, 1, 0), (0, 1, 5, 4), (4, 7, 3, 0)] boundary_mesh = vedo.Mesh([verts, faces]).lineColor('black').lineWidth(1)
self.actor.points(self.positions()) # update all positions return self ################################################################################ if __name__ == "__main__": vedo.settings.allowInteraction = True np.random.seed(6) boids = [] for i in range(500): c = 'black' if i % 50 else 'red' boids.append(Boid(np.random.randn(3), np.random.randn(3), c=c)) flock = Flock(boids) plt = vedo.Plotter(bg2='lb', interactive=False) axes = vedo.Axes(xrange=(-3, 3), yrange=(-3, 3), zrange=(-3, 3), yzGrid=True, zxGrid2=True) plt += [__doc__, flock.actor, axes] pb = vedo.ProgressBar(0, 100) for i in pb.range(): flock.move() plt.show(resetcam=False, viewup='z') pb.print()
def viz_observation_manifold(t3, tlim, size): tmin = 0 tmax = 2 * tlim # tlim line vline1 = vp.Tube([[tmin, tlim, t3], [tmax, tlim, t3]], r=2.0) vline1.color('g') # t = 0 line vline2 = vp.Tube([[tmin, tlim, t3], [tmin, tmax, t3]], r=2.0) vline2.color((1, 1, 1)) # Manifold verts = [[tmin, tlim, t3], [tmax, tlim, t3], [tmin, tmax, t3], [tmax, tmax, t3]] triangs = [[0, 1, 3], [0, 3, 2]] vmesh1 = vp.Mesh([verts, triangs]) vmesh1.color((1, 1, 1)) # Inverse manifold verts = [[tmin, tmin, t3], [tmax, tmin, t3], [tmin, tlim, t3], [tmax, tlim, t3]] triangs = [[0, 1, 3], [0, 3, 2]] vmesh2 = vp.Mesh([verts, triangs]) vmesh2.color((0.9, 0.9, 0.9)).alpha(0.0) # Invisible points to set the extent vpoints = vp.Points([(tmin - 0.1, tmin - 0.1, tmin - 0.1), (1.01 * tmax, 1.01 * tmax, 1.01 * tmax)]).alpha(0.0) lpos = [(p, str(p)) for p in [0, 50, 100, 150]] vplotter = vp.Plotter(offscreen=True, size=size, axes=dict(xyGrid=True, yzGrid=True, zxGrid=True, xTitleSize=0, yTitleSize=0, zTitleSize=0, xPositionsAndLabels=lpos, yPositionsAndLabels=lpos, zPositionsAndLabels=lpos[1:], axesLineWidth=5, tipSize=0.02, gridLineWidth=2, xLabelSize=0.05, yLabelSize=0.05, zLabelSize=0.05, xLabelOffset=0.05, yLabelOffset=0.05, zLabelOffset=0.0, zTitleRotation=225)) vlabels = [ vp.Text2D("H", (0.09 * size[0], 0.10 * size[1]), s=3, font='Arial'), vp.Text2D("N", (0.87 * size[0], 0.16 * size[1]), s=3, font='Arial'), vp.Text2D("S", (0.49 * size[0], 0.90 * size[1]), s=3, font='Arial') ] vp.show([vline1, vline2, vmesh1, vpoints] + vlabels, camera=dict(pos=(378, 324, 450), focalPoint=(tlim, tlim, tlim + 27), viewup=(0, 0, 1))) img = vp.screenshot(None, scale=1, returnNumpy=True) vp.clear() vp.closePlotter() return img
def _view(scene, backend='2d', sea=True, width=1024, height=600, camera_pos=(50, -25, 10), lookat=(0, 0, 0), visual_alpha=1.0, do_meshes=True, geometry_size=1, force_normalize=False, force_scale=1, cog_normalize=False, cog_scale=1): camera = dict() camera['viewup'] = [0, 0, 1] camera['pos'] = camera_pos camera['focalPoint'] = lookat vtkp.embedWindow(backend=backend) # screenshot vtkp.settings.usingQt = False vp = DAVE.visual.Viewport(scene) vp.visual_alpha = visual_alpha vp.show_meshes = do_meshes vp.show_geometry = (geometry_size > 0) vp.geometry_scale = geometry_size vp.force_do_normalize = force_normalize vp.show_force = (force_scale > 0) vp.force_scale = force_scale vp.cog_scale = cog_scale vp.cog_do_normalize = cog_normalize vtkp.settings.lightFollowsCamera = True offscreen = vtkp.Plotter(axes=0, offscreen=True, size=(width, height)) vp.show_global = sea vp.create_world_actors() vp.create_visuals(recreate=True) vp.position_visuals() vp.update_visibility() warningshown = False for va in vp.visuals: for a in va.actors: if a.GetVisibility(): if backend == 'panel': # Work-around for panel tr = vtk.vtkTransform() tr.SetMatrix(a.GetMatrix()) a.SetScale(tr.GetScale()) a.SetPosition(tr.GetPosition()) a.SetOrientation(tr.GetOrientation()) scale = tr.GetScale() orientation = tr.GetOrientation() if not warningshown: if isinstance(va.node, DAVE.Visual): if scale != (1, 1, 1): if orientation != (0, 0, 0): print( 'WARNING: THIS INTERACTIVE VIEWER WRONGLY HANDLES SCALE IN COMBINATION WITH ORIENTATION.' ) if va.node is not None: print( f'VISUAL FOR {va.node.name} IS NOT DISPLAYED CORRECTLY.' ) print( 'USE show(...) or Gui for correct visualization' ) warningshown = True tr0 = vtk.vtkTransform() tr0.Identity() a.SetUserTransform(tr0) offscreen.add(a) return offscreen.show(camera=camera)
f1_list = sorted(f1_files) f2_list = sorted(f2_files) # print(f1_list) # print(f2_list) index = 3 medium = pv.read(tmp_folder + 'porousMedium.vti') grains = medium.get_array('tag').reshape([nz, ny, nx]) grains = grains[:, :, n_slices_start:nx-n_slices_end] grains = grains[:,:,:] print(grains.shape) grains = vd.Volume(grains).isosurface(1) plt = vd.Plotter(axes=9, bg='w', bg2='w', size=(1200,900), offscreen=False) # Create a vedo plotter; axes=9 is just an outline plt += grains.c("gray").opacity(0.4) cam = dict(pos=(179, 313, 136), focalPoint=(45.0, 49.5, 44.0), viewup=(-0.163, -0.252, 0.954), distance=309, clippingRange=(158, 501)) plt.show(camera=cam, interactive=True) # .screenshot(f'animation_and_plotting/gif_images/test{index}.png', scale=4) plt.close() # exit() # for index in range(len(f1_list)): f1_mesh = pv.read(f1_list[index]) f1_density = f1_mesh.get_array('Density').reshape([nz, ny, nx]) f1_density = f1_density[:, :, n_slices_start:nx-n_slices_end]
import numpy as np from geom.geometry3d import rot3d_from_rtp, rot3d_from_z_vec, rot3d_from_x_vec import vedo import trimesh import pyvista as pv import cv2 as cv plt1 = vedo.Plotter(title='Confirm Perch Location', pos=[0, 0], interactive=True, sharecam=False) plt2 = vedo.Plotter(title='Simulated Camera View', sharecam=False, pos=[800, 0], size=[1155.5, 650], interactive=False) approved = False user_responded = False def confirm_perch_placement(environment, placed_cameras, focus_id): global approved global user_responded plt1.keyPressFunction = perch_keyfunc plt1.clear() approved = False plt2.clear()
def optimize(seg_env_prototype=None, target_prototype=None, cluster_env_path=None, full_env_path=None, N_its=1, enable_user_confirmation=True, preloaded_vars=None, visualize_with_vedo=False): if preloaded_vars is None: env, camera_list, optimization_options, pso_options = initialize( seg_env_prototype, target_prototype, cluster_env_path, full_env_path, load_full_env=True) if enable_user_confirmation: # surface_confirmation.confirm_surfaces(environment=env, N_max=10) surface_confirmation_demo.confirm_surfaces(environment=env, N_max=10) env.post_process_environment() preloaded_vars = { 'env': copy.deepcopy(env), 'camera_list': copy.deepcopy(camera_list), 'optimization_options': copy.deepcopy(optimization_options), 'pso_options': copy.deepcopy(pso_options) } # SAVE THIS! pickle_env = open("../test/preloaded_environment_apartment.p", 'wb') pickle.dump(preloaded_vars, pickle_env) pickle_env.close() else: # work around to the seg fault issue... load everything in advance, then just pass it in! env = preloaded_vars['env'] camera_list = initialize_camera_list() optimization_options = initialize_opt_options() pso_options = initialize_pso_options() env.vedo_mesh = vedo.mesh.Mesh(env.obs_mesh) env.opt_options = optimization_options env.correct_normals() env.n_points = optimization_options.n_points env.generate_integration_points() env.perch_regions = [] env.perch_area = 0 env.set_surface_as_perchable() optimization_options.log_performance = False # env.plot_environment() # PSO: # base dimension for simple 2d problem is 2. scales up depending on selected opt camera_particle_dimension = optimization_options.get_particle_size() n_cams = len(camera_list) N_iterations = pso_options["N_iterations"] N_particles = pso_options["N_particles"] if pso_options["greedy_search"]: particle_dimension = camera_particle_dimension num_optimizations = n_cams else: particle_dimension = n_cams * camera_particle_dimension num_optimizations = 1 # for logging pso_keypoints = np.zeros([N_its, num_optimizations, N_iterations, 3]) optimization_options.search_time = np.zeros( [N_its, num_optimizations, N_iterations + 1]) optimization_options.best_fitness = np.zeros( [N_its, num_optimizations, N_iterations + 1]) optimization_options.pts_searched = np.zeros( [N_its, num_optimizations, N_iterations + 1]) bounds = (np.zeros(particle_dimension), np.ones(particle_dimension) ) # particle boundaries # for velocity update: # 'w' is velocity decay aka inertia, # 'c1' is "cognitive parameter", e.g. attraction to particle best, # 'c2' is "social parameter", e.g. attraction to local/global best # 'k' = number of neighbors to consider # 'p' = the Minkowski p-norm. 1 for absolute val dist, 2 for norm dist options = { 'c1': pso_options["pso_c1"], 'c2': pso_options["pso_c2"], 'w': pso_options["pso_w"], 'k': pso_options["pso_k"], 'p': pso_options["pso_p"] } optimal_cameras = PlacedCameras() fig_num = 1 if pso_options['individual_surface_opt']: num_surface_loops = len(env.perch_regions) surface_number = range(num_surface_loops) N_particles = env.assign_particles_to_surfaces( N_particles, pso_options["pso_k"], neighborhood_search=pso_options["local_search"]) else: num_surface_loops = 1 surface_number = [-1] N_particles = [N_particles] # STORE FOR ANALYSIS LATER if optimization_options.log_performance: pso_best_fitnesses = np.zeros(num_optimizations) pso_points_searched = np.zeros(num_optimizations) pso_search_time = np.zeros(num_optimizations) pso_keypoints = [] for i in range(num_optimizations): pso_keypoints.append([[], [], [], []]) # store, for each optimization, time, num particles searched, fitness, standard deviation bh = pso_options["boundary_handling"] # for i in range(num_optimizations): i = 0 while i < num_optimizations: if optimization_options.log_performance: optimization_options.data_index = 0 start_time = datetime.now() if pso_options["greedy_search"]: search_cameras_list = [copy.deepcopy(camera_list[i])] else: search_cameras_list = camera_list best_cost = np.finfo(float).max best_pos_surf = -1 best_pos = np.zeros(particle_dimension) for j in range(num_surface_loops): # Future work: investigate velocity clamping... optimization_options.surface_number = j # if pso_options["local_search"]: # optimizer = ps.single.LocalBestPSO(n_particles=N_particles[j], dimensions=particle_dimension, # options=options, bounds=bounds, bh_strategy=bh) # else: # optimizer = ps.single.GlobalBestPSO(n_particles=N_particles[j], dimensions=particle_dimension, # options=options, bounds=bounds, bh_strategy=bh) optimization_options.surface_number = surface_number[j] # this flag gets reset if the current search has too little variance optimization_options.continue_searching = True optimization_options.stagnant_loops = 0 if visualize_with_vedo: plt1 = vedo.Plotter(title='Confirm Perch Location', pos=[0, 0], interactive=False, sharecam=False) plt1.clear() # draw wireframe lineset of camera frustum # env_mesh = trimesh.load(env.full_env_path) env_mesh = trimesh.load( '/home/simon/catkin_ws/src/mesh_partition/datasets/' + env.name + '_1m_pt1.ply') R = np.zeros([4, 4]) R[:3, :3] = env.R env_mesh.vertices = trimesh.transform_points( env_mesh.vertices, R) env_mesh_vedo = vedo.mesh.Mesh(env_mesh) target_mesh_pymesh = env.generate_target_mesh(shape='box') target_mesh = trimesh.Trimesh(target_mesh_pymesh.vertices, target_mesh_pymesh.faces) target_mesh_vedo = vedo.mesh.Mesh(target_mesh) target_colors = 0.5 * np.ones([len(target_mesh.faces), 4]) target_colors[:, 0] *= 0 target_colors[:, 2] *= 0 target_mesh_vedo.alpha(0.6) target_mesh_vedo.cellIndividualColors(target_colors, alphaPerCell=True) env_mesh.visual.face_colors[:, -1] = 255 env_mesh_vedo.cellIndividualColors( env_mesh.visual.face_colors / 255, alphaPerCell=True) geom_list = [env_mesh_vedo, target_mesh_vedo] if env.name == 'office3' or env.name == 'apartment': env_mesh2 = trimesh.load( '/home/simon/catkin_ws/src/mesh_partition/datasets/' + env.name + '_1m_pt2.ply') env_mesh_vedo2 = vedo.mesh.Mesh(env_mesh2) env_mesh2.visual.face_colors[:, -1] = 150 env_mesh_vedo2.cellIndividualColors( env_mesh2.visual.face_colors / 255, alphaPerCell=True) geom_list.append(env_mesh_vedo2) for s in env.perch_regions: surf_mesh = trimesh.Trimesh(vertices=s.points, faces=s.faces) vedo_surf_mesh = vedo.mesh.Mesh(surf_mesh) vedo_surf_mesh.color('g') vedo_surf_mesh.opacity(0.7) geom_list.append(vedo_surf_mesh) for i_ in range(len(optimal_cameras.cameras)): quad_mesh = trimesh.load( "/home/simon/catkin_ws/src/perch_placement/src/ui/models/white-red-black_quad2.ply" ) R = rot3d_from_x_vec( optimal_cameras.cameras[i_].wall_normal) R2 = rot3d_from_rtp(np.array([0, -90, 0])) R_aug = np.zeros([4, 4]) R_aug[:3, :3] = R.dot(R2) R_aug[:3, -1] = optimal_cameras.cameras[i_].pose[:3] quad_mesh.vertices = trimesh.transform_points( quad_mesh.vertices, R_aug) quad_mesh_vedo = vedo.mesh.Mesh(quad_mesh) quad_mesh_vedo.cellIndividualColors( quad_mesh.visual.face_colors / 255, alphaPerCell=True) pymesh_frustum = optimal_cameras.cameras[ i_].generate_discrete_camera_mesh(degrees_per_step=20, environment=env) pymesh_verts = pymesh_frustum.vertices.copy() pymesh_verts.flags.writeable = True pymesh_faces = pymesh_frustum.faces.copy() pymesh_faces.flags.writeable = True frustum = trimesh.Trimesh( vertices=pymesh_frustum.vertices.copy(), faces=pymesh_frustum.faces.copy()) vedo_frustum = vedo.mesh.Mesh(frustum) vedo_frustum.alpha(0.3) vedo_frustum.color("b") quad_mesh_vedo.color('o') geom_list.append(quad_mesh_vedo) geom_list.append(vedo_frustum) for actor in geom_list: plt1.add(actor) else: plt1 = None # if pso_options["multi_threading"]: # # noinspection PyTypeChecker # surf_best_cost, surf_best_pos = optimizer.optimize(evaluate_swarm, iters=N_iterations, environment=env, # cameras=search_cameras_list, # placed_cameras=optimal_cameras, # opt_options=optimization_options, # n_processes=multiprocessing.cpu_count(), # vedo_plt=plt1) # else: # surf_best_cost, surf_best_pos = optimizer.optimize(evaluate_swarm, iters=N_iterations, environment=env, # cameras=search_cameras_list, # placed_cameras=optimal_cameras, # opt_options=optimization_options, # vedo_plt=plt1) pso_params = PSO_Hyperparameters(w=pso_options["pso_w"], c1=pso_options["pso_c1"], c2=pso_options["pso_c2"], lr=1, k=pso_options["pso_k"], p=pso_options["pso_p"], N_particles=N_particles[j], N_iterations=N_iterations) surf_best_cost, surf_best_pos = run_pso( fitness_function=evaluate_swarm, pso_hyper_parameters=pso_params, environment=env, cameras=search_cameras_list, placed_cameras=optimal_cameras, opt_options=optimization_options, local_pso=True) if surf_best_cost < best_cost: best_cost = copy.deepcopy(surf_best_cost) best_pos = copy.deepcopy(surf_best_pos) if pso_options["individual_surface_opt"]: best_pos_surf = j # print("Surface " + str(j) + " has lowest cost so far.. ") # print("Particle: " + str(best_pos)) if optimization_options.log_performance: pso_search_time[i] = (datetime.now() - start_time).total_seconds() pso_best_fitnesses[i] = best_cost if pso_options["greedy_search"]: search_cameras_list_copy = copy.deepcopy(search_cameras_list) optimization_options.surface_number = best_pos_surf best_cam = convert_particle_to_state( environment=env, particle=best_pos, cameras=search_cameras_list_copy, opt_options=optimization_options)[0] optimal_cameras.cameras.append(copy.deepcopy(best_cam)) if enable_user_confirmation: if confirm_perch_placement( environment=env, placed_cameras=optimal_cameras.cameras, focus_id=i): best_cam_covariances = evaluate_camera_covariance( environment=env, cameras=[best_cam]) optimal_cameras.append_covariances(best_cam_covariances) i += 1 else: optimal_cameras.cameras.pop() env.remove_rejected_from_perch_space(camera=best_cam, r=0.3) else: best_cam_covariances = evaluate_camera_covariance( environment=env, cameras=[best_cam]) optimal_cameras.append_covariances(best_cam_covariances) i += 1 evaluate_discrete_coverage(env.n_points, optimal_cameras, plot=True) return optimal_cameras.cameras
# It would be more correct (API-wise) to call widget.Initialize() and # widget.Start() here, but Initialize() calls RenderWindow.Render(). # That Render() call will get through before we can setup the # RenderWindow() to render via the wxWidgets-created context; this # causes flashing on some platforms and downright breaks things on # other platforms. Instead, we call widget.Enable(). widget.Enable(1) widget.AddObserver("ExitEvent", lambda o,e,f=frame: f.Close()) ##################################################### vedo example def func(evt): print("Event dump:\n", evt) plt.camera.Azimuth(10) # rotate one camera cone = vedo.shapes.Cone(c='green8') axes = vedo.Axes(cone, c='white') cube = vedo.shapes.Cube() # Create 2 subwindows with a cone and a cube plt = vedo.Plotter(N=2, bg='blue2', bg2='blue8', wxWidget=widget) plt.addCallback("right mouse click", func) plt.add([cone, axes, "right-click anywhere"], at=0).resetCamera() plt.add([cube], at=1).resetCamera() # plt.show() # vedo.show() is now disabled in wx ##################################################### # Show everything frame.Show() app.MainLoop()
##################################################### vedo def funcMove(event): mesh = event.actor if not mesh: return ptid = mesh.closestPoint(event.picked3d, returnPointId=True) txt = f"Probed point:\n{vedo.utils.precision(event.picked3d, 3)}\n" \ f"value = {vedo.utils.precision(arr[ptid], 2)}" vpt = vedo.shapes.Sphere(mesh.points(ptid), r=0.01, c='orange2').pickable(False) vig = vpt.vignette(txt, s=.05, offset=(0.5,0.5), font="VictorMono").followCamera() msg.text(txt) # update the 2d text message plt.remove(plt.actors[-2:]).add([vpt, vig]) # remove last 2 objects, add the new ones widget.Render() # need to manually call Render msg = vedo.Text2D(pos='bottom-left', font="VictorMono") msh = vedo.shapes.ParametricShape("RandomHills").cmap('terrain') axs = vedo.Axes(msh) arr = msh.pointdata["Scalars"] plt = vedo.Plotter(bg='moccasin', bg2='blue9', wxWidget=widget) plt.add([msh, axs, msg]).resetCamera() plt.actors += [None,None,None] # place holder for sphere, vignette, text2d plt.addCallback('MouseMove', funcMove) ##################################################### # Show everything frame.Show() app.MainLoop()