def __init__(self, parent=None, **kwargs): """Init.""" # _____________________ INIT _____________________ self._n = 1000 self._ratio = 4 / 5 CbarBase.__init__(self, **kwargs) # _____________________ CANVAS _____________________ if parent is None: # Define a canvas : self._canvas = scene.SceneCanvas(keys='interactive', show=False, resizable=True, dpi=600, bgcolor=self._bgcolor, size=(300, 900)) self._wc = self._canvas.central_widget.add_view() parent = self._wc.scene # Define the camera : self._camera = FixedCam(rect=(-1.2, -1.2, 2.4, 2.4)) self._wc.camera = self._camera self.parent = parent # _____________________ OBJECTS _____________________ # --------------------- Node --------------------- # Define node parent and limit node : self._cbNode = Node(name='Colorbar', parent=parent) self._limNode = Node(name='Limits', parent=self._cbNode) # Rescale between (-1., 1.) : self._rsc = vist.STTransform(scale=(self._width, 2 / self._n, 1), translate=(0, -1., 0)) # Set transformation to the node : self._cbNode.transform = self._rsc # --------------------- Image --------------------- self._mImage = visuals.Image(parent=self._cbNode, name='image') # --------------------- Border --------------------- pos = np.array([[0., 0., -3.], [1., 0., -3.], [1., 0., -3.], [1., self._n, -3.], [1., self._n, -3.], [0., self._n, -3.], [0., self._n, -3.], [0., 0., -3.]]) self._mBorder = visuals.Line(parent=self._cbNode, name='Border') self._mBorder.set_data(pos=pos, width=2., connect='segments', color=self._txtcolor) self._mBorder.visible = self._border # --------------------- Labels --------------------- # Clim labels : self._mClimM = visuals.Text(parent=self._limNode, color=self._txtcolor, font_size=self._txtsz, name='Clim_M', anchor_x='left') self._mClimm = visuals.Text(parent=self._limNode, color=self._txtcolor, font_size=self._txtsz, name='Clim_m', anchor_x='left') # Cblabel : self._mcblabel = visuals.Text(parent=self._limNode, name='Cblabel', color=self._txtcolor, anchor_x='center', font_size=self._cbtxtsz) self._mcblabel.rotation = -90 # Vmin/Vmax : self._vmMNode = Node(name='VminVmax', parent=self._limNode) self._mVm = visuals.Text(parent=self._vmMNode, color=self._txtcolor, font_size=self._ratio * self._txtsz, name='Vmin', anchor_x='left') self._mVM = visuals.Text(parent=self._vmMNode, color=self._txtcolor, font_size=self._ratio * self._txtsz, name='Vmax', anchor_x='left') # Build colorbar : self._build(True, 'all')
# vispy: gallery 30 # ----------------------------------------------------------------------------- # Copyright (c) 2015, Vispy Development Team. All Rights Reserved. # Distributed under the (new) BSD License. See LICENSE.txt for more info. # ----------------------------------------------------------------------------- """ Demonstrate the use of the vispy console. Note how the console size is independent of the canvas scaling. """ import sys from vispy import scene, app from vispy.scene.widgets import Console from vispy.scene.visuals import Text canvas = scene.SceneCanvas(keys='interactive', size=(400, 400)) grid = canvas.central_widget.add_grid() vb = scene.widgets.ViewBox(border_color='b') vb.camera = 'panzoom' vb.camera.rect = -1, -1, 2, 2 grid.add_widget(vb, row=0, col=0) text = Text('Starting timer...', color='w', font_size=24, parent=vb.scene) console = Console(text_color='g', font_size=12., border_color='g') grid.add_widget(console, row=1, col=0) def on_timer(event): text.text = 'Tick #%s' % event.iteration if event.iteration > 1 and event.iteration % 10 == 0:
import itertools import numpy as np from vispy import app, scene from vispy.color import get_colormaps from vispy.visuals.transforms import STTransform colormaps = itertools.cycle(get_colormaps()) # vertex positions of data to draw N = 200 pos = np.zeros((N, 2), dtype=np.float32) pos[:, 0] = np.linspace(10, 390, N) pos[:, 1] = np.random.normal(size=N, scale=20, loc=0) canvas = scene.SceneCanvas(keys='interactive', size=(400, 200), show=True) # Create a visual that updates the line with different colormaps color = next(colormaps) line = scene.Line(pos=pos, color=color, method='gl') line.transform = STTransform(translate=[0, 140]) line.parent = canvas.central_widget text = scene.Text(color, bold=True, font_size=24, color='w', pos=(200, 40), parent=canvas.central_widget)
print(density, density.shape) def get_min_and_max(array): return float("%.4g" % np.nanmin(array)), float("%.4g" % np.nanmax(array)) #----------- # For volume data, it's kind of already 'gridded' trans = (-(xmax - xmin) / 2.0, -(ymax - ymin) / 2.0, -(zmax - zmin) / 2.0) sur_scale = [(xmax - xmin) / 50., (ymax - ymin) / 50., (zmax - zmin) / 50.] # Create a canvas with a 3D viewport canvas = scene.SceneCanvas(keys='interactive', config={'depth_size': 24}, bgcolor='white') view = canvas.central_widget.add_view() surface = scene.visuals.Isosurface(density, level=density.max() / 2., shading=None, color=(0.5, 0.6, 1, 0.5), parent=view.scene) # surface.transform = scene.transforms.STTransform(translate=(-len(X)/2., -len(Y)/2., -len(Z)/2.)) surface.set_gl_state(depth_test=True, cull_face=True) surface.transform = scene.STTransform(translate=trans, scale=sur_scale) surface2 = scene.visuals.Isosurface(density, level=density.max() / 4., shading=None,
# gloo.gl.use('desktop debug') # Create lines for use in ndc and pixel coordinates N = 1000 color = np.ones((N, 4), dtype=np.float32) color[:, 0] = np.linspace(0, 1, N) color[:, 1] = color[::-1, 0] pos = np.empty((N, 2), np.float32) pos[:, 0] = np.linspace(0., 1., N) pos[:, 1] = np.random.normal(loc=0.5, scale=0.03, size=N) pos[N // 2:N // 2 + 20, 1] = 0.9 # So we can see which side is up # Create canvas canvas = scene.SceneCanvas(size=(800, 600), show=True, keys='interactive') # # Create viewboxes on left ... # w, h = canvas.size w2 = w / 2. h2 = h / 2. # left (+y up) vb1 = scene.widgets.ViewBox(parent=canvas.scene, name='vb1', margin=2, border_color='red') vb1.pos = 0, 0
def __init__(self, icurves, highlight=None, clrmap="husl", colors=None, parent=None): """ :param icurves: input curve or list of curves :param clrmap: (optional) what colormap name from vispy.colormap to use :param colors: (optional) use list of colors instead of colormap """ self.canvas = scene.SceneCanvas( size=(1280, 900), position=(200, 200), keys="interactive", bgcolor=bg_clr, parent=parent, ) self.grid = self.canvas.central_widget.add_grid(spacing=0) self.view = self.grid.add_view(row=0, col=1, camera="panzoom") curves = np.array(icurves) if len(curves.shape) == 1: ## Single curve curves = np.array([icurves]) nb_traces, size = curves.shape # the Line visual requires a vector of X,Y coordinates xy_curves = np.dstack((np.tile(np.arange(size), (nb_traces, 1)), curves)) # Specify which points are connected # Start by connecting each point to its successor connect = np.empty((nb_traces * size - 1, 2), np.int32) connect[:, 0] = np.arange(nb_traces * size - 1) connect[:, 1] = connect[:, 0] + 1 # Prevent vispy from drawing a line between the last point # of a curve and the first point of the next curve for i in range(size, nb_traces * size, size): connect[i - 1, 1] = i - 1 if highlight is not None: # cheat by predrawing a single line over the highlighted one scene.Line(pos=xy_curves[highlight], color=highlighted, parent=self.view.scene) scene.Line(pos=xy_curves, color=others, parent=self.view.scene, connect=connect) else: if colors is None: colormap = color.get_colormap(clrmap)[np.linspace( 0.0, 1.0, nb_traces * size)] else: colormap = color.get_colormap(clrmap)[colors] scene.Line(pos=xy_curves, color=colormap, parent=self.view.scene, connect=connect) self.x_axis = scene.AxisWidget(orientation="bottom") self.y_axis = scene.AxisWidget(orientation="left") self.x_axis.stretch = (1, 0.05) self.y_axis.stretch = (0.05, 1) self.grid.add_widget(self.x_axis, row=1, col=1) self.grid.add_widget(self.y_axis, row=0, col=0) self.x_axis.link_view(self.view) self.y_axis.link_view(self.view) self.view.camera.set_range(x=(-1, size), y=(curves.min(), curves.max())) self.canvas.show() if parent is None: self.canvas.app.run()
__author__ = 'Penny Qian' """ This script is to test creating IsoSurface based on Gaussian Density Estimation for scatter points Some displacement exists between the scatter points and the produced IsoSurface """ import numpy as np from vispy import app, scene, io from vispy.color import Color from scipy import stats # Prepare canvas canvas = scene.SceneCanvas(keys='interactive', size=(800, 600), show=True, bgcolor='white') canvas.measure_fps() # Set up a viewbox to display the image with interactive pan/zoom view = canvas.central_widget.add_view() # Create three cameras (Fly, Turntable and Arcball) fov = 60. cam2 = scene.cameras.TurntableCamera(parent=view.scene, fov=fov, name='Turntable') view.camera = cam2 # Select turntable at first # Add scatter plots here n = 5000 pos = np.random.normal(size=(n, 3), scale=0.2)
def __init__(self, parent): super(SignalWidget, self).__init__(parent) # Useful trnascripts self.plugin = self.parent() self.sd = self.plugin.sd self.CONF_SECTION = self.parent().CONF_SECTION # Variables self.measurement_mode = False self.curr_pc = None self.sig_start = None self.sig_stop = None self.spect_type = 'spectrum' # spectrum, spectrogram # General variables self.low_lim = None self.high_lim = None # Sepctrum variables self.mean_filter = None # Setup camera self.signal_camera = SignalCamera() self.spectrum_camera = SignalCamera() self.canvas = scene.SceneCanvas(show=True, keys='interactive', parent=self, bgcolor=CONF.get( self.CONF_SECTION, 'bgcolor')) self.view_grid = self.canvas.central_widget.add_grid(margin=10) # Signal self.signal_view = self.view_grid.add_view(row=0, col=1, row_span=2, camera=self.signal_camera) axis_color = CONF.get(self.CONF_SECTION, 'axis_color') self.signal_yaxis = AxisWidget(orientation='left', axis_label='Amplitude', axis_font_size=12, tick_label_margin=5, axis_color=axis_color, tick_color=axis_color, text_color=axis_color) self.signal_yaxis.width_max = 60 self.view_grid.add_widget(self.signal_yaxis, row=0, col=0, row_span=2) self.signal_xaxis = scene.AxisWidget(orientation='bottom', axis_label='Time [s]', axis_font_size=12, tick_label_margin=5, axis_color=axis_color, tick_color=axis_color, text_color=axis_color) self.signal_xaxis.height_max = 55 self.view_grid.add_widget(self.signal_xaxis, row=2, col=1) self.signal_yaxis.link_view(self.signal_view) self.signal_xaxis.link_view(self.signal_view) # Spectrum self.spectrum_view = self.view_grid.add_view( row=3, col=1, row_span=2, camera=self.spectrum_camera) self.spectrum_yaxis = AxisWidget(orientation='left', axis_label='Amplitude', axis_font_size=12, tick_label_margin=5, axis_color=axis_color, tick_color=axis_color, text_color=axis_color) self.spectrum_yaxis.width_max = 60 self.view_grid.add_widget(self.spectrum_yaxis, row=3, col=0, row_span=2) self.spectrum_xaxis = scene.AxisWidget(orientation='bottom', axis_label='Frequency [Hz]', axis_font_size=12, axis_color=axis_color, tick_color=axis_color, text_color=axis_color) self.spectrum_xaxis.height_max = 55 self.view_grid.add_widget(self.spectrum_xaxis, row=5, col=1) self.spectrum_yaxis.link_view(self.spectrum_view) self.spectrum_xaxis.link_view(self.spectrum_view) self.signal_line = Line(parent=self.signal_view.scene, width=1) self.spectrum_line = Line(parent=self.spectrum_view.scene, width=1) self.spectrogram = Spectrogram([0], parent=self.spectrum_view.scene) # ----- Set layout ----- # Widget layout layout = QVBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.addWidget(self.canvas.native) # Set the whole layout self.setLayout(layout)
BoatNode = scene.visuals.create_visual_node(BoatVisual) TextNode = scene.visuals.create_visual_node(visuals.TextVisual) # Create a canvas to display our visual WINDOW_WIDTH = 1600 WINDOW_HEIGHT = 800 ARENA_WIDTH = 800 ARENA_HEIGHT = WINDOW_HEIGHT DATA_WIDTH = WINDOW_WIDTH - ARENA_WIDTH DATA_HEIGHT = WINDOW_HEIGHT ARENA_CENTER = (ARENA_WIDTH/2., ARENA_HEIGHT/2.) ARENA_EDGE_SIZE = 100.0 # remember 0, 0 is upper left in pixel coordinates, (pixel_width, pixel_height) is the lower right in pixel coordinates # In real coordinates 0, 0 is the center, negatives are to the left and down CANVAS = scene.SceneCanvas(keys='interactive', show=True, size=(WINDOW_WIDTH, WINDOW_HEIGHT)) ARENA_VIEW = scene.widgets.ViewBox(parent=CANVAS.scene, name="arena_view", margin=0, bgcolor=(1, 1, 1, 1), size=(ARENA_WIDTH, ARENA_HEIGHT), pos=(0, 0)) DATA_VIEW = scene.widgets.ViewBox(parent=CANVAS.scene, name="data_view", margin=0, bgcolor=(0.8, 0.8, 0.8, 1), size=(DATA_WIDTH, DATA_HEIGHT), pos=(ARENA_WIDTH, 0)) # Create two instances of the visual, each using canvas.scene as their parent COLORS = {"pid": (0, .6, .6, 1), "q": (.6, 0, 0, 1)} BOAT_VISUALS = {"pid": BoatNode(ARENA_CENTER[0], ARENA_CENTER[1], 0, 20, 40, COLORS["pid"], parent=CANVAS.scene), "q": BoatNode(ARENA_CENTER[0], ARENA_CENTER[1], 0, 20, 40, COLORS["q"], parent=CANVAS.scene)} NAVIGATION_LINES = {"pid": scene.visuals.Line(pos=np.zeros((2, 2), dtype=np.float32), color=COLORS["pid"], parent=CANVAS.scene), "q": scene.visuals.Line(pos=np.zeros((2, 2), dtype=np.float32), color=COLORS["q"], parent=CANVAS.scene)} NAVIGATION_LINES["pid"].transform = scene.transforms.STTransform() NAVIGATION_LINES["q"].transform = scene.transforms.STTransform()
def visualize(z_in, azimuth=25., elevation=30., thresholds=[0.94, .89, .75, .5, .25, .1], opacities=[.9, .8, .7, .5, .2, .1], # thresholds=[0.94, .89, .75], opacities=[.99, .7, .2], # thresholds=[0.7, .5, .2], opacities=[.95, .5, .2], fourier_label = {'f_x':'f_x', 'f_y':'f_y', 'f_t':'f_t'}, name=None, ext=ext, do_axis=True, do_grids=False, draw_projections=True, colorbar=False, f_N=2., f_tN=2., figsize=figsize, figpath=figpath, **kwargs): """ Visualization of the Fourier spectrum by showing 3D contour plots at different thresholds parameters ---------- z : envelope of the cloud """ z = z_in.copy() N_X, N_Y, N_frame = z.shape fx, fy, ft = get_grids(N_X, N_Y, N_frame) # Normalize the amplitude. z /= z.max() from vispy import app, scene try: AffineTransform = scene.transforms.AffineTransform except: AffineTransform = scene.transforms.MatrixTransform app.use_app('pyglet') #from vispy.util.transforms import perspective, translate, rotate from vispy.color import Color transparent = Color(color='black', alpha=0.) import colorsys canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=450) view = canvas.central_widget.add_view() vol_data = np.rollaxis(np.rollaxis(z, 1), 2) # volume = scene.visuals.Volume(vol_data, parent=view.scene)#frame) center = scene.transforms.STTransform(translate=( -N_X/2, -N_Y/2, -N_frame/2)) # volume.transform = center # volume.cmap = 'blues' if draw_projections: from vispy.color import Colormap cm = Colormap([(1.0, 1.0, 1.0, 1.0), 'k']) opts = {'parent':view.scene, 'cmap':cm, 'clim':(0., 1.)} energy_xy = np.rot90(np.max(z, axis=2)[:, ::-1], 3)[:, ::-1] fourier_xy = scene.visuals.Image(np.rot90(energy_xy), **opts) tr_xy = AffineTransform() tr_xy.rotate(90, (0, 0, 1)) tr_xy.translate((N_X/2, -N_Y/2, -N_frame/2)) fourier_xy.transform = tr_xy energy_xt = np.rot90(np.max(z, axis=1)[:, ::-1], 3)[::-1, ::-1] fourier_xt = scene.visuals.Image(energy_xt, **opts) tr_xt = AffineTransform() tr_xt.rotate(90, (1, 0, 0)) tr_xt.translate((-N_X/2, N_Y/2, -N_frame/2)) fourier_xt.transform = tr_xt energy_yt = np.max(z, axis=0)#[:, ::-1] fourier_yt = scene.visuals.Image(energy_yt, **opts) tr_yt = AffineTransform() tr_yt.rotate(90, (0, 1, 0)) tr_yt.translate((-N_X/2, -N_Y/2, N_frame/2)) fourier_yt.transform = tr_yt # Generate iso-surfaces at different energy levels surfaces = [] for i_, (threshold, opacity) in enumerate(list(zip(thresholds, opacities))): surfaces.append(scene.visuals.Isosurface(z, level=threshold, # color=Color(np.array(colorsys.hsv_to_rgb(1.*i_/len(thresholds), 1., 1.)), alpha=opacity), color=Color(np.array(colorsys.hsv_to_rgb(.66, 1., 1.)), alpha=opacity), shading='smooth', parent=view.scene) ) surfaces[-1].transform = center # Draw a sphere at the origin axis = scene.visuals.XYZAxis(parent=view.scene) for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1], [1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1], [1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]): line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_Y/2, p[2]*N_frame/2], [p[3]*N_X/2, p[4]*N_Y/2, p[5]*N_frame/2]]), color='black', parent=view.scene) axisX = scene.visuals.Line(pos=np.array([[0, -N_Y/2, 0], [0, N_Y/2, 0]]), color='red', parent=view.scene) axisY = scene.visuals.Line(pos=np.array([[-N_X/2, 0, 0], [N_X/2, 0, 0]]), color='green', parent=view.scene) axisZ = scene.visuals.Line(pos=np.array([[0, 0, -N_frame/2], [0, 0, N_frame/2]]), color='blue', parent=view.scene) if do_axis: t = {} for text in ['f_x', 'f_y', 'f_t']: t[text] = scene.visuals.Text(fourier_label[text], parent=canvas.scene, face='Helvetica', color='black') t[text].font_size = 8 t['f_x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8 t['f_y'].pos = canvas.size[0] - canvas.size[0] // 8, canvas.size[1] - canvas.size[1] // 6 t['f_t'].pos = canvas.size[0] // 8, canvas.size[1] // 2 cam = scene.TurntableCamera(elevation=elevation, azimuth=azimuth, up='z') cam.fov = 48 cam.scale_factor = N_X * 1.8 if do_axis: margin = 1.35 else: margin = 1 cam.set_range((-N_X/2*margin, N_X/2/margin), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2*margin, N_frame/2/margin)) view.camera = cam im = canvas.render(size=figsize) app.quit() if not(name is None): import vispy.io as io io.write_png(name + ext, im) else: return im
def cube(im_in, azimuth=30., elevation=45., name=None, ext=ext, do_axis=True, show_label=True, cube_label = {'x':'x', 'y':'y', 't':'t'}, colormap='gray', roll=-180., vmin=0., vmax=1., figsize=figsize, figpath=figpath, **kwargs): """ Visualization of the stimulus as a cube """ im = im_in.copy() N_X, N_Y, N_frame = im.shape fx, fy, ft = get_grids(N_X, N_Y, N_frame) import numpy as np from vispy import app, scene try: AffineTransform = scene.transforms.AffineTransform except: AffineTransform = scene.transforms.MatrixTransform app.use_app('pyglet') from vispy.util.transforms import perspective, translate, rotate canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=450) view = canvas.central_widget.add_view() # frame = scene.visuals.Cube(size = (N_X/2, N_frame/2, N_Y/2), color=(0., 0., 0., 0.), # edge_color='k', # parent=view.scene) for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1], [1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1], [1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]): # line = scene.visuals.Line(pos=np.array([[p[0]*N_Y/2, p[1]*N_X/2, p[2]*N_frame/2], [p[3]*N_Y/2, p[4]*N_X/2, p[5]*N_frame/2]]), color='black', parent=view.scene) line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_frame/2, p[2]*N_Y/2], [p[3]*N_X/2, p[4]*N_frame/2, p[5]*N_Y/2]]), color='black', parent=view.scene) opts = {'parent':view.scene, 'cmap':'grays', 'clim':(0., 1.)} image_xy = scene.visuals.Image(np.rot90(im[:, :, 0], 3), **opts) tr_xy = AffineTransform() tr_xy.rotate(90, (1, 0, 0)) tr_xy.translate((-N_X/2, -N_frame/2, -N_Y/2)) image_xy.transform = tr_xy image_xt = scene.visuals.Image(np.fliplr(im[:, -1, :]), **opts) tr_xt = AffineTransform() tr_xt.rotate(90, (0, 0, 1)) tr_xt.translate((N_X/2, -N_frame/2, N_Y/2)) image_xt.transform = tr_xt image_yt = scene.visuals.Image(np.rot90(im[-1, :, :], 1), **opts) tr_yt = AffineTransform() tr_yt.rotate(90, (0, 1, 0)) tr_yt.translate((+N_X/2, -N_frame/2, N_Y/2)) image_yt.transform = tr_yt if do_axis: t = {} for text in ['x', 'y', 't']: t[text] = scene.visuals.Text(cube_label[text], parent=canvas.scene, face='Helvetica', color='black') t[text].font_size = 8 t['x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8 t['t'].pos = canvas.size[0] - canvas.size[0] // 5, canvas.size[1] - canvas.size[1] // 6 t['y'].pos = canvas.size[0] // 12, canvas.size[1] // 2 cam = scene.TurntableCamera(elevation=35, azimuth=30) cam.fov = 45 cam.scale_factor = N_X * 1.7 if do_axis: margin = 1.3 else: margin = 1 cam.set_range((-N_X/2, N_X/2), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2, N_frame/2)) view.camera = cam if not(name is None): im = canvas.render(size=figsize) app.quit() import vispy.io as io io.write_png(name + ext, im) else: app.quit() return im
def debug(self, measurements, file_path, add_geodesic): # Model object model = mesh_lib.Model(file_path) model_point_coordinates = model.get_coords() canvas = scene.SceneCanvas(keys='interactive') view = canvas.central_widget.add_view() # all model - GREEN points = Markers(parent=view.scene) points.set_data( pos=model_point_coordinates, edge_color=None, face_color=(0, 1, 0, .3), size=5 ) data_list = [] for m in measurements: # measurements in config file # parsing key vertexes and description text point_1 = int(m[1]) + 1 point_2 = int(m[2]) + 1 point_3 = int(m[3]) + 1 text = " ".join(m[4:]) # coordinates of key vertexes key_coords = model.get_coords((point_1, point_2, point_3)) # plane that goes through all three key vertexes plane = mesh_lib.get_plane(key_coords) # key vertexes WHITE points = Markers() points.set_data( pos=key_coords, edge_color=None, face_color=(1, 1, 1, 1), size=5 ) # "C" - circumference if m[0] == "C": # 3 segments of path (indexes) p_1 = model.get_path(point_1, point_2) p_2 = model.get_path(point_2, point_3) p_3 = model.get_path(point_3, point_1) # full path path = p_1 + p_2[1:] + p_3[1:] # "L" - Length if m[0] == "L": # 2 segments of path (indexes) p_1 = model.get_path(point_1, point_2) p_2 = model.get_path(point_2, point_3) # full path path = p_1 + p_2[1:] # geodesic geodesic_coordinates = model.get_coords(path) geodesic_length = mesh_lib.get_length(geodesic_coordinates) print("{0}:".format(text)) print( " Geodesic distance: {0} cm".format( round(100 * geodesic_length, 3) ) ) if add_geodesic: # if debug_full # geodesic line - RED line = Line(parent=view.scene) line.set_data( pos=geodesic_coordinates, color=(1, 0, 0, 1) ) # approximated flattened_coordinates = mesh_lib.get_projections(plane, geodesic_coordinates) flattened_length = mesh_lib.get_length(flattened_coordinates) print( " Approximated distance: {0} cm".format( round(100 * flattened_length, 3) ) ) data_list.append(geodesic_length) data_list.append(flattened_length) # flattened line - BLUE line = Line(parent=view.scene) line.set_data( pos=flattened_coordinates, color=(0, 0, 1, 1) ) view.camera = 'turntable' view.camera.fov = 45 view.camera.distance = 3 axis = XYZAxis(parent=view.scene) final_result = {"canvas":canvas,"data":data_list} return final_result
import sys import os import numpy as np from vispy import app, scene, io # from vispy import color canvas = scene.SceneCanvas(title='Skeleton Pose', size=(600, 600), keys='interactive') view = canvas.central_widget.add_view(camera='turntable') view.camera.fov = 45 view.camera.distance = 10 pose_data_fname = './data/error.csv' data = np.loadtxt(pose_data_fname, skiprows=1, delimiter=',') pose_data = data[:, :-2] predict = data[:, -2] real = data[:, -1] predict = predict.reshape(-1) real = real.reshape(-1) pose_data = pose_data.reshape(-1, 19, 3) pose_idx = 0 test = 0 max_pose_idx = pose_data.shape[0] - 1 pos = pose_data[pose_idx] j_colors = np.random.uniform(size=(19, 3), low=.5, high=.8) # j_colors = color.get_colormap('orange').map(np.array([e/24 for e in range(25)]))
def oscilloscope(): # Copyright (c) Vispy Development Team. All Rights Reserved. # Distributed under the (new) BSD License. See LICENSE.txt for more info. """ An oscilloscope, spectrum analyzer, and spectrogram. This demo uses pyaudio to record data from the microphone. If pyaudio is not available, then a signal will be generated instead. """ import threading import atexit import numpy as np from vispy import app, scene, gloo, visuals from vispy.util.filter import gaussian_filter try: import pyaudio class MicrophoneRecorder(object): def __init__(self, rate=44100, chunksize=1024): self.rate = rate self.chunksize = chunksize self.p = pyaudio.PyAudio() self.stream = self.p.open(format=pyaudio.paInt16, channels=1, rate=self.rate, input=True, frames_per_buffer=self.chunksize, stream_callback=self.new_frame) self.lock = threading.Lock() self.stop = False self.frames = [] atexit.register(self.close) def new_frame(self, data, frame_count, time_info, status): data = np.fromstring(data, 'int16') with self.lock: self.frames.append(data) if self.stop: return None, pyaudio.paComplete return None, pyaudio.paContinue def get_frames(self): with self.lock: frames = self.frames self.frames = [] return frames def start(self): self.stream.start_stream() def close(self): with self.lock: self.stop = True self.stream.close() self.p.terminate() except ImportError: class MicrophoneRecorder(object): def __init__(self): self.chunksize = 1024 self.rate = rate = 44100 t = np.linspace(0, 10, rate * 10) self.data = (np.sin(t * 10.) * 0.3).astype('float32') self.data += np.sin((t + 0.3) * 20.) * 0.15 self.data += gaussian_filter( np.random.normal(size=self.data.shape) * 0.2, (0.4, 8)) self.data += gaussian_filter( np.random.normal(size=self.data.shape) * 0.005, (0, 1)) self.data += np.sin(t * 1760 * np.pi) # 880 Hz self.data = (self.data * 2**10 - 2**9).astype('int16') self.ptr = 0 def get_frames(self): if self.ptr + 1024 > len(self.data): end = 1024 - (len(self.data) - self.ptr) frame = np.concatenate( (self.data[self.ptr:], self.data[:end])) else: frame = self.data[self.ptr:self.ptr + 1024] self.ptr = (self.ptr + 1024) % (len(self.data) - 1024) return [frame] def start(self): pass class Oscilloscope(scene.ScrollingLines): """A set of lines that are temporally aligned on a trigger. Data is added in chunks to the oscilloscope, and each new chunk creates a new line to draw. Older lines are slowly faded out until they are removed. Parameters ---------- n_lines : int The maximum number of lines to draw. line_size : int The number of samples in each line. dx : float The x spacing between adjacent samples in a line. color : tuple The base color to use when drawing lines. Older lines are faded by decreasing their alpha value. trigger : tuple A set of parameters (level, height, width) that determine how triggers are detected. parent : Node An optional parent scenegraph node. """ def __init__(self, n_lines=100, line_size=1024, dx=1e-4, color=(20, 255, 50), trigger=(0, 0.002, 1e-4), parent=None): self._trigger = trigger # trigger_level, trigger_height, trigger_width # lateral positioning for trigger self.pos_offset = np.zeros((n_lines, 3), dtype=np.float32) # color array to fade out older plots self.color = np.empty((n_lines, 4), dtype=np.ubyte) self.color[:, :3] = [list(color)] self.color[:, 3] = 0 self._dim_speed = 0.01**(1 / n_lines) self.frames = [] # running list of recently received frames self.plot_ptr = 0 scene.ScrollingLines.__init__(self, n_lines=n_lines, line_size=line_size, dx=dx, color=self.color, pos_offset=self.pos_offset, parent=parent) self.set_gl_state('additive', line_width=2) def new_frame(self, data): self.frames.append(data) # see if we can discard older frames while len(self.frames) > 10: self.frames.pop(0) if self._trigger is None: dx = 0 else: # search for next trigger th = int(self._trigger[1]) # trigger window height tw = int(self._trigger[2] / self._dx) # trigger window width thresh = self._trigger[0] trig = np.argwhere((data[tw:] > thresh + th) & (data[:-tw] < thresh - th)) if len(trig) > 0: m = np.argmin(np.abs(trig - len(data) / 2)) i = trig[m, 0] y1 = data[i] y2 = data[min(i + tw * 2, len(data) - 1)] s = y2 / (y2 - y1) i = i + tw * 2 * (1 - s) dx = i * self._dx else: # default trigger at center of trace # (optionally we could skip plotting instead, or place this # after the most recent trace) dx = self._dx * len(data) / 2. # if a trigger was found, add new data to the plot self.plot(data, -dx) def plot(self, data, dx=0): self.set_data(self.plot_ptr, data) np.multiply(self.color[..., 3], 0.98, out=self.color[..., 3], casting='unsafe') self.color[self.plot_ptr, 3] = 50 self.set_color(self.color) self.pos_offset[self.plot_ptr] = (dx, 0, 0) self.set_pos_offset(self.pos_offset) self.plot_ptr = (self.plot_ptr + 1) % self._data_shape[0] rolling_tex = """ float rolling_texture(vec2 pos) { if( pos.x < 0 || pos.x > 1 || pos.y < 0 || pos.y > 1 ) { return 0.0f; } vec2 uv = vec2(mod(pos.x+$shift, 1), pos.y); return texture2D($texture, uv).r; } """ cmap = """ vec4 colormap(float x) { x = x - 1e4; return vec4(x/5e6, x/2e5, x/1e4, 1); } """ class ScrollingImage(scene.Image): def __init__(self, shape, parent): self._shape = shape self._color_fn = visuals.shaders.Function(rolling_tex) self._ctex = gloo.Texture2D(np.zeros(shape + (1, ), dtype='float32'), format='luminance', internalformat='r32f') self._color_fn['texture'] = self._ctex self._color_fn['shift'] = 0 self.ptr = 0 scene.Image.__init__(self, method='impostor', parent=parent) # self.set_gl_state('additive', cull_face=False) self.shared_program.frag['get_data'] = self._color_fn cfun = visuals.shaders.Function(cmap) self.shared_program.frag['color_transform'] = cfun @property def size(self): return self._shape def roll(self, data): data = data.reshape(data.shape[0], 1, 1) self._ctex[:, self.ptr] = data self._color_fn['shift'] = (self.ptr + 1) / self._shape[1] self.ptr = (self.ptr + 1) % self._shape[1] self.update() def _prepare_draw(self, view): if self._need_vertex_update: self._build_vertex_data() if view._need_method_update: self._update_method(view) global fft_frames, scope, spectrum, mic mic = MicrophoneRecorder() n_fft_frames = 8 fft_samples = mic.chunksize * n_fft_frames win = scene.SceneCanvas(keys='interactive', show=True, fullscreen=True) grid = win.central_widget.add_grid() view3 = grid.add_view(row=0, col=0, col_span=2, camera='panzoom', border_color='grey') image = ScrollingImage((1 + fft_samples // 2, 4000), parent=view3.scene) image.transform = scene.LogTransform((0, 10, 0)) # view3.camera.rect = (0, 0, image.size[1], np.log10(image.size[0])) view3.camera.rect = (3493.32, 1.85943, 605.554, 1.41858) view1 = grid.add_view(row=1, col=0, camera='panzoom', border_color='grey') view1.camera.rect = (-0.01, -0.6, 0.02, 1.2) gridlines = scene.GridLines(color=(1, 1, 1, 0.5), parent=view1.scene) scope = Oscilloscope(line_size=mic.chunksize, dx=1.0 / mic.rate, parent=view1.scene) view2 = grid.add_view(row=1, col=1, camera='panzoom', border_color='grey') view2.camera.rect = (0.5, -0.5e6, np.log10(mic.rate / 2), 5e6) lognode = scene.Node(parent=view2.scene) lognode.transform = scene.LogTransform((10, 0, 0)) gridlines2 = scene.GridLines(color=(1, 1, 1, 1), parent=lognode) spectrum = Oscilloscope(line_size=1 + fft_samples // 2, n_lines=10, dx=mic.rate / fft_samples, trigger=None, parent=lognode) mic.start() window = np.hanning(fft_samples) fft_frames = [] def update(ev): global fft_frames, scope, spectrum, mic data = mic.get_frames() for frame in data: # import scipy.ndimage as ndi # frame -= ndi.gaussian_filter(frame, 50) # frame -= frame.mean() scope.new_frame(frame) fft_frames.append(frame) if len(fft_frames) >= n_fft_frames: cframes = np.concatenate(fft_frames) * window fft = np.abs(np.fft.rfft(cframes)).astype('float32') fft_frames.pop(0) spectrum.new_frame(fft) image.roll(fft) timer = app.Timer(interval='auto', connect=update) timer.start() app.run()
def scatter(pos, mfc=[0.5, 0.5, 0.5, 0.8], mec=None, mfs=8, mes=1, bgc=[0.9, 0.9, 0.9], scaling=False, symbol='disc'): """ Display a scatter plot in 2D or 3D. Parameters ---------- pos : array The array of locations to display each symbol. mfc : Color | ColorArray The color used to draw each symbol interior. mec : Color | ColorArray The color used to draw each symbol outline. mfs : float or array The symbol size in px. mes : float | None The width of the symbol outline in pixels. bgc : Color The color used for the background. scaling : bool If set to True, marker scales when rezooming. symbol : str The style of symbol to draw ('disc', 'arrow', 'ring', 'clobber', 'square', 'diamond', 'vbar', 'hbar', 'cross', 'tailed_arrow', 'x', 'triangle_up', 'triangle_down', 'star'). """ # Create the Canvas, the Scene and the View canvas = scene.SceneCanvas(keys='interactive', show=True, bgcolor=bgc) view = canvas.central_widget.add_view() # Create the scatter plot scatter = visuals.Markers() scatter.set_data(pos, face_color=mfc, edge_color=mec, scaling=scaling, size=mfs, edge_width=mes, symbol=symbol) view.add(scatter) # 2D Shape if pos.shape[1] == 2: # Set the camera properties view.camera = scene.PanZoomCamera(aspect=1) view.camera.set_range() # Create lines to know the position of the cursor tr = canvas.scene.node_transform(scatter) win_xmin, win_ymax = tr.map([0, 0])[:2] win_xmax, win_ymin = tr.map(canvas.size)[:2] win_xsize, win_ysize = win_xmax - win_xmin, win_ymax - win_ymin prop = .015 tick_size = prop * win_xsize top_line = scene.visuals.Line(pos=np.array( [[win_xmin, win_ymax], [win_xmin, win_ymax - tick_size]]), color=[.2, .2, .2, 0.5], width=1, parent=view.scene, method='gl') right_line = scene.visuals.Line(pos=np.array( [[win_xmax, win_ymin], [win_xmax - tick_size, win_ymin]]), color=[.2, .2, .2, 0.5], width=1, parent=view.scene, method='gl') bottom_line = scene.visuals.Line(pos=np.array( [[win_xmax, win_ymin], [win_xmax, win_ymin + tick_size]]), color=[.2, .2, .2, 0.5], width=1, parent=view.scene, method='gl') left_line = scene.visuals.Line(pos=np.array( [[win_xmin, win_ymax], [win_xmin + tick_size, win_ymax]]), color=[.2, .2, .2, 0.5], width=1, parent=view.scene, method='gl') cross_hline = scene.visuals.Line(pos=np.array( [[win_xmax, win_ymin], [win_xmax, win_ymin + tick_size]]), color=[0, 0, 0, 1], width=2, parent=view.scene, method='gl') cross_vline = scene.visuals.Line(pos=np.array( [[win_xmin, win_ymax], [win_xmin + tick_size, win_ymax]]), color=[0, 0, 0, 1], width=2, parent=view.scene, method='gl') # TODO: create rectangle around the text # Create text to give cursor position text_xline = visuals.Text('', bold=False, font_size=12, color=[0, 0, 0, 1], pos=[50, 50], anchor_x='left', anchor_y='baseline') text_yline = visuals.Text('', bold=False, font_size=12, color=[0, 0, 0, 1], pos=[50, 50], anchor_x='left', anchor_y='baseline') view.add(text_xline) view.add(text_yline) # When the mouse move, refresh the cursor position @canvas.events.mouse_move.connect def on_mouse_move(event): # Find the cursor position in the windows coordinate tr = canvas.scene.node_transform(scatter) x, y = tr.map(event.pos)[:2] # Find the min and max for both axis in the windows coordinate win_xmin, win_ymax = tr.map([0, 0])[:2] win_xmax, win_ymin = tr.map(canvas.size)[:2] win_xsize, win_ysize = win_xmax - win_xmin, win_ymax - win_ymin tick_size = prop * win_xsize #refresh xtext, ytext = str('%.2e' % x), str('%.2e' % y) text_xline.text = xtext text_xline.pos = [x, win_ymin] text_yline.text = ytext text_yline.pos = [win_xmin, y] top_line.set_data( pos=np.array([[x, win_ymax], [x, win_ymax - tick_size]])) right_line.set_data( pos=np.array([[win_xmax, y], [win_xmax - tick_size, y]])) bottom_line.set_data( pos=np.array([[x, win_ymin], [x, win_ymin + tick_size]])) left_line.set_data( pos=np.array([[win_xmin, y], [win_xmin + tick_size, y]])) cross_hline.set_data( pos=np.array([[x - tick_size / 2, y], [x + tick_size / 2, y]])) cross_vline.set_data( pos=np.array([[x, y - tick_size / 2], [x, y + tick_size / 2]])) # 3D Shape elif pos.shape[1] == 3: view.camera = 'turntable' app.run()
#print("filtering") #start = time() #vol = filter3d(vol, np.ones( (2,)*3 )) #print(f"done filtering! {(time()-start)/D**3} sec / voxel") # Increase the visibility of the x-z plane (where the logistic map lies) vol[:, vol.shape[1] // 2, :] = np.sqrt(vol[:, vol.shape[1] // 2, :]) # Slice the data to reveal only the logistic map slice = 0 if slice: vol = vol[:, vol.shape[1] // 2 - 1:vol.shape[1] // 2 + 2, :] # Prepare canvas canvas = scene.SceneCanvas(keys='interactive', size=rec_size, show=not rec) # Set up a viewbox to display the image with interactive pan/zoom view = canvas.central_widget.add_view() stepsize = .1 # step size inside the fragment shader : 0.1 is highest quality # Modify the vispy `transclucent` volume OpenGL shader NEW_TRANSLUCENT_SNIPPETS = dict( before_loop=""" vec4 integrated_color = vec4(0., 0., 0., 0.); """, in_loop=""" color = $cmap(val);
def fn(i, j, ci=m // 2, cj=n // 2, t=None): x = i / m * (x1 - x0) + x0 y = j / n * (y1 - y0) + y0 # vx = -dy # vy = dx # vx = np.cos(t) * dx + np.sin(t) * dy # vy = -np.sin(t) * dx + np.cos(t) * dy vx = x * (3 - 5 * y) #x-rabbit vy = y * (2 * x - 1) #y-fox return np.array([vx, vy]) #=[vy,vx] return fn VectorField = scene.visuals.create_visual_node(VectorFieldVisual) canvas = scene.SceneCanvas(size=[1600, 1600], keys='interactive', show=True) gloo.set_state( # # clear_color=(0.30, 0.30, 0.35, 1.00), # # polygon_offset=(1, 1), # # blend_func=('src_alpha', 'one_minus_src_alpha'), line_width=2, ) view = canvas.central_widget.add_view(camera='panzoom') view.camera.set_range() view.camera.rect = (0, 0, 100, 100) # text = scene.visuals.Text("Hello world", # color='w',anchor_x='left', # parent=view, pos=(20, 30)) field = np.fromfunction(getFn(0.0, 5, 100, 0.0, 5, 100),
# -*- coding: utf-8 -*- # vispy: gallery 30 # ----------------------------------------------------------------------------- # Copyright (c) Vispy Development Team. All Rights Reserved. # Distributed under the (new) BSD License. See LICENSE.txt for more info. # ----------------------------------------------------------------------------- """ Simple use of SceneCanvas to display an Isocurve visual. """ import sys from vispy import app, scene, visuals from vispy.util.filter import gaussian_filter import numpy as np canvas = scene.SceneCanvas(keys='interactive', title='Isocurve(s) overlayed ' 'over Random Image Example') canvas.size = 800, 600 canvas.show() # Set up a viewbox to display the image with interactive pan/zoom view = canvas.central_widget.add_view() # Create the image img_data = np.empty((200, 100, 3), dtype=np.ubyte) noise = np.random.normal(size=(200, 100), loc=50, scale=150) noise = gaussian_filter(noise, (4, 4, 0)) img_data[:] = noise[..., np.newaxis] image = scene.visuals.Image(img_data, parent=view.scene) # move image behind curves image.transform = visuals.transforms.STTransform(translate=(0, 0, 0.5))
def scatter_plot_voxels(gridLabels, suncg_labels, vox_min, vox_unit, save_path=None, animate=False): nbr_classes = len(suncg_labels) occMask = gridLabels > 0 xyz = np.nonzero(occMask) positions = np.vstack([xyz[0], xyz[1], xyz[2]]) gridLabelsMasked = gridLabels[occMask] canvas = scene.SceneCanvas(keys='interactive', bgcolor='w', size=(1920, 1080)) view = canvas.central_widget.add_view() azimuth = 30 view.camera = scene.TurntableCamera(up='y', distance=4, fov=70, azimuth=azimuth, elevation=30.) # Sample colormap and adjust alpha colormap = get_colormap('hsl', value=1.0, saturation=0.8, ncolors=nbr_classes) pos_color = np.zeros((positions.shape[1], 4)) cm_sampled = [] for i, (iclass, sample_f) in enumerate( zip(suncg_labels[1:], np.linspace(0, 1, nbr_classes - 1))): if iclass.lower() in ('floor', 'wall', 'window'): alpha = 0.5 elif iclass.lower() == 'ceiling': alpha = 0.0 else: alpha = 1.0 base_color = colormap[sample_f].rgba.flatten() base_color[3] = alpha pos_color[i == gridLabelsMasked] = base_color Scatter3D = scene.visuals.create_visual_node(visuals.MarkersVisual) p1 = Scatter3D(parent=view.scene) p1.set_gl_state('translucent', blend=True, depth_test=True) p1.set_data(positions.T, face_color=pos_color, symbol='disc', size=10, edge_width=0.5, edge_color='k') p1.transform = scene.transforms.MatrixTransform() p1.transform.scale(3 * [vox_unit]) p1.transform.translate(3 * [-vox_unit * gridLabels.shape[0] / 2.0]) if save_path is None: return def make_frame(t): view.camera.set_state({'azimuth': azimuth + t * 90}) return canvas.render() if animate: animation = VideoClip(make_frame, duration=3) animation.write_gif('voxel.gif', fps=8, opt='OptimizePlus') else: img = canvas.render() cv2.imwrite('voxel.png', img[::-1])
dtype=np.float32) faces = np.array([(0, 3, 2), (0, 2, 1)], dtype=np.uint32) texture = np.array([((1.0, 0.0, 0.0), (0.0, 1.0, 0.0)), ((0.0, 0.0, 1.0), (1.0, 1.0, 1.0))], dtype=np.float32) textureCoordinates = np.array([(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)], dtype=np.float32) # Add mesh as VisPy node TriangleMesh = scene.visuals.create_visual_node(TriangleMeshVisual) # Create a new OpenGL window plt = scene.SceneCanvas(keys='interactive', size=(1024, 768)) view = plt.central_widget.add_view(bgcolor=(0.2, 0.2, 0.2), border_color=(0.0, 0.0, 0.0), border_width=1) # Add and configure camera view.camera = scene.cameras.ArcballCamera(fov=0) view.camera.center = (0.5, 0.0, 0.5) mesh = TriangleMesh(vertices, faces, texture=texture, textureCoordinates=textureCoordinates, vertexShader=defaultVertexShaderWithTexture, fragmentShader=defaultFragmentShaderWithTexture,
self.ptr = (self.ptr + 1) % self._shape[1] self.update() def _prepare_draw(self, view): if self._need_vertex_update: self._build_vertex_data() if view._need_method_update: self._update_method(view) mic = MicrophoneRecorder() n_fft_frames = 8 fft_samples = mic.chunksize * n_fft_frames win = scene.SceneCanvas(keys='interactive', show=True, fullscreen=True) grid = win.central_widget.add_grid() view3 = grid.add_view(row=0, col=0, col_span=2, camera='panzoom', border_color='grey') image = ScrollingImage((1 + fft_samples // 2, 4000), parent=view3.scene) image.transform = scene.LogTransform((0, 10, 0)) # view3.camera.rect = (0, 0, image.size[1], np.log10(image.size[0])) view3.camera.rect = (3493.32, 1.85943, 605.554, 1.41858) view1 = grid.add_view(row=1, col=0, camera='panzoom', border_color='grey') view1.camera.rect = (-0.01, -0.6, 0.02, 1.2) gridlines = scene.GridLines(color=(1, 1, 1, 0.5), parent=view1.scene) scope = Oscilloscope(line_size=mic.chunksize, dx=1.0/mic.rate, parent=view1.scene)
row = [] vlines.append(row) for j in range(N): v = visuals.LineVisual(pos=data, color='w', method='gl') v.transform = visuals.transforms.STTransform(translate=(-1, 0), scale=scales) row.append(v) vcanvas = VisualCanvas(vlines, position=(400, 300), size=(800, 600), title="VisualCanvas") # Scenegraph version scanvas = scene.SceneCanvas(show=True, keys='interactive', title="SceneCanvas") scanvas.size = 800, 600 grid = scanvas.central_widget.add_grid(margin=0) lines = [] for i in range(10): lines.append([]) for j in range(10): vb = grid.add_view(camera='panzoom', row=i, col=j) vb.camera.set_range([0, 100], [-5, 5], margin=0) line = scene.visuals.Line(pos=data, color='w', method='gl') vb.add(line) scanvas.show()
from vispy import scene import numpy as np data = np.arange(1000).reshape((10, 10, 10)) canvas = scene.SceneCanvas(show=True) view = canvas.central_widget.add_view() axis = scene.visuals.XYZAxis(parent=view.scene) view.camera = scene.cameras.TurntableCamera(parent=view.scene) with canvas: canvas.render()
from vispy import app, scene import numpy as np from gta import GTAData filename = 'data/gta_test/3fd50f7b-658b-4ef4-bb17-dfc1f287def8_00000819' data = GTAData(filename) bbox_edges = [] for v in data.vehicles: bbox_edges.extend(v.get_3d_bbox_edges()) # Create a canvas with a 3D viewport canvas = scene.SceneCanvas(keys='interactive', title='GTA Scene', bgcolor='white') canvas.show() view = canvas.central_widget.add_view() # Add vehicle bounding box to view if len(bbox_edges) > 0: scene.visuals.Line(pos=np.array(bbox_edges), color=(0.2, 0.5, 0.3, 1), connect='segments', parent=view.scene) scene.visuals.XYZAxis(parent=view.scene) # Add point cloud c_pos_marker = scene.visuals.Markers(parent=view.scene) cloud = np.array(data.load_depth()) cloud = cloud[np.all([-100,-100,-70] < cloud, axis=1), :]
import sys import numpy as np from vispy import app, scene from vispy.util.filter import gaussian_filter canvas = scene.SceneCanvas(keys='interactive', bgcolor='w') view = canvas.central_widget.add_view() view.camera = scene.TurntableCamera(up='z', fov=60) # Simple surface plot example # x, y values are not specified, so assumed to be 0:50 z = np.random.normal(size=(160, 120), scale=200) z[100, 100] += 50000 z = gaussian_filter(z, (10, 10)) p1 = scene.visuals.SurfacePlot(z=z, color=(0.3, 0.3, 1, 1), shading='flat') p1.transform = scene.transforms.MatrixTransform() p1.transform.scale([1 / 249., 1 / 249., 1 / 249.]) p1.transform.translate([-0.5, -0.5, 0]) view.add(p1) # p1._update_data() # cheating. # cf = scene.filters.ZColormapFilter('fire', zrange=(z.max(), z.min())) # p1.attach(cf) xax = scene.Axis(pos=[[-0.5, -0.5], [0.5, -0.5]], tick_direction=(0, -1), font_size=16, axis_color='k', tick_color='k',
atoms = [atom for atom in structure.get_atoms()] natoms = len(atoms) #atom coordinates coordinates = np.array([atom.coord for atom in atoms]) center = centroid(coordinates) coordinates -= center #atom color color = [colorrgba(atom.get_id()) for atom in atoms] #atom radius radius = [vrad(atom.get_id()) for atom in atoms] W, H = 1200, 800 MySpheres = scene.visuals.create_visual_node(MySpheresVisual) canvas = scene.SceneCanvas(keys='interactive', app='pyqt4', bgcolor='black', size=(W, H), show=True) view = canvas.central_widget.add_view() view.camera = 'arcball' spheres = [ MySpheres(coordinates[0], color[0], radius[0], W, H, parent=view.scene) ] canvas.app.run()
from vispy import app, scene # vertex positions of data to draw N = 200 pos = np.zeros((N, 2), dtype=np.float32) x_lim = [50., 750.] y_lim = [-2., 2.] pos[:, 0] = np.linspace(x_lim[0], x_lim[1], N) pos[:, 1] = np.random.normal(size=N) # color array color = np.ones((N, 4), dtype=np.float32) color[:, 0] = np.linspace(0, 1, N) color[:, 1] = color[::-1, 0] canvas = scene.SceneCanvas(keys='interactive', show=True) grid = canvas.central_widget.add_grid(spacing=0) viewbox = grid.add_view(row=0, col=1, camera='panzoom') # add some axes x_axis = scene.AxisWidget(orientation='bottom') x_axis.stretch = (1, 0.1) grid.add_widget(x_axis, row=1, col=1) x_axis.link_view(viewbox) y_axis = scene.AxisWidget(orientation='left') y_axis.stretch = (0.1, 1) grid.add_widget(y_axis, row=0, col=0) y_axis.link_view(viewbox) # add a line plot inside the viewbox
def __init__(self, axis=False, title=None, xlabel=None, ylabel=None, title_font_size=15., axis_font_size=12., axis_color='black', tick_font_size=10., name=None, x_height_max=80, y_width_max=80, axis_label_margin=50, tick_label_margin=5, rpad=20., bgcolor='white', add_cbar=False, cargs={}, xargs={}, yargs={}, cbargs={}, show=False, camera=None, shortcuts={}): """Init.""" self._axis = axis self._title = title self._xlabel = xlabel self._ylabel = ylabel self._title_font_size = title_font_size self._axis_font_size = axis_font_size self._axis_color = axis_color self._tick_font_size = tick_font_size self._name = name self._x_height_max = x_height_max self._y_width_max = y_width_max self._axis_label_margin = axis_label_margin self._tick_label_margin = tick_label_margin self._bgcolor = bgcolor self._visible = show # ########################## MAIN CANVAS ########################## self.canvas = scene.SceneCanvas(keys='interactive', bgcolor=bgcolor, show=show, title=name, **cargs) # ########################## AXIS ########################## if axis: # add axis to canvas # ----------- GRID ----------- grid = self.canvas.central_widget.add_grid(margin=10) grid.spacing = 0 # ----------- COLOR ----------- axcol = color2vb(axis_color) kw = { 'axis_label_margin': axis_label_margin, 'tick_label_margin': tick_label_margin, 'axis_font_size': axis_font_size, 'axis_color': axcol, 'tick_color': axcol, 'text_color': axcol, 'tick_font_size': tick_font_size } # ----------- TITLE ----------- self._titleObj = scene.Label(title, color=axcol, font_size=title_font_size) self._titleObj.height_max = 40 grid.add_widget(self._titleObj, row=0, col=0, col_span=2) # ----------- Y-AXIS ----------- yargs.update(kw) self.yaxis = scene.AxisWidget(orientation='left', domain=(0, 129), axis_label=ylabel, **yargs) self.yaxis.width_max = y_width_max grid.add_widget(self.yaxis, row=1, col=0) # ----------- X-AXIS ----------- xargs.update(kw) self.xaxis = scene.AxisWidget(orientation='bottom', axis_label=xlabel, **xargs) self.xaxis.height_max = x_height_max grid.add_widget(self.xaxis, row=2, col=1) # ----------- MAIN ----------- self.wc = grid.add_view(row=1, col=1, camera=camera) self.grid = grid # ----------- LINK ----------- self.xaxis.link_view(self.wc) self.yaxis.link_view(self.wc) # ----------- CBAR ----------- rpad_col = 0 if add_cbar: self.wc_cbar = grid.add_view(row=1, col=2) self.wc_cbar.width_max = 150. self.cbar = CbarVisual(width=.2, parent=self.wc_cbar.scene) rpad_col += 1 # ----------- RIGHT PADDING ----------- self._rpad = grid.add_widget(row=1, col=2 + rpad_col, row_span=1) self._rpad.width_max = rpad else: # Ignore axis self.wc = self.canvas.central_widget.add_view(camera=camera)
# -*- coding: utf-8 -*- # ----------------------------------------------------------------------------- # Copyright (c) 2015, Vispy Development Team. All Rights Reserved. # Distributed under the (new) BSD License. See LICENSE.txt for more info. # ----------------------------------------------------------------------------- # vispy: gallery 2 """ Demonstrating two scenes that share the same camera view by linking the cameras. """ import numpy as np from vispy import app, scene, io canvas = scene.SceneCanvas(keys='interactive') canvas.size = 800, 600 canvas.show() # Create two ViewBoxes, place side-by-side vb1 = scene.widgets.ViewBox(border_color='yellow', parent=canvas.scene) vb2 = scene.widgets.ViewBox(border_color='blue', parent=canvas.scene) # grid = canvas.central_widget.add_grid() grid.padding = 6 grid.add_widget(vb1, 0, 0) grid.add_widget(vb2, 0, 1) # Create the image im1 = io.load_crate().astype('float32') / 255 # Make gray, smooth, and take derivatives: edge enhancement
''' mode_MSB = (mode << 5) + (polarity << 4) + (den << 3) + ( iovalue << 1) + data_length mode_LSB = (reference << 7) + (0b0 << 6) + (input_range << 4) + ( clock_enable << 3) + (burn_out << 2) + channel self.single_write(self.AD7730_MODE_REG, [mode_MSB, mode_LSB]) def setFilter(self): data = self.single_read(self.AD7730_FILTER_REG) data[2] = data[2] | 0b00110011 self.single_write(self.AD7730_FILTER_REG, data) return data canvas = scene.SceneCanvas(keys='interactive', show=True, size=(1024, 768)) grid = canvas.central_widget.add_grid() view = grid.add_view(0, 1) view.camera = scene.MagnifyCamera(mag=1, size_factor=0.5, radius_ratio=0.6) # Add axes yax = scene.AxisWidget(orientation='left') yax.stretch = (0.05, 1) grid.add_widget(yax, 0, 0) yax.link_view(view) xax = scene.AxisWidget(orientation='bottom') xax.stretch = (1, 0.05) grid.add_widget(xax, 1, 1) xax.link_view(view)