def axis_visual(scale=1.0, parent=None): """ Returns a :class:`vispy.scene.visuals.XYZAxis` class instance using given scale. Parameters ---------- scale : numeric, optional Axis visual scale. parent : Node, optional Parent of the axis visual in the `SceneGraph`. Returns ------- XYZAxis Axis visual. """ axis = XYZAxis(parent=parent) transform = MatrixTransform() transform.scale((scale, scale, scale)) axis.transform = transform return axis
class dummy(scene.visuals.Cube): """ creates a custom draft to demonstrate what is not working """ def __init__(self,view,x,y,z,face_color,edge_color): scene.visuals.Cube.__init__(self,(x,y,z),color=face_color,edge_color=edge_color,parent=view) def trafo(self,x=0.,y=0.,z=0.,angle=0.,al=0.,be=0.,ga=0.): #Not Working self.transform = MatrixTransform() self.transform = self.transform.rotate(angle,[al,be,ga]) self.transform = self.transform.translate([x,y,z])
def __init__(self): vispy.app.Canvas.__init__(self, keys='interactive', size=(800, 800)) # Create 4 copies of an image to be displayed with different transforms image = get_image() self.images = [visuals.ImageVisual(image, method='impostor') for i in range(4)] # Transform all images to a standard size / location (because # get_image() might return unexpected sizes) s = 100. / max(self.images[0].size) tx = 0.5 * (100 - (self.images[0].size[0] * s)) ty = 0.5 * (100 - (self.images[0].size[1] * s)) base_tr = STTransform(scale=(s, s), translate=(tx, ty)) self.images[0].transform = (STTransform(scale=(30, 30), translate=(600, 600)) * SineTransform() * STTransform(scale=(0.1, 0.1), translate=(-5, -5)) * base_tr) tr = MatrixTransform() tr.rotate(40, (0, 0, 1)) tr.rotate(30, (1, 0, 0)) tr.translate((0, -20, -60)) p = MatrixTransform() p.set_perspective(0.5, 1, 0.1, 1000) tr = p * tr tr1 = (STTransform(translate=(200, 600)) * tr * STTransform(translate=(-50, -50)) * base_tr) self.images[1].transform = tr1 tr2 = (STTransform(scale=(3, -100), translate=(200, 50)) * LogTransform((0, 2, 0)) * STTransform(scale=(1, -0.01), translate=(-50, 1.1)) * base_tr) self.images[2].transform = tr2 tr3 = (STTransform(scale=(400, 400), translate=(570, 400)) * PolarTransform() * STTransform(scale=(np.pi/150, -0.005), translate=(-3.3*np.pi/4., 0.7)) * base_tr) self.images[3].transform = tr3 text = visuals.TextVisual( text=['logarithmic', 'polar', 'perspective', 'custom (sine)'], pos=[(100, 20), (500, 20), (100, 410), (500, 410)], color='k', font_size=16) self.visuals = self.images + [text] self.show()
class Canvas(app.Canvas): def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 550)) vertices, faces, outline = create_box(width=1, height=1, depth=1, width_segments=4, height_segments=8, depth_segments=16) self.box = visuals.BoxVisual(width=1, height=1, depth=1, width_segments=4, height_segments=8, depth_segments=16, vertex_colors=vertices['color'], edge_color='b') self.theta = 0 self.phi = 0 self.transform = MatrixTransform() self.box.transform = self.transform self.show() self.timer = app.Timer(connect=self.rotate) self.timer.start(0.016) def rotate(self, event): self.theta += .5 self.phi += .5 self.transform.reset() self.transform.rotate(self.theta, (0, 0, 1)) self.transform.rotate(self.phi, (0, 1, 0)) self.transform.scale((100, 100, 0.001)) self.transform.translate((200, 200)) self.update() def on_resize(self, event): # Set canvas viewport and reconfigure visual transforms to match. vp = (0, 0, self.physical_size[0], self.physical_size[1]) self.context.set_viewport(*vp) self.box.transforms.configure(canvas=self, viewport=vp) def on_draw(self, ev): gloo.clear(color='white', depth=True) self.box.draw()
def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 550)) vertices, faces, outline = create_box(width=1, height=1, depth=1, width_segments=4, height_segments=8, depth_segments=16) self.box = visuals.BoxVisual(width=1, height=1, depth=1, width_segments=4, height_segments=8, depth_segments=16, vertex_colors=vertices['color'], edge_color='b') self.theta = 0 self.phi = 0 self.transform = MatrixTransform() self.box.transform = self.transform self.show() self.timer = app.Timer(connect=self.rotate) self.timer.start(0.016)
def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 550)) self.meshes = [] self.rotation = MatrixTransform() # Generate some data to work with global mdata mdata = create_sphere(20, 40, 1.0) # Mesh with pre-indexed vertices, uniform color self.meshes.append(visuals.MeshVisual(meshdata=mdata, color='b')) # Mesh with pre-indexed vertices, per-face color # Because vertices are pre-indexed, we get a different color # every time a vertex is visited, resulting in sharp color # differences between edges. verts = mdata.get_vertices(indexed='faces') nf = verts.size//9 fcolor = np.ones((nf, 3, 4), dtype=np.float32) fcolor[..., 0] = np.linspace(1, 0, nf)[:, np.newaxis] fcolor[..., 1] = np.random.normal(size=nf)[:, np.newaxis] fcolor[..., 2] = np.linspace(0, 1, nf)[:, np.newaxis] mesh = visuals.MeshVisual(vertices=verts, face_colors=fcolor) self.meshes.append(mesh) # Mesh with unindexed vertices, per-vertex color # Because vertices are unindexed, we get the same color # every time a vertex is visited, resulting in no color differences # between edges. verts = mdata.get_vertices() faces = mdata.get_faces() nv = verts.size//3 vcolor = np.ones((nv, 4), dtype=np.float32) vcolor[:, 0] = np.linspace(1, 0, nv) vcolor[:, 1] = np.random.normal(size=nv) vcolor[:, 2] = np.linspace(0, 1, nv) self.meshes.append(visuals.MeshVisual(verts, faces, vcolor)) self.meshes.append(visuals.MeshVisual(verts, faces, vcolor, shading='flat')) self.meshes.append(visuals.MeshVisual(verts, faces, vcolor, shading='smooth')) # Lay out meshes in a grid grid = (3, 3) s = 300. / max(grid) for i, mesh in enumerate(self.meshes): x = 800. * (i % grid[0]) / grid[0] + 400. / grid[0] - 2 y = 800. * (i // grid[1]) / grid[1] + 400. / grid[1] + 2 transform = ChainTransform([STTransform(translate=(x, y), scale=(s, s, s)), self.rotation]) mesh.transform = transform mesh.transforms.scene_transform = STTransform(scale=(1, 1, 0.01)) self.show() self.timer = app.Timer(connect=self.rotate) self.timer.start(0.016)
def __init__(self, h): self.h = h app.Canvas.__init__(self, keys='interactive', size=(800, 550)) hcyl = mplcyl.TruncatedCone() print('1') #plot_tc(p0=np.array([1, 3, 2]), p1=np.array([8, 5, 9]), R=[5.0, 2.0]) verts, edges = h.get_geometry() self.meshes = [] self.rotation = MatrixTransform() sec_ids = [] s = 1.0 x, y = 0., 0. for edge in edges: ends = verts['pos'][edge] # xyz coordinate of one end [x,y,z] dia = verts['dia'][edge] # diameter at that end sec_id = verts['sec_index'][edge[0]] # save the section index dif = ends[1]-ends[0] # distance between the ends length = (dif**2).sum() ** 0.5 # print length # print dia #C, T, B = hcyl.make_truncated_cone(p0=ends[0], p1=ends[1], R=[dia[0]/2., dia[1]/2.]) mesh_verts = create_cylinder(8, 8, radius=[dia[0]/2., dia[1]/2.], length=length, offset=False) #mesh_verts = create_grid_mesh(C[0], C[1], C[2]) # sec_id_array = np.empty(mesh_verts.shape[0]*3, dtype=int) # # sec_id_array[:] = sec_id # meshes.append(mesh_verts) # sec_ids.append(sec_id_array) self.meshes.append(visuals.MeshVisual(meshdata=mesh_verts, color='r')) # transform = ChainTransform([STTransform(translate=(x, y), # scale=(s, s, s)), # self.rotation]) # # for i, mesh in enumerate(self.meshes): # # x = 800. * (i % grid[0]) / grid[0] + 40 # mesh.transform = transform # mesh.transforms.scene_transform = STTransform(scale=(1, 1, 0.01)) gloo.set_viewport(0, 0, *self.physical_size) gloo.clear(color='white', depth=True) for mesh in self.meshes: mesh.draw() print('running') self.show() if sys.flags.interactive != 1: app.run()
class vispy_Cylinders(app.Canvas): """ Input: h: HocReader instance """ def __init__(self, h): self.h = h app.Canvas.__init__(self, keys='interactive', size=(800, 550)) hcyl = mplcyl.TruncatedCone() print('1') #plot_tc(p0=np.array([1, 3, 2]), p1=np.array([8, 5, 9]), R=[5.0, 2.0]) verts, edges = h.get_geometry() self.meshes = [] self.rotation = MatrixTransform() sec_ids = [] s = 1.0 x, y = 0., 0. for edge in edges: ends = verts['pos'][edge] # xyz coordinate of one end [x,y,z] dia = verts['dia'][edge] # diameter at that end sec_id = verts['sec_index'][edge[0]] # save the section index dif = ends[1]-ends[0] # distance between the ends length = (dif**2).sum() ** 0.5 # print length # print dia #C, T, B = hcyl.make_truncated_cone(p0=ends[0], p1=ends[1], R=[dia[0]/2., dia[1]/2.]) mesh_verts = create_cylinder(8, 8, radius=[dia[0]/2., dia[1]/2.], length=length, offset=False) #mesh_verts = create_grid_mesh(C[0], C[1], C[2]) # sec_id_array = np.empty(mesh_verts.shape[0]*3, dtype=int) # # sec_id_array[:] = sec_id # meshes.append(mesh_verts) # sec_ids.append(sec_id_array) self.meshes.append(visuals.MeshVisual(meshdata=mesh_verts, color='r')) # transform = ChainTransform([STTransform(translate=(x, y), # scale=(s, s, s)), # self.rotation]) # # for i, mesh in enumerate(self.meshes): # # x = 800. * (i % grid[0]) / grid[0] + 40 # mesh.transform = transform # mesh.transforms.scene_transform = STTransform(scale=(1, 1, 0.01)) gloo.set_viewport(0, 0, *self.physical_size) gloo.clear(color='white', depth=True) for mesh in self.meshes: mesh.draw() print('running') self.show() if sys.flags.interactive != 1: app.run() #exit(1) def rotate(self, event): # rotate with an irrational amount over each axis so there is no # periodicity self.rotation.rotate(0.2 ** 0.5, (1, 0, 0)) self.rotation.rotate(0.3 ** 0.5, (0, 1, 0)) self.rotation.rotate(0.5 ** 0.5, (0, 0, 1)) self.update() def on_resize(self, event): # Set canvas viewport and reconfigure visual transforms to match. vp = (0, 0, self.physical_size[0], self.physical_size[1]) self.context.set_viewport(*vp) for mesh in self.meshes: mesh.transforms.configure(canvas=self, viewport=vp) def on_draw(self, ev): gloo.set_viewport(0, 0, *self.physical_size) gloo.clear(color='black', depth=True) for mesh in self.meshes: mesh.draw()
'D:\\Databases\\toy_db\\db_mne\\meg_causal\\subject_02\\src\\subject_02_cortical' ) rr = src[0]['rr'] fname_mesh = op.join(db_bv, 'hiphop138-multiscale', 'Decimated', '4K', 'hiphop138_Lwhite_dec_4K_parcels_marsAtlas.gii') giftiImage = gifti.giftiio.read(fname_mesh) values = giftiImage.darrays[0].data parcels, counts = np.unique(values, return_counts=True) trans = mne.read_trans( 'D:\\Databases\\toy_db\\db_mne\\meg_causal\\subject_02\\trans\\subject_02-trans.fif' ) trans = trans['trans'] mt = MatrixTransform(trans) rr = mt.map(rr * 1000)[:, 0:-1] cmap = np.zeros(rr.shape) col = np.vstack((np.linspace(1, 0, len(parcels)), np.linspace(0, 1, len(parcels)), np.roll(np.linspace(1, 0, len(parcels)), 21))).T for p in parcels: cmap[values == p] = col[parcels == p] se = SceneObj(bgcolor='black') brain = BrainObj( 'D:\\Databases\\toy_db\\db_mne\\meg_causal\\subject_02\\surf\\subject_02_Lwhite.gii' ) src = SourceObj('coords', rr, color=cmap) se.add_to_subplot(brain)
class Canvas(app.Canvas): def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 550)) self.meshes = [] self.rotation = MatrixTransform() # Generate some data to work with global mdata mdata = create_sphere(20, 40, 1.0) # Mesh with pre-indexed vertices, uniform color self.meshes.append(visuals.MeshVisual(meshdata=mdata, color='b')) # Mesh with pre-indexed vertices, per-face color # Because vertices are pre-indexed, we get a different color # every time a vertex is visited, resulting in sharp color # differences between edges. verts = mdata.get_vertices(indexed='faces') nf = verts.size//9 fcolor = np.ones((nf, 3, 4), dtype=np.float32) fcolor[..., 0] = np.linspace(1, 0, nf)[:, np.newaxis] fcolor[..., 1] = np.random.normal(size=nf)[:, np.newaxis] fcolor[..., 2] = np.linspace(0, 1, nf)[:, np.newaxis] mesh = visuals.MeshVisual(vertices=verts, face_colors=fcolor) self.meshes.append(mesh) # Mesh with unindexed vertices, per-vertex color # Because vertices are unindexed, we get the same color # every time a vertex is visited, resulting in no color differences # between edges. verts = mdata.get_vertices() faces = mdata.get_faces() nv = verts.size//3 vcolor = np.ones((nv, 4), dtype=np.float32) vcolor[:, 0] = np.linspace(1, 0, nv) vcolor[:, 1] = np.random.normal(size=nv) vcolor[:, 2] = np.linspace(0, 1, nv) self.meshes.append(visuals.MeshVisual(verts, faces, vcolor)) self.meshes.append(visuals.MeshVisual(verts, faces, vcolor, shading='flat')) self.meshes.append(visuals.MeshVisual(verts, faces, vcolor, shading='smooth')) # Lay out meshes in a grid grid = (3, 3) s = 300. / max(grid) for i, mesh in enumerate(self.meshes): x = 800. * (i % grid[0]) / grid[0] + 400. / grid[0] - 2 y = 800. * (i // grid[1]) / grid[1] + 400. / grid[1] + 2 transform = ChainTransform([STTransform(translate=(x, y), scale=(s, s, s)), self.rotation]) mesh.transform = transform mesh.transforms.scene_transform = STTransform(scale=(1, 1, 0.01)) self.show() self.timer = app.Timer(connect=self.rotate) self.timer.start(0.016) def rotate(self, event): # rotate with an irrational amount over each axis so there is no # periodicity self.rotation.rotate(0.2 ** 0.5, (1, 0, 0)) self.rotation.rotate(0.3 ** 0.5, (0, 1, 0)) self.rotation.rotate(0.5 ** 0.5, (0, 0, 1)) self.update() def on_resize(self, event): # Set canvas viewport and reconfigure visual transforms to match. vp = (0, 0, self.physical_size[0], self.physical_size[1]) self.context.set_viewport(*vp) for mesh in self.meshes: mesh.transforms.configure(canvas=self, viewport=vp) def on_draw(self, ev): gloo.set_viewport(0, 0, *self.physical_size) gloo.clear(color='black', depth=True) for mesh in self.meshes: mesh.draw()
from playground.utils import rgb2gray from vispy.visuals.transforms import MatrixTransform from vispy.io.mesh import read_mesh filename = './constraint_cue.obj' canvas = scene.SceneCanvas(keys='interactive') view = canvas.central_widget.add_view() (vertices, faces, vertex_colors, _) = read_mesh(filename) vertex_colors = rgb2gray(vertex_colors) print(vertex_colors) # color = np.zeros((ys.shape[0], 4)) * np.array([0,1,1,1]) N = vertex_colors.shape[0] mesh = scene.visuals.Mesh(vertices, faces, vertex_colors, shading=None) view.camera = 'turntable' maze_scale_factor = 100 transform = MatrixTransform() transform.scale(scale=[100,100,100,100]) # transform.translate(pos=[8100.4286, 8000]) mesh.transform = transform view.add(mesh) canvas.show() if __name__ == '__main__': canvas.app.run()
def _niimg_rot(): """Get rotation trnasformations of each slice.""" # Sagittal sg_rot = MatrixTransform() sg_rot.rotate(90., (0, 0, 1)) sg_rot.rotate(180., (0, 1, 0)) # Coronal cr_rot = MatrixTransform() cr_rot.rotate(90., (0, 0, 1)) cr_rot.rotate(180., (0, 1, 0)) # Axial ax_rot = MatrixTransform() ax_rot.rotate(180., (1, 0, 0)) return sg_rot, cr_rot, ax_rot
def test_multiprogram(): vert = """ uniform float u_scale; void main() { gl_Position = $transform(vec4(0, 0, 0, 0)); } """ frag = """ void main() { gl_FragColor = $color; $post_hook } """ # test adding programs mp = MultiProgram(vert, frag) p1 = mp.add_program() p2 = mp.add_program('p2') assert 'p2' in mp._programs # test weak reference to program mp.add_program('junk') assert 'junk' not in mp._programs and len(mp._programs) == 2 # test setting variables on multiprogram or individual programs mp['u_scale'] = 2 assert p1['u_scale'] == 2 assert p2['u_scale'] == 2 p1['u_scale'] = 3 assert p1['u_scale'] == 3 assert p2['u_scale'] == 2 # test setting template variables globally mp.frag['color'] = (1, 1, 1, 1) assert p1.frag['color'].value == (1, 1, 1, 1) assert p2.frag['color'].value == (1, 1, 1, 1) # test setting template variables per-program func = Function(""" void filter() { gl_FragColor.r = 0.5; } """) p1.frag['post_hook'] = StatementList() p2.frag['post_hook'] = StatementList() p2.frag['post_hook'].add(func()) tr1 = STTransform() tr2 = MatrixTransform() p1.vert['transform'] = tr1 p2.vert['transform'] = tr2 assert 'st_transform_map' in p1.vert.compile() assert 'affine_transform_map' in p2.vert.compile() assert 'filter' not in p1.frag.compile() assert 'filter' in p2.frag.compile() # test changing shader code mp.vert = vert + '\n//test\n' mp.vert['transform'] = tr1 assert '//test' in p1.vert.compile() # test that newly-added programs inherit all previously set variables p3 = mp.add_program() assert p3['u_scale'] == 2 assert p3.frag['color'].value == (1, 1, 1, 1) assert '//test' in p3.vert.compile() assert 'st_transform_map' in p3.vert.compile()
def close(self): """Vispy visual is closing.""" disconnect_events(self.layer.events, self) self.node.transforms = MatrixTransform() self.node.parent = None
#print(bodyT) #ok #print(jointT) #ok verts, faces, normals, nothin = io.read_mesh(objPath+obj) #verts preserve the number of vertex but the order is not preserved verts*=0.01 vertexMod = scaleMatDict[name] @ np.vstack([verts.transpose(),np.ones([1,verts.shape[0]])]) #(4,n) verts = vertexMod[:3,:].transpose() objMesh = scene.visuals.Mesh(parent=view.scene,vertices=verts, shading='flat', faces=faces,color=(0.8, 0.8, 0.8,0.2)) #'flat' is much faster than 'smooth', None removes lighting objMesh.set_gl_state('translucent', cull_face=False,depth_test=False) aBox=scene.visuals.Box(parent=view.scene,width=size[0],depth=size[1],height=size[2],color=(0.8,0.1,0.1,0.2)) aBox.transform=MatrixTransform(bodyT.transpose()) #transpose to match openGL format aBox.set_gl_state('translucent', cull_face=False,depth_test=False) #if(obj in markerDict): # v=trimesh.load(objPath+obj, process=False).vertices #use this library because it preserve the order of vertex # v*=0.01 # for tup in markerDict[obj]: # vertexIndex,markerName=tup #markerDict[obj][i] # markerPosition.append(v[vertexIndex,:]) # print(obj,markerName,vertexIndex,v[vertexIndex,:]) #else: # print(obj) humanJointPositionList=np.stack(humanJointPositionList)
class Canvas(app.Canvas): def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 550)) self.meshes = [] self.rotation = MatrixTransform() # Generate some data to work with global mdata mdata = create_sphere(20, 40, 1.0) verts = mdata.get_vertices() faces = mdata.get_faces() gamma, phi = xyz_to_gp(verts) data = np.cos(5*gamma)+np.cos(phi*4)/2. mesh = visuals.MeshVisual(vertices=verts, faces=faces, banded=False, nband=8, vertex_values=data) mesh.cmap = 'viridis' self.meshes.append(mesh) mesh = visuals.MeshVisual(vertices=verts, faces=faces, banded=True, nband=8, vertex_values=data) mesh.cmap = 'viridis' self.meshes.append(mesh) mesh = visuals.MeshVisual(vertices=verts, faces=faces, banded=False, nband=8, vertex_values=data, shading='flat') mesh.cmap = 'viridis' self.meshes.append(mesh) mesh = visuals.MeshVisual(vertices=verts, faces=faces, banded=True, nband=8, vertex_values=data, shading='flat') mesh.cmap = 'viridis' self.meshes.append(mesh) mesh = visuals.MeshVisual(vertices=verts, faces=faces, banded=False, nband=8, vertex_values=data, shading='smooth') mesh.cmap = 'viridis' mesh.shininess = 0.01 self.meshes.append(mesh) # Mesh with color indexed into a colormap mesh = visuals.MeshVisual(vertices=verts, faces=faces, banded=True, nband=8, vertex_values=data, shading='smooth') mesh.cmap = 'viridis' mesh.shininess = 0.01 self.meshes.append(mesh) # Lay out meshes in a grid grid = (3, 3) s = 300. / max(grid) for i, mesh in enumerate(self.meshes): x = 800. * (i % grid[0]) / grid[0] + 400. / grid[0] - 2 y = 800. * (i // grid[1]) / grid[1] + 400. / grid[1] + 2 transform = ChainTransform([STTransform(translate=(x, y), scale=(s, s, s)), self.rotation]) mesh.transform = transform mesh.transforms.scene_transform = STTransform(scale=(1, 1, 0.01)) self.show() self.timer = app.Timer(connect=self.rotate) self.timer.start(0.016) def rotate(self, event): # rotate with an irrational amount over each axis so there is no # periodicity self.rotation.rotate(0.2 ** 0.5, (1, 0, 0)) self.rotation.rotate(0.3 ** 0.5, (0, 1, 0)) self.rotation.rotate(0.5 ** 0.5, (0, 0, 1)) self.update() def on_resize(self, event): # Set canvas viewport and reconfigure visual transforms to match. vp = (0, 0, self.physical_size[0], self.physical_size[1]) self.context.set_viewport(*vp) for mesh in self.meshes: mesh.transforms.configure(canvas=self, viewport=vp) def on_draw(self, ev): gloo.set_viewport(0, 0, *self.physical_size) gloo.clear(color='black', depth=True) for mesh in self.meshes: mesh.draw()
def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 550)) self.meshes = [] self.rotation = MatrixTransform() # Generate some data to work with global mdata mdata = create_sphere(20, 40, 1.0) # Mesh with pre-indexed vertices, uniform color self.meshes.append(visuals.MeshVisual(meshdata=mdata, color='b')) # Mesh with pre-indexed vertices, per-face color # Because vertices are pre-indexed, we get a different color # every time a vertex is visited, resulting in sharp color # differences between edges. rng = np.random.RandomState(0) verts = mdata.get_vertices(indexed='faces') nf = verts.size//9 fcolor = np.ones((nf, 3, 4), dtype=np.float32) fcolor[..., 0] = np.linspace(1, 0, nf)[:, np.newaxis] fcolor[..., 1] = rng.randn(nf, 1) fcolor[..., 2] = np.linspace(0, 1, nf)[:, np.newaxis] mesh = visuals.MeshVisual(vertices=verts, face_colors=fcolor) self.meshes.append(mesh) # Mesh with unindexed vertices, per-vertex color # Because vertices are unindexed, we get the same color # every time a vertex is visited, resulting in no color differences # between edges. verts = mdata.get_vertices() faces = mdata.get_faces() nv = verts.size//3 vcolor = np.ones((nv, 4), dtype=np.float32) vcolor[:, 0] = np.linspace(1, 0, nv) vcolor[:, 1] = rng.randn(nv) vcolor[:, 2] = np.linspace(0, 1, nv) self.meshes.append(visuals.MeshVisual(verts, faces, vcolor)) self.meshes.append(visuals.MeshVisual(verts, faces, vcolor, shading='flat')) self.meshes.append(visuals.MeshVisual(verts, faces, vcolor, shading='smooth')) # Mesh with color indexed into a colormap verts = mdata.get_vertices(None) faces = mdata.get_faces() values = rng.randn(len(verts)) mesh = visuals.MeshVisual(vertices=verts, faces=faces, vertex_values=values, shading='smooth') mesh.clim = [-1, 1] mesh.cmap = 'viridis' mesh.shininess = 0.01 self.meshes.append(mesh) # Lay out meshes in a grid grid = (3, 3) s = 300. / max(grid) for i, mesh in enumerate(self.meshes): x = 800. * (i % grid[0]) / grid[0] + 400. / grid[0] - 2 y = 800. * (i // grid[1]) / grid[1] + 400. / grid[1] + 2 transform = ChainTransform([STTransform(translate=(x, y), scale=(s, s, s)), self.rotation]) mesh.transform = transform mesh.transforms.scene_transform = STTransform(scale=(1, 1, 0.01)) self.show() self.timer = app.Timer(connect=self.rotate) self.timer.start(0.016)
class Canvas(app.Canvas): def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 550)) self.meshes = [] self.rotation = MatrixTransform() # Generate some data to work with global mdata mdata = create_sphere(20, 40, 1.0) # Mesh with pre-indexed vertices, uniform color self.meshes.append(visuals.MeshVisual(meshdata=mdata, color='b')) # Mesh with pre-indexed vertices, per-face color # Because vertices are pre-indexed, we get a different color # every time a vertex is visited, resulting in sharp color # differences between edges. rng = np.random.RandomState(0) verts = mdata.get_vertices(indexed='faces') nf = verts.size//9 fcolor = np.ones((nf, 3, 4), dtype=np.float32) fcolor[..., 0] = np.linspace(1, 0, nf)[:, np.newaxis] fcolor[..., 1] = rng.randn(nf, 1) fcolor[..., 2] = np.linspace(0, 1, nf)[:, np.newaxis] mesh = visuals.MeshVisual(vertices=verts, face_colors=fcolor) self.meshes.append(mesh) # Mesh with unindexed vertices, per-vertex color # Because vertices are unindexed, we get the same color # every time a vertex is visited, resulting in no color differences # between edges. verts = mdata.get_vertices() faces = mdata.get_faces() nv = verts.size//3 vcolor = np.ones((nv, 4), dtype=np.float32) vcolor[:, 0] = np.linspace(1, 0, nv) vcolor[:, 1] = rng.randn(nv) vcolor[:, 2] = np.linspace(0, 1, nv) self.meshes.append(visuals.MeshVisual(verts, faces, vcolor)) self.meshes.append(visuals.MeshVisual(verts, faces, vcolor, shading='flat')) self.meshes.append(visuals.MeshVisual(verts, faces, vcolor, shading='smooth')) # Mesh with color indexed into a colormap verts = mdata.get_vertices(None) faces = mdata.get_faces() values = rng.randn(len(verts)) mesh = visuals.MeshVisual(vertices=verts, faces=faces, vertex_values=values, shading='smooth') mesh.clim = [-1, 1] mesh.cmap = 'viridis' mesh.shininess = 0.01 self.meshes.append(mesh) # Lay out meshes in a grid grid = (3, 3) s = 300. / max(grid) for i, mesh in enumerate(self.meshes): x = 800. * (i % grid[0]) / grid[0] + 400. / grid[0] - 2 y = 800. * (i // grid[1]) / grid[1] + 400. / grid[1] + 2 transform = ChainTransform([STTransform(translate=(x, y), scale=(s, s, s)), self.rotation]) mesh.transform = transform mesh.transforms.scene_transform = STTransform(scale=(1, 1, 0.01)) self.show() self.timer = app.Timer(connect=self.rotate) self.timer.start(0.016) def rotate(self, event): # rotate with an irrational amount over each axis so there is no # periodicity self.rotation.rotate(0.2 ** 0.5, (1, 0, 0)) self.rotation.rotate(0.3 ** 0.5, (0, 1, 0)) self.rotation.rotate(0.5 ** 0.5, (0, 0, 1)) self.update() def on_resize(self, event): # Set canvas viewport and reconfigure visual transforms to match. vp = (0, 0, self.physical_size[0], self.physical_size[1]) self.context.set_viewport(*vp) for mesh in self.meshes: mesh.transforms.configure(canvas=self, viewport=vp) def on_draw(self, ev): gloo.set_viewport(0, 0, *self.physical_size) gloo.clear(color='black', depth=True) for mesh in self.meshes: mesh.draw()
def __init__(self, image_funcs, axis='z', pos=0, limit=None, seismic_coord_system=True, cmaps=['grays'], clims=None, interpolation='nearest', method='auto'): assert clims is not None, 'clim must be specified explicitly.' # Create an Image obj and unfreeze it so we can add more # attributes inside. # First image (from image_funcs[0]) scene.visuals.Image.__init__(self, parent=None, # no image func yet cmap=cmaps[0], clim=clims[0], interpolation=interpolation, method=method) self.unfreeze() self.interactive = True # Other images ... self.overlaid_images = [self] for i_img in range(1, len(image_funcs)): overlaid_image = scene.visuals.Image(parent=self, cmap=cmaps[i_img], clim=clims[i_img], interpolation=interpolation, method=method) self.overlaid_images.append(overlaid_image) # Set GL state. Must check depth test, otherwise weird in 3D. self.set_gl_state(depth_test=True, depth_func='lequal', blend_func=('src_alpha', 'one_minus_src_alpha')) # Determine the axis and position of this plane. self.axis = axis # Check if pos is within the range. if limit is not None: assert (pos>=limit[0]) and (pos<=limit[1]), \ 'pos={} is outside limit={} range.'.format(pos, limit) self.pos = pos self.limit = limit self.seismic_coord_system = seismic_coord_system # Get the image_func that returns either image or image shape. self.image_funcs = image_funcs # a list of functions! shape = self.image_funcs[0](self.pos, get_shape=True) # The selection highlight (a Plane visual with transparent color). # The plane is initialized before any rotation, on '+z' direction. self.highlight = scene.visuals.Plane(parent=self, width=shape[0], height=shape[1], direction='+z', color=(1, 1, 0, 0.1)) # transparent yellow color # Move the plane to align with the image. self.highlight.transform = STTransform( translate=(shape[0]/2, shape[1]/2, 0)) # This is to make sure we can see highlight plane through the images. self.highlight.set_gl_state('additive', depth_test=True) self.highlight.visible = False # only show when selected # Set the anchor point (2D local world coordinates). The mouse will # drag this image by anchor point moving in the normal direction. self.anchor = None # None by default self.offset = 0 # Apply SRT transform according to the axis attribute. self.transform = MatrixTransform() # Move the image plane to the corresponding location. self._update_location() self.freeze()
class AxisAlignedImage(scene.visuals.Image): """ Visual subclass displaying an image that aligns to an axis. This image should be able to move along the perpendicular direction when user gives corresponding inputs. Parameters: """ def __init__(self, image_funcs, axis='z', pos=0, limit=None, seismic_coord_system=True, cmaps=['grays'], clims=None, interpolation='nearest', method='auto'): assert clims is not None, 'clim must be specified explicitly.' # Create an Image obj and unfreeze it so we can add more # attributes inside. # First image (from image_funcs[0]) scene.visuals.Image.__init__(self, parent=None, # no image func yet cmap=cmaps[0], clim=clims[0], interpolation=interpolation, method=method) self.unfreeze() self.interactive = True # Other images ... self.overlaid_images = [self] for i_img in range(1, len(image_funcs)): overlaid_image = scene.visuals.Image(parent=self, cmap=cmaps[i_img], clim=clims[i_img], interpolation=interpolation, method=method) self.overlaid_images.append(overlaid_image) # Set GL state. Must check depth test, otherwise weird in 3D. self.set_gl_state(depth_test=True, depth_func='lequal', blend_func=('src_alpha', 'one_minus_src_alpha')) # Determine the axis and position of this plane. self.axis = axis # Check if pos is within the range. if limit is not None: assert (pos>=limit[0]) and (pos<=limit[1]), \ 'pos={} is outside limit={} range.'.format(pos, limit) self.pos = pos self.limit = limit self.seismic_coord_system = seismic_coord_system # Get the image_func that returns either image or image shape. self.image_funcs = image_funcs # a list of functions! shape = self.image_funcs[0](self.pos, get_shape=True) # The selection highlight (a Plane visual with transparent color). # The plane is initialized before any rotation, on '+z' direction. self.highlight = scene.visuals.Plane(parent=self, width=shape[0], height=shape[1], direction='+z', color=(1, 1, 0, 0.1)) # transparent yellow color # Move the plane to align with the image. self.highlight.transform = STTransform( translate=(shape[0]/2, shape[1]/2, 0)) # This is to make sure we can see highlight plane through the images. self.highlight.set_gl_state('additive', depth_test=True) self.highlight.visible = False # only show when selected # Set the anchor point (2D local world coordinates). The mouse will # drag this image by anchor point moving in the normal direction. self.anchor = None # None by default self.offset = 0 # Apply SRT transform according to the axis attribute. self.transform = MatrixTransform() # Move the image plane to the corresponding location. self._update_location() self.freeze() @property def axis(self): """The dimension that this image is perpendicular aligned to.""" return self._axis @axis.setter def axis(self, value): value = value.lower() if value not in ('z', 'y', 'x'): raise ValueError('Invalid value for axis.') self._axis = value def set_anchor(self, mouse_press_event): """ Set an anchor point (2D coordinate on the image plane) when left click in the selection mode (<Ctrl> pressed). After that, the dragging called in func 'drag_visual_node' will try to move along the normal direction and let the anchor follows user's mouse position as close as possible. """ # Get the screen-to-local transform to get camera coordinates. tr = self.canvas.scene.node_transform(self) # Get click (camera) coordinate in the local world. click_pos = tr.map([*mouse_press_event.pos, 0, 1]) click_pos /= click_pos[3] # rescale to cancel out the pos.w factor # Get the view direction (camera-to-target) vector in the local world. view_vector = tr.map([*mouse_press_event.pos, 1, 1])[:3] view_vector /= np.linalg.norm(view_vector) # normalize to unit vector # Get distance from camera to the drag anchor point on the image plane. # Eq 1: click_pos + distance * view_vector = anchor # Eq 2: anchor[2] = 0 <- intersects with the plane # The following equation can be derived by Eq 1 and Eq 2. distance = (0. - click_pos[2]) / view_vector[2] self.anchor = click_pos[:2] + distance * view_vector[:2] # only need vec2 def drag_visual_node(self, mouse_move_event): """ Drag this visual node while holding left click in the selection mode (<Ctrl> pressed). The plane will move in the normal direction perpendicular to this image, and the anchor point (set with func 'set_anchor') will move along the normal direction to stay as close to the mouse as possible, so that user feels like 'dragging' the plane. """ # Get the screen-to-local transform to get camera coordinates. tr = self.canvas.scene.node_transform(self) # Unlike in 'set_anchor', we now convert most coordinates to the screen # coordinate system, because it's more intuitive for user to do operations # in 2D and get 2D feedbacks, e.g. mouse leading the anchor point. anchor = [*self.anchor, self.pos, 1] # 2D -> 3D anchor_screen = tr.imap(anchor) # screen coordinates of the anchor point anchor_screen /= anchor_screen[3] # rescale to cancel out 'w' term anchor_screen = anchor_screen[:2] # only need vec2 # Compute the normal vector, starting from the anchor point and # perpendicular to the image plane. normal = [*self.anchor, self.pos+1, 1] # +[0,0,1,0] from anchor normal_screen = tr.imap(normal) # screen coordinates of anchor + [0,0,1,0] normal_screen /= normal_screen[3] # rescale to cancel out 'w' term normal_screen = normal_screen[:2] # only need vec2 normal_screen -= anchor_screen # end - start = vector normal_screen /= np.linalg.norm(normal_screen) # normalize to unit vector # Use the vector {anchor_screen -> mouse.pos} and project to the # normal_screen direction using dot product, we can get how far the plane # should be moved (on the screen!). drag_vector = mouse_move_event.pos[:2] - anchor_screen drag = np.dot(drag_vector, normal_screen) # normal_screen must be length 1 # We now need to convert the move distance from screen coordinates to # local world coordinates. First, find where the anchor is on the screen # after dragging; then, convert that screen point to a local line shooting # across the normal vector; finally, find where the line comes directly # above/below the anchor point (before dragging) and get that distance as # the true dragging distance in local coordinates. new_anchor_screen = anchor_screen + normal_screen * drag new_anchor = tr.map([*new_anchor_screen, 0, 1]) new_anchor /= new_anchor[3] # rescale to cancel out the pos.w factor view_vector = tr.map([*new_anchor_screen, 1, 1])[:3] view_vector /= np.linalg.norm(view_vector) # normalize to unit vector # Solve this equation: # new_anchor := new_anchor + view_vector * ?, # ^^^ describe a 3D line of possible new anchor positions # arg min (?) |new_anchor[:2] - anchor[:2]| # ^^^ find a point on that 3D line that minimize the 2D distance between # new_anchor and anchor. numerator = anchor[:2] - new_anchor[:2] numerator *= view_vector[:2] # element-wise multiplication numerator = np.sum(numerator) denominator = view_vector[0]**2 + view_vector[1]**2 shoot_distance = numerator / denominator # Shoot from new_anchor to get the new intersect point. The z- coordinate # of this point will be our dragging offset. offset = new_anchor[2] + view_vector[2] * shoot_distance # Note: must reverse normal direction from -y direction to +y! if self.axis == 'y': offset = -offset # Limit the dragging within range. if self.limit is not None: if self.pos + offset < self.limit[0]: offset = self.limit[0] - self.pos if self.pos + offset > self.limit[1]: offset = self.limit[1] - self.pos self.offset = offset # Note: must reverse normal direction from +y direction to -y! if self.axis == 'y': offset = -offset self._update_location() def _update_location(self): """ Update the image plane to the dragged location and redraw this image. """ self.pos += self.offset self.pos = int(np.round(self.pos)) # must round to nearest integer location # Update the transformation in order to move to new location. self.transform.reset() if self.axis == 'z': # 1. No rotation to do for z axis (y-x) slice. Only translate. self.transform.translate((0, 0, self.pos)) elif self.axis == 'y': # 2. Rotation(s) for the y axis (z-x) slice, then translate: self.transform.rotate(90, (1, 0, 0)) self.transform.translate((0, self.pos, 0)) elif self.axis == 'x': # 3. Rotation(s) for the x axis (z-y) slice, then translate: self.transform.rotate(90, (1, 0, 0)) self.transform.rotate(90, (0, 0, 1)) self.transform.translate((self.pos, 0, 0)) # Update image on the slice based on current position. The numpy array # is transposed due to a conversion from i-j to x-y axis system. # First image, the primary one: self.set_data(self.image_funcs[0](self.pos).T) # Other images, overlaid on the primary image: for i_img in range(1, len(self.image_funcs)): self.overlaid_images[i_img].set_data( self.image_funcs[i_img](self.pos).T) # Reset attributes after dragging completes. self.offset = 0 self._bounds_changed() # update the bounds with new self.pos def _compute_bounds(self, axis_3d, view): """ Overwrite the original 2D bounds of the Image class. This will correct the automatic range setting for the camera in the scene canvas. In the original Image class, the code assumes that the image always lies in x-y plane; here we generalize that to x-z and y-z plane. Parameters: axis_3d: int in {0, 1, 2}, represents the axis in 3D view box. view: the ViewBox object that connects to the parent. The function returns a tuple (low_bounds, high_bounds) that represents the spatial limits of self obj in the 3D scene. """ # Note: self.size[0] is slow dim size, self.size[1] is fast dim size. if self.axis == 'z': if axis_3d==0: return (0, self.size[0]) elif axis_3d==1: return (0, self.size[1]) elif axis_3d==2: return (self.pos, self.pos) elif self.axis == 'y': if axis_3d==0: return (0, self.size[0]) elif axis_3d==1: return (self.pos, self.pos) elif axis_3d==2: return (0, self.size[1]) elif self.axis == 'x': if axis_3d==0: return (self.pos, self.pos) elif axis_3d==1: return (0, self.size[0]) elif axis_3d==2: return (0, self.size[1])
def trafo(self,x=0.,y=0.,z=0.,angle=0.,al=0.,be=0.,ga=0.): #Not Working self.transform = MatrixTransform() self.transform = self.transform.rotate(angle,[al,be,ga]) self.transform = self.transform.translate([x,y,z])
def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 600)) brain = np.load(load_data_file('brain/brain.npz', force_download='2014-09-04')) #brain1 = scipy.io.loadmat('NewBESATri.mat') brain2 = brain1['t'] from numpy import genfromtxt my_data = genfromtxt('BESACOORD61.csv', delimiter=',') dataTest = brain['vertex_buffer'] color = dataTest['a_color'] color = color[750:1500] facesTest = brain['index_buffer'] n = 750 ps = 100 data = np.zeros(n, [('a_position', np.float32, 3), ('a_normal', np.float32, 3), ('a_color', np.float32, 3)]) #('a_size', np.float32, 1)]) import scipy.spatial tri = scipy.spatial.Delaunay(my_data) # points: np.array() of 3d points convex = tri.convex_hull indices = tri.simplices vertices = my_data[indices] data['a_position'] = my_data data['a_color'] = np.random.uniform(0, 1, (n, 3)) faces = brain2 faces = faces-1 vertices = my_data norm = np.zeros( vertices.shape, dtype=vertices.dtype ) #Create an indexed view into the vertex array using the array of three indices for triangles tris = vertices[faces] #Calculate the normal for all the triangles, by taking the cross product of the vectors v1-v0, and v2-v0 in each triangle n = np.cross( tris[::,1 ] - tris[::,0] , tris[::,2 ] - tris[::,0] ) # n is now an array of normals per triangle. The length of each normal is dependent the vertices, # we need to normalize these, so that our next step weights each normal equally. lens = np.sqrt( n[:,0]**2 + n[:,1]**2 + n[:,2]**2 ) n[:,0] /= lens n[:,1] /= lens n[:,2] /= lens norm[ faces[:,0] ] += n norm[ faces[:,1] ] += n norm[ faces[:,2] ] += n ''' Normalize a numpy array of 3 component vectors shape=(n,3) ''' lens = np.sqrt( norm[:,0]**2 + norm[:,1]**2 + norm[:,2]**2 ) norm[:,0] /= lens norm[:,1] /= lens norm[:,2] /= lens data['a_normal'] = norm #np.random.uniform(0, 1.0, (n, 3)) #10, 3, 3 #data['a_size'] = np.random.uniform(5*ps, 10*ps, n) u_linewidth = 1.0 u_antialias = 1.0 brain2 = np.uint32(brain2) convex = np.uint32(convex) data = data faces = brain2-1 #data = dataTest #faces = facesTest self.meshes = [] self.rotation = MatrixTransform() # Generate some data to work with global mdata mdata = create_sphere(20, 40, 1.0) #mdata['_faces'] =faces #mdata['_vertices']=data # Mesh with pre-indexed vertices, uniform color meshData=vispy.geometry.MeshData(vertices=data['a_position'], faces=None, edges=None, vertex_colors=None, face_colors=None) meshData._vertices = data['a_position'] meshData._faces = faces #meshData._face_colors = data['a_color'] #meshData._vertex_colors = data['a_color'] self.meshes.append(visuals.MeshVisual(meshdata=meshData, color='b')) #for mesh in self.meshes: # mesh.draw() # Mesh with pre-indexed vertices, per-face color # Because vertices are pre-indexed, we get a different color # every time a vertex is visited, resulting in sharp color # differences between edges. tris = vertices[faces] verts = data['a_position'] #mdata.get_vertices(indexed='faces') nf = 1496#verts.size//9 fcolor = np.ones((nf, 3, 4), dtype=np.float32) fcolor[..., 0] = np.linspace(1, 0, nf)[:, np.newaxis] fcolor[..., 1] = np.random.normal(size=nf)[:, np.newaxis] fcolor[..., 2] = np.linspace(0, 1, nf)[:, np.newaxis] #fcolor = data['a_color'] mesh = visuals.MeshVisual(vertices=tris, face_colors=fcolor) self.meshes.append(mesh) # Mesh with unindexed vertices, per-vertex color # Because vertices are unindexed, we get the same color # every time a vertex is visited, resulting in no color differences # between edges. #verts = mdata.get_vertices() faces = faces #mdata.get_faces() nv = verts.size//3 vcolor = np.ones((nv, 4), dtype=np.float32) vcolor[:, 0] = np.linspace(.6, .6, nv) vcolor[:, 1] = np.random.normal(size=nv) vcolor[:, 2] = np.linspace(0.6, .6, nv) self.meshes.append(visuals.MeshVisual(verts, faces, vcolor)) self.meshes.append(visuals.MeshVisual(verts, faces, vcolor, shading='flat')) # self.meshes.append(visuals.MeshVisual(verts, faces, vcolor, shading='smooth')) # Lay out meshes in a grid grid = (1, 1) s = 300. / max(grid) #s = 500 for i, mesh in enumerate(self.meshes): x = 800. * (i % grid[0]) / grid[0] / grid[0] - 2 y = 800. * (i // grid[1]) / grid[1] / grid[1] + 2 transform = ChainTransform([STTransform(translate=(x, y), scale=(s, s, s)), self.rotation]) mesh.transform = transform mesh.transforms.scene_transform = STTransform(scale=(.01, .01, .00001)) self.show() self.timer = app.Timer(connect=self.rotate) self.timer.start(0.00016)
class Colorbar(scene.visuals.Image): """ A colorbar visual fixed to the right side of the canvas. This is based on the rendering from Matplotlib, then display this rendered image as a scene.visuals.Image visual node on the canvas. Parameters: """ def __init__(self, size=(500, 10), cmap='grays', clim=None, label_str="Colorbar", label_color='black', label_size=12, tick_size=10, border_width=1.0, border_color='black', visible=True, parent=None): assert clim is not None, 'clim must be specified explicitly.' # Create a scene.visuals.Image (without parent by default). scene.visuals.Image.__init__(self, parent=None, interpolation='nearest', method='auto') self.unfreeze() self.visible = visible self.canvas_size = None # will be set when parent is linked # Record the important drawing parameters. self.pos = (0, 0) self.bar_size = size # tuple self.cmap = get_colormap(cmap) # vispy Colormap self.clim = clim # tuple # Record the styling parameters. self.label_str = label_str self.label_color = label_color self.label_size = label_size self.tick_size = tick_size self.border_width = border_width self.border_color = border_color # Draw colorbar using Matplotlib. self.set_data(self._draw_colorbar()) # Give a Matrix transform to self in order to move around canvas. self.transform = MatrixTransform() self.freeze() def on_resize(self, event): """ When window is resized, only need to move the position in vertical direction, because the coordinate is relative to the secondary ViewBox that stays on the right side of the canvas. """ pos = np.array(self.pos).astype(np.single) pos[1] *= event.size[1] / self.canvas_size[1] self.pos = tuple(pos) # Move the colorbar to specified position (with half-size padding, because # Image visual uses a different anchor (top-left corner) rather than the # center-left corner used by ColorBar visual.). self.transform.reset() self.transform.translate(( self.pos[0] / 2.618, # make the gap smaller :) self.pos[1] - self.size[1] / 2.)) # Update the canvas size. self.canvas_size = event.size def _draw_colorbar(self): """ Draw a Matplotlib colorbar, save this figure without any boundary to a rendering buffer, and return this buffer as a numpy array. """ dpi = get_dpi() # Compute the Matplotlib figsize: note the order of width, height. # The width is doubled because we will only keep the colorbar portion # before we export this image to buffer! figsize = (self.bar_size[1] / dpi * 2, self.bar_size[0] / dpi) # Convert cmap and clim to Matplotlib format. rgba = self.cmap.colors.rgba # Blend to white to avoid this Matplotlib rendering issue: # https://github.com/matplotlib/matplotlib/issues/1188 for i in range(3): rgba[:, i] = (1 - rgba[:, -1]) + rgba[:, -1] * rgba[:, i] rgba[:, -1] = 1. if len(rgba) < 2: # in special case of 'grays' cmap! rgba = np.array([[0, 0, 0, 1.], [1, 1, 1, 1.]]) cmap = LinearSegmentedColormap.from_list('vispy_cmap', rgba) norm = mpl.colors.Normalize(vmin=self.clim[0], vmax=self.clim[1]) sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm) # Put the colorbar at proper location on the Matplotlib fig. fig = plt.figure(figsize=figsize, dpi=dpi) ax = plt.Axes(fig, [0, 0, 1, 1]) ax.set_axis_off() fig.add_axes(ax) divider = make_axes_locatable(ax) cax = divider.append_axes('right', size='100%', pad=0.) cb = fig.colorbar(sm, cax=cax) ax.remove() # Apply styling to the colorbar. cb.set_label(self.label_str, color=self.label_color, fontsize=self.label_size) plt.setp(plt.getp(cb.ax.axes, 'yticklabels'), color=self.label_color, fontsize=self.tick_size) cb.ax.yaxis.set_tick_params(color=self.label_color) cb.outline.set_linewidth(self.border_width) cb.outline.set_edgecolor(self.border_color) # Export the rendering to a numpy array in the buffer. buf = io.BytesIO() fig.savefig(buf, format='png', bbox_inches='tight', pad_inches=0, dpi=dpi, transparent=True) buf.seek(0) return plt.imread(buf)
def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 550)) self.meshes = [] self.rotation = MatrixTransform() # Generate some data to work with global mdata mdata = create_sphere(20, 40, 1.0) verts = mdata.get_vertices() faces = mdata.get_faces() gamma, phi = xyz_to_gp(verts) data = np.cos(5*gamma)+np.cos(phi*4)/2. mesh = visuals.MeshVisual(vertices=verts, faces=faces, banded=False, nband=8, vertex_values=data) mesh.cmap = 'viridis' self.meshes.append(mesh) mesh = visuals.MeshVisual(vertices=verts, faces=faces, banded=True, nband=8, vertex_values=data) mesh.cmap = 'viridis' self.meshes.append(mesh) mesh = visuals.MeshVisual(vertices=verts, faces=faces, banded=False, nband=8, vertex_values=data, shading='flat') mesh.cmap = 'viridis' self.meshes.append(mesh) mesh = visuals.MeshVisual(vertices=verts, faces=faces, banded=True, nband=8, vertex_values=data, shading='flat') mesh.cmap = 'viridis' self.meshes.append(mesh) mesh = visuals.MeshVisual(vertices=verts, faces=faces, banded=False, nband=8, vertex_values=data, shading='smooth') mesh.cmap = 'viridis' mesh.shininess = 0.01 self.meshes.append(mesh) # Mesh with color indexed into a colormap mesh = visuals.MeshVisual(vertices=verts, faces=faces, banded=True, nband=8, vertex_values=data, shading='smooth') mesh.cmap = 'viridis' mesh.shininess = 0.01 self.meshes.append(mesh) # Lay out meshes in a grid grid = (3, 3) s = 300. / max(grid) for i, mesh in enumerate(self.meshes): x = 800. * (i % grid[0]) / grid[0] + 400. / grid[0] - 2 y = 800. * (i // grid[1]) / grid[1] + 400. / grid[1] + 2 transform = ChainTransform([STTransform(translate=(x, y), scale=(s, s, s)), self.rotation]) mesh.transform = transform mesh.transforms.scene_transform = STTransform(scale=(1, 1, 0.01)) self.show() self.timer = app.Timer(connect=self.rotate) self.timer.start(0.016)
class Body(): """ binds tranfos to the bodies and the order of doing it """ def __init__(self, state_vec, p): self.state_vec = state_vec self.n = 0 self.n_max = len(state_vec) self.p = p self.radius = p/6.0 self.rot = MatrixTransform() self.v_orient = None self.x = 0. self.y = 0. self.z = 0. #print("-------", self.n_max, self.p) def set_orient(self,v_orient): """ set orientation to v_orient. :param v_orient: new orientation of point object """ self.v_orient = v_orient def _update(self): """ update rotation and then translation """ global OO self.n += 1 if self.n > self.n_max-1: self.n = 0 return dx = self.state_vec[self.n][0] dy = self.state_vec[self.n][1] dz = self.state_vec[self.n][2] if self.v_orient: new_base = self.v_orient[self.n] else: new_base = None self.trafo(dx,dy,dz,base=new_base) def _norm(self, n): """ normalizing a vector n = (x,y,z) """ x, y, z = n norm = np.sqrt(x*x + y*y + z*z) return x/norm, y/norm, z/norm def _cross(self, n0, n1): """ doing a crossproduct i.e. n1 x n2 """ x0, y0, z0 = n0 x1, y1, z1 = n1 x = y0*z1 - z0*y1 y = z0*x1 - x0*z1 z = x0*y1 - y0*x1 return x,y,z def _ortho(self, n): """ finding an arbitrary orthogonal vector to another in 3d """ x,y,z = n if z!=0. and y!=0.: return 0., z, -y elif x!=0. and y!=0.: return y, -x, 0. elif x!=0. and z!=0.: return z, 0., -x else: return x,y,z+1 def _get_ortho_base(self, n): """ calc an ottho base for one direction, such that ex is pointing in the end to that direction """ ex = self._norm(n) ey = self._norm(self._ortho(ex)) ez = self._cross(ex, ey) return ex, ey, ez def trafo(self, x=0.,y=0.,z=0., base=None, scale=None, reset=True): """ doing first the scale then rotation and afterwards translate """ if reset: self.rot.reset() if scale is not None: self.rot.scale(scale) if base is not None: self.rot.mult_rotation(base) self.rot.translate((x,y,z)) self.transform = self.rot