vp = Plotter(shape=[2, 2], verbose=0, axes=3, interactive=0) shape1 = Sphere(alpha=0.2) shape2 = vp.load('data/shapes/icosahedron.vtk').normalize().lineWidth(1) agrid1, actorpts1 = makeGrid(shape1, N) vp.show(at=0, actors=[shape1, actorpts1]) agrid2, actorpts2 = makeGrid(shape2, N) vp.show(at=1, actors=[shape2, actorpts2]) vp.camera.Zoom(1.2) vp.interactive = False clm1 = pyshtools.SHGrid.from_array(agrid1).expand() clm2 = pyshtools.SHGrid.from_array(agrid2).expand() # clm1.plot_spectrum2d() # plot the value of the sph harm. coefficients # clm2.plot_spectrum2d() for t in arange(0, 1, 0.005): act21 = Points(morph(clm2, clm1, t, lmax), c='r', r=4) act12 = Points(morph(clm1, clm2, t, lmax), c='g', r=4) vp.show(at=2, actors=act21, resetcam=0, legend='time: ' + str(int(t * 100))) vp.show(at=3, actors=act12) vp.camera.Azimuth(2) vp.show(interactive=1)
# Can simulate the 'Arago spot', the bright point at the center of # a circular object shadow (https://en.wikipedia.org/wiki/Arago_spot). # from numpy import conj, real, pi, array, sin, cos, exp from vtkplotter import Plotter, arange, mag, grid, line ######################################### lambda1 = 680e-9 # red wavelength 680nm width = 10e-6 # slit width in m D = 0.1 # screen distance in m ######################################### # create the slits as a set of individual coherent point-like sources n = 10 # nr of elementary sources in slit (to control precision). slit1 = list(zip([0] * n, arange(0, n) * width / n, [0] * n)) # source points inside slit 1 slit2 = list(slit1 + array([1e-5, 0, 0])) # a shifted copy of slit 1 slits = slit1 + slit2 #slits += list(slit1 + array([-2e-5, 1e-5, 0])) # add an other copy of slit 1 #slits = [(cos(x)*4e-5, sin(x)*4e-5, 0) for x in arange(0,2*pi, .1)] # Arago spot #slits = grid(sx=1e-4, sy=1e-4, resx=9, resy=9).coordinates() # a square lattice vp = Plotter(title='The Double Slit Experiment', axes=0, verbose=0, bg='black') screen = vp.add(grid(pos=[0, 0, -D], sx=0.1, sy=0.1, resx=200, resy=50)) screen.wire(False) # show it as a solid plane (not as wireframe) k = 0.0 + 1j * 2 * pi / lambda1 # complex wave number norm = len(slits) * 5e+5 amplitudes = []
# Example on how to specify a color for each individual cell # or point of an actor's mesh. # Last example also shows the usage of addScalarBar3D(). # from vtkplotter import Plotter, arange vp = Plotter(N=3) ##################################### addPointScalars man1 = vp.load('data/shapes/man.vtk') Np = man1.N() # nr. of vertices scals = arange(0, 1, 1. / Np) # coloring by index nr of vertex man1.addPointScalars(scals, 'mypointscalars') # add a vtkArray to actor #print(man1.scalars('mypointscalars')) # info can be retrieved this way vp.show(man1, at=0, elevation=-60) vp.addScalarBar() # add a scalarbar to last drawn actor ##################################### pointColors man2 = vp.load('data/shapes/man.vtk') scals = man2.coordinates()[:, 1] + 37 # pick y coordinates of vertices man2.pointColors(scals, cmap='bone', vmin=36.2, vmax=36.7) # right dark arm vp.show(man2, at=1, axes=0, legend='pointColors') vp.addScalarBar(horizontal=True) ##################################### cellColors man3 = vp.load('data/shapes/man.vtk') scals = man3.cellCenters()[:, 2] + 37 # pick z coordinates of cells man3.cellColors(scals, cmap='afmhot') #print(man3.scalars('cellColors_afmhot')) # info can be retrieved this way
# Example on how to specify a color for each individual cell # or point of an actor's mesh. # Last example shows the usage of addScalarBar3D(). # Needs matplotlib. from vtkplotter import Plotter, arange vp = Plotter(shape=(1, 3), size='fullscreen') ##################################### man1 = vp.load('data/shapes/man.vtk') Np = man1.N() # nr. of vertices pscals = arange(0, 1, 1. / Np) # coloring will be by index nr of the vertex man1.pointScalars(pscals, 'mypointscalars') # add a vtkArray to actor #print(man1.scalars('mypointscalars')) # info can be retrieved this way vp.show(man1, at=0, axes=1) vp.addScalarBar() # add a scalarbar to last drawn actor ##################################### man2 = vp.load('data/shapes/man.vtk') pscals = man2.coordinates()[:, 1] + 37 # pick y coordinates of vertices man2.pointColors(pscals, cmap='bone') # use a colormap to associate a color #print(man2.scalars('pointColors_bone')) # info can be retrieved this way vp.show(man2, at=1, axes=0, legend='pointColors') vp.addScalarBar(horizontal=True) ##################################### man3 = vp.load('data/shapes/man.vtk') cscals = man3.cellCenters()[:, 2] + 37 # pick z coordinates of cells man3.cellColors(cscals, cmap='afmhot') # add some oriented 3D text
Rb = screen_w/32 # Radius of the big sphere Rs = Rb*0.43 # Radius of small spheres Ms=(Rs/Rb)**3 # Mass of the small spheres (Mbig=1) Dt = 0.03 # Time step LBox=(screen_w/2,screen_h/2) # Size of the box = 2LBox[0].2LBox[1] Lb0 = LBox[0]-Rb Lb1 = LBox[1]-Rb Ls0 = LBox[0]-Rs Ls1 = LBox[1]-Rs # Create the arrays with the initial positions of the spheres. # Start with the big sphere at the center, then put the small # spheres at random selected from a grid of possible positions. ListPos=[(0,0)] PossiblePos=[(x,y) for x in arange(-LBox[0]+2*Rs,LBox[0]-2*Rs,2.2*Rs) for y in arange(-LBox[1]+2*Rs,LBox[1]-2*Rs,2.2*Rs) if x*x+y*y > Rb+Rs] if Nsp > len(PossiblePos)+1: Nsp = len(PossiblePos)+1 for s in range(Nsp-1): n = random.randint(0, len(PossiblePos)-1) ListPos.append(PossiblePos[n]) del PossiblePos[n] Pos = np.array(ListPos) # Create an array with all the radius and a list with all the masses Radius = np.concatenate( (np.array([Rb]), np.array([Rs]*(Nsp-1))) ) Mass=[1.0]+[Ms]*(Nsp-1)
Rs = Rb * 0.43 # Radius of small spheres Ms = (Rs / Rb)**3 # Mass of the small spheres (Mbig=1) Dt = 0.03 # Time step LBox = (screen_w / 2, screen_h / 2) # Size of the box = 2LBox[0].2LBox[1] Lb0 = LBox[0] - Rb Lb1 = LBox[1] - Rb Ls0 = LBox[0] - Rs Ls1 = LBox[1] - Rs # Create the arrays with the initial positions of the spheres. # Start with the big sphere at the center, then put the small # spheres at random selected from a grid of possible positions. ListPos = [(0, 0)] PossiblePos = [(x, y) for x in arange(-LBox[0] + 2 * Rs, LBox[0] - 2 * Rs, 2.2 * Rs) for y in arange(-LBox[1] + 2 * Rs, LBox[1] - 2 * Rs, 2.2 * Rs) if x * x + y * y > Rb + Rs] if Nsp > len(PossiblePos) + 1: Nsp = len(PossiblePos) + 1 for s in range(Nsp - 1): n = random.randint(0, len(PossiblePos) - 1) ListPos.append(PossiblePos[n]) del PossiblePos[n] Pos = np.array(ListPos) # Create an array with all the radius and a list with all the masses Radius = np.concatenate((np.array([Rb]), np.array([Rs] * (Nsp - 1)))) Mass = [1.0] + [Ms] * (Nsp - 1)
# The input actor's polydata is modified by the method # so more than one pass is possible. # If showNLines>0 an actor is built demonstrating the # details of the regression for some random points # from __future__ import division, print_function from vtkplotter import Plotter, arange, sin, cos, sqrt from vtkplotter.analysis import smoothMLS1D import numpy as np N = 9 # nr. of iterations # build some initial cloud of noisy points along a line #pts = [ (sin(6*x), sin(2*x)/(x+1), cos(9*x)) for x in arange(0,1, .001)] #pts = [ (0, sin(x), cos(x)) for x in arange(0,6, .002) ] pts = [(sqrt(x), sin(x), x / 10) for x in arange(0, 16, .01)] pts += np.random.randn(len(pts), 3) / 10 # add noise np.random.shuffle(pts) # make sure points are not ordered vp = Plotter(N=N, axes=5) a = vp.points(pts) vp.show(a, at=0, legend='cloud') for i in range(1, N): a = a.clone().color(i) smoothMLS1D(a, f=0.2) # at last iteration make sure points are separated by tol if i == N - 1: a.clean(tol=.01)
model.add(Dense(neurons, activation="relu")) model.add(Dense(neurons, activation="relu")) model.add(Dense(1, activation="sigmoid")) model.compile(optimizer="rmsprop", loss="mse", metrics=["mae"]) model.fit(datalist, scalars, epochs=50, batch_size=64) predicted_scalars = model.predict(datalist) model.summary() idx = 0 vispred = np.zeros([n, n, n]) for i, x in enumerate(ls): for j, y in enumerate(ls): for k, z in enumerate(ls): vispred[i, j, k] = predicted_scalars[idx] idx += 1 v1 = Volume(visdata) v2 = Volume(vispred) s1 = v1.isosurface(threshold=[t for t in arange(0, 1, 0.1)]) s1.alpha(0.5) s2 = v2.isosurface(threshold=[t for t in arange(0, 1, 0.1)]) s2.alpha(0.5) show([[v1, s1], s2], N=2, axes=8)
(as source are in scale, too small to be seen, they are magnified x200). Can simulate the 'Arago spot', the bright point at the center of a circular object shadow (https://en.wikipedia.org/wiki/Arago_spot). ''' from numpy import conj, real, pi, array, sin, cos, exp from vtkplotter import Plotter, arange, mag, Grid, Line, Points, Text ######################################### lambda1 = 680e-9 # red wavelength 680nm width = 10e-6 # slit width in m D = 0.1 # screen distance in m ######################################### # create the slits as a set of individual coherent point-like sources n = 10 # nr of elementary sources in slit (to control precision). slit1 = list(zip([0]*n, arange(0,n)*width/n, [0]*n)) # source points inside slit 1 slit2 = list(slit1 + array([1e-5, 0,0])) # a shifted copy of slit 1 slits = slit1 + slit2 #slits += list(slit1 + array([-2e-5, 1e-5, 0])) # add an other copy of slit 1 #slits = [(cos(x)*4e-5, sin(x)*4e-5, 0) for x in arange(0,2*pi, .1)] # Arago spot #slits = Grid(sx=1e-4, sy=1e-4, resx=9, resy=9).coordinates() # a square lattice vp = Plotter(title='The Double Slit Experiment', axes=0, verbose=0, bg='black') screen = vp.add(Grid(pos=[0,0,-D], sx=0.1, sy=0.1, resx=200, resy=50)) screen.wire(False) # show it as a solid plane (not as wireframe) k = 0.0 + 1j * 2*pi/lambda1 # complex wave number norm = len(slits)*5e+5 amplitudes = []
from vtkplotter import Plotter, arange, exp c = 2.9979246e+8 k = 1.3806485e-23 # boltzmann constant h = 6.6260700e-34 # planck constant def planck(l, T): a = 2 * h * c**2 b = h * c / (l * k * T) return a / (l**5 * (exp(b) - 1)) * 1e-13 # Planck formula vp = Plotter(interactive=0, verbose=0, bg='k', axes=0) vp.infinity = True # view from infinity (axes are kept orthogonal) vp.xtitle = '' vp.ytitle = 'Intensity' vp.ztitle = 'Temperature' vp.load('data/images/light.jpg').scale(.00118).pos([.72, -.11, .14]) wavelengths = arange(400, 700, 10) * 1e-9 intensities = [] for T in range(3000, 9000, 50): I = planck(wavelengths, T) coords = list(zip(wavelengths * 2e+6, I * 0.02, [T * 5e-5] * len(I))) lineact = vp.line(coords, lw=4, alpha=.5) lineact.pointColors(wavelengths * 2e+6, cmap='jet') vp.show(elevation=.1, azimuth=0.1) vp.show(axes=1, interactive=1)
model.add(Dense(neurons, activation="relu")) model.add(Dense(neurons, activation="relu")) model.add(Dense(1, activation="sigmoid")) model.compile(optimizer="rmsprop", loss="mse", metrics=["mae"]) model.fit(datalist, scalars, epochs=50, batch_size=64) predicted_scalars = model.predict(datalist) model.summary() idx = 0 vispred = np.zeros([n, n, n]) for i, x in enumerate(ls): for j, y in enumerate(ls): for k, z in enumerate(ls): vispred[i, j, k] = predicted_scalars[idx] idx += 1 v1 = Volume(visdata) v2 = Volume(vispred) s1 = isosurface(v1, threshold=[t for t in arange(0, 1, 0.1)]) s1.alpha(0.5) s2 = isosurface(v2, threshold=[t for t in arange(0, 1, 0.1)]) s2.alpha(0.5) show([[v1, s1], s2], N=2, axes=8, bg="w", depthpeeling=1)
# Form a surface by joining two lines. # from vtkplotter import Plotter, arange, sin, cos vp = Plotter() l1 = [ [sin(x), cos(x), x/2] for x in arange(0,9, .1)] l2 = [ [sin(x)+0.2, cos(x)+x/15, x/2] for x in arange(0,9, .1)] vp.tube(l1, c='g', r=0.02) vp.tube(l2, c='b', r=0.02) vp.ribbon(l1, l2, alpha=.2, res=(200,5), legend='ruled surf').wire(1) vp.show(viewup='z')
model.add(Dense(neurons, activation="relu")) model.add(Dense(neurons, activation="relu")) model.add(Dense(1, activation="sigmoid")) model.compile(optimizer="rmsprop", loss="mse", metrics=["mae"]) model.fit(datalist, scalars, epochs=50, batch_size=64) predicted_scalars = model.predict(datalist) model.summary() idx = 0 vispred = np.zeros([n, n, n]) for i, x in enumerate(ls): for j, y in enumerate(ls): for k, z in enumerate(ls): vispred[i, j, k] = predicted_scalars[idx] idx += 1 v1 = Volume(visdata) v2 = Volume(vispred) s1 = isosurface(v1.image, threshold=[t for t in arange(0, 1, 0.1)]) s1.alpha(0.5) s2 = isosurface(v2.image, threshold=[t for t in arange(0, 1, 0.1)]) s2.alpha(0.5) show([[v1, s1], s2], N=2, axes=8, bg="w", depthpeeling=1)
#Create a map of transparencies which can be passed # to method pointColors() # from vtkplotter import Plotter, arange vp = Plotter(axes=6) # type 6 marks bounding box corners act = vp.load('data/beethoven.ply') # pick y coordinates of vertices and use them as scalars pscals = act.coordinates()[:, 1] # make a range of transparencies from bottom (0) to top (1) alphas = arange(0, 1, 1. / len(pscals)) act.pointColors(pscals, alpha=alphas, cmap='copper') vp.show(act)