def on_draw(self, event): with self._fbo: gloo.clear('black') gloo.set_viewport(0, 0, *self.size) self.program.draw() self.im = self._fbo.read() app.quit()
def key_event(event): if event.key.name == 'Escape': app.quit() if event.key.name == 'P': print("Added point") tr = view.node_transform(image) x, y = tr.map(app.current_pos)[:2] c, r = int(x), int(y) points.append(np.array((r, c))) update_drawing() if event.key.name == 'D': tr = view.node_transform(image) x, y = tr.map(app.current_pos)[:2] c, r = int(x), int(y) deltas = np.array(points) - np.array((r, c)) sq_dists = np.sum(deltas * deltas, axis=1) del points[np.argmin(sq_dists)] update_drawing() if event.key.name == 'S': df = pd.DataFrame(points, columns=['X', 'Y']) df.to_csv(output_fpath, index=False)
def update_vertices(ev, *args): global vis, timescale, canvas, frames, lag, paused, record, start_shot, started_shot, finished_shot if not paused: index = int((ev.count - lag) / timescale) % vis.frames vis.set_vertex_data(index) if start_shot and index == 0: if started_shot: finished_shot = True print("Start round") record = True started_shot = True else: lag += 1 if record: im = canvas.render() frames.append(im) if finished_shot: print("Start saving") record = False can_record = False app.quit() canvas.close() print("Saving...") write_recording()
def on_draw(self, event): self.program['iGlobalTime'] += 1.0 / self._rate self.program.draw() if self._duration is not None and self.program[ 'iGlobalTime'] >= self._duration: app.quit()
def on_timer(self,event): if self.animation is not None: self.t = 2.0 - (default_timer() - self.t0) / 10.0 if self.t < 2.0 and self.t > 0.0: self.animation(self) else: app.quit()
def on_draw(self, event): if self.render_rgb: self.draw_color() # Render color image if self.render_depth: self.draw_depth() # Render depth image if self.render_normal: self.draw_normal() # Render normal image app.quit() # Immediately exit the application after the first drawing
def draw(self): if self._glsl: fragment = fragment_template % self._glsl self._glsl = None # Check to see if the shader will compile successfully before we # set it. We do this here because the ShaderWatcher runs in a # different thread and so can't access the GL context. frag_handle = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(frag_handle, fragment) gl.glCompileShader(frag_handle) status = gl.glGetShaderParameter(frag_handle, gl.GL_COMPILE_STATUS) if not status: errors = gl.glGetShaderInfoLog(frag_handle) errors = self.process_errors(errors) print("Shader failed to compile:", file=sys.stderr) print(errors, file=sys.stderr) # Switch to error shader self._glsl = error_shader self.update() else: self.program.set_shaders(vertex, fragment) gl.glDeleteShader(frag_handle) if self._interactive: self.program.draw() if self._ffmpeg_pipe is not None: img = _screenshot() self.write_video_frame(img) self._render_frame_index += 1 if self._render_frame_count is not None and self._render_frame_index >= self._render_frame_count: app.quit() return self.advance_time() else: with self._fbo: rs = list(self._render_size) if self._tile_coord[0] + rs[0] > self._output_size[0]: rs[0] = self._output_size[0] - self._tile_coord[0] if self._tile_coord[1] + rs[1] > self._output_size[1]: rs[1] = self._output_size[1] - self._tile_coord[1] gloo.set_viewport(0, 0, *rs) self.program['iOffset'] = self._tile_coord self.program.draw() img = _screenshot() row = self._output_size[1] - self._tile_coord[1] - rs[1] col = self._tile_coord[0] self._img[row:row + rs[1], col:col + rs[0], :] = img
def on_draw(self, event): self.program['iGlobalTime'] += 1.0 / self._rate self.program.draw() if self._stdout is not None: framebuffer = vispy.gloo.util._screenshot((0, 0, self.physical_size[0], self.physical_size[1])) self._stdout.write(framebuffer.tobytes()) if self._duration is not None and self.program['iGlobalTime'] >= self._duration: app.quit()
def on_draw(self, event): # Render in the FBO. with self._fbo: gloo.clear((1,1,1,1)) gloo.set_viewport(0, 0, *self.true_size) self.program.draw(gl.GL_TRIANGLE_STRIP) # Retrieve the contents of the FBO texture. self.shadowsArray = _screenshot((0, 0, self.true_size[0], self.true_size[1])) # Immediately exit the application. app.quit()
def on_timer(self, event): if self._interactive: self.update() else: # update() doesn't call on_draw() if window is hidden under some toolkits, # so call draw() directly self.draw() # update tiles self._tile_index += 1 clock_time_elapsed = time.clock() - self._clock_time_start rendered_tile_count = self._tile_index + self._render_frame_index * self._tile_count total_tile_count = self._tile_count * self._render_frame_count clock_time_per_tile = clock_time_elapsed / float( rendered_tile_count) clock_time_total = clock_time_per_tile * total_tile_count clock_time_remain = clock_time_total - clock_time_elapsed print("Tile %d / %d (%.2f%%); %s elapsed; %s remaining; %s total" % \ (rendered_tile_count, total_tile_count, rendered_tile_count * 100.0 / total_tile_count, str(datetime.timedelta(seconds=round(clock_time_elapsed))), str(datetime.timedelta(seconds=round(clock_time_remain))), str(datetime.timedelta(seconds=round(clock_time_total))))) if self._tile_index == self._tile_count: if self._ffmpeg_pipe: self.write_video_frame(self._img) self._render_frame_index += 1 if self._render_frame_count is not None and self._render_frame_index >= self._render_frame_count: app.quit() return # Reset tile indices self._tile_index = 0 self._tile_coord = [0, 0] self.advance_time() else: self.write_img(self._img, self._output) app.quit() return else: self._tile_coord[0] += self._render_size[0] if self._tile_coord[0] >= self._output_size[0]: self._tile_coord[0] = 0 self._tile_coord[1] += self._render_size[1] if self._progress_file: self.write_img(self._img, self._progress_file)
def on_timer(self, event): if self._interactive: self.update() else: # update() doesn't call on_draw() if window is hidden under some toolkits, # so call draw() directly self.draw() # update tiles self._tile_index += 1 clock_time_elapsed = time.clock() - self._clock_time_start rendered_tile_count = self._tile_index + self._render_frame_index * self._tile_count total_tile_count = self._tile_count * self._render_frame_count clock_time_per_tile = clock_time_elapsed / float(rendered_tile_count) clock_time_total = clock_time_per_tile * total_tile_count clock_time_remain = clock_time_total - clock_time_elapsed print("Tile %d / %d (%.2f%%); %s elapsed; %s remaining; %s total" % \ (rendered_tile_count, total_tile_count, rendered_tile_count * 100.0 / total_tile_count, str(datetime.timedelta(seconds=round(clock_time_elapsed))), str(datetime.timedelta(seconds=round(clock_time_remain))), str(datetime.timedelta(seconds=round(clock_time_total))))) if self._tile_index == self._tile_count: if self._ffmpeg_pipe: self.write_video_frame(self._img) self._render_frame_index += 1 if self._render_frame_count is not None and self._render_frame_index >= self._render_frame_count: app.quit() return # Reset tile indices self._tile_index = 0 self._tile_coord = [0, 0] self.advance_time() else: self.write_img(self._img, self._output) app.quit() return else: self._tile_coord[0] += self._render_size[0] if self._tile_coord[0] >= self._output_size[0]: self._tile_coord[0] = 0 self._tile_coord[1] += self._render_size[1] if self._progress_file: self.write_img(self._img, self._progress_file)
def on_draw(self, event): # Render in the FBO. with self._fbo: gloo.clear('black') gloo.set_viewport(0, 0, *self.size) self.program.draw() # Retrieve the contents of the FBO texture. self.im = _screenshot((0, 0, self.size[0], self.size[1])) self._time = time() - self._t0 # Immediately exit the application. app.quit()
def on_draw(self, event): if self.render_rgb: self.draw_color() # Render color image if self.render_depth: self.draw_depth() # Render depth image if self.render_obj_coords: self.draw_obj_coords() if self.render_segmentation: self.draw_segmentation() if self.render_bounding_boxes: self.draw_bounding_boxes() app.quit() # Immediately exit the application after the first drawing
def on_draw(self, event): with self._fbo: gloo.clear('black') self.program.bind(self.verts_buf) self.program.draw('triangles', self.tris_buf) # Retrieve depth # For some reason, vispy flipuds images in read_pixels, so we # unflip here. This is inefficient but vispy-compatible self.depth = read_fbo_color_rgba32f(self._fbo) self.depth = np.flipud(self.depth) self._time = time() - self._t0 app.quit()
def on_draw(self, event): # Render in the FBO. with self._fbo: gloo.clear('black') gloo.set_viewport(0, 0, *self.size) self.program.draw() # Retrieve the contents of the FBO texture. self.im = read_pixels((0, 0, self.size[0], self.size[1]), True, out_type='float') self._time = time() - self._t0 # Immediately exit the application. app.quit()
def handle_key(ev): global timescale, record, can_record, frames, filename, canvas, paused, start_shot, view if ev.text == ']': # Increase speed timescale /= 2 print("Timescale is now", timescale) elif ev.text == '[': # Decrease speed timescale *= 2 print("Timescale is now", timescale) elif ev.text == 'r': # Start record if record: print("Already recording") elif can_record: record = True print("Started recording") # Measure fps canvas.measure_fps(callback=set_fps) else: print("Record is disabled") elif ev.text == 's': if can_record and record: record = False can_record = False app.quit() canvas.close() print("Saving...") write_recording() elif ev.text == 'f': canvas.size = (1920, 1080) elif ev.text == 'h': canvas.size = (1280, 720) elif ev.text == '=': vis.pointsize += 1 print(f"Pointsize is {vis.pointsize}") elif ev.text == '-': vis.pointsize -= 1 print(f"Pointsize is {vis.pointsize}") elif ev.text == ' ': if paused: print("Unpaused") else: print("Paused") paused = not paused elif ev.text == 'm': start_shot = True elif ev.text == 'z': view.camera.distance *= 0.9 elif ev.text == 'x': view.camera.distance *= 1.1
def vispar(): def _exeval(f, *x, **y): nonlocal _error assert _done == _todo == [] # _todo.insert(0,fog(print,'Hello wurlzy')) _todo.insert(0, fog(f, *x, **y)) while not _done and not _error: pass assert _todo == [] if _error: assert not _done temp = _error _error = None raise temp out = _done.pop() assert not _done return out def _exec(*x, **y): return _exeval(exec, *x, **y) def _eval(*x, **y): return _exeval(eval, *x, **y) _error = None _todo = [] _done = [] # Results of _todo import rp.r_iterm_comm as ric _level = ric.pseudo_terminal_level run_as_new_thread(pseudo_terminal, globals(), exec=_exec, eval=_eval) while ric.pseudo_terminal_level == _level: pass while 1: if ric.pseudo_terminal_level == _level: break try: from vispy import app app.process_events() except: print("harry potwar strikes again! keep chuggin...") pass if _todo: try: _done.append(_todo.pop()()) except BaseException as e: _error = e assert not _todo print('...aaaannndddd were DONE chuggin.') app.quit( ) # NOT nessecary but PERHAPS its nicer than having a crashy window...make this optional though!!!
def key_event(event): app.tags[app.current_id] = key_to_tag[event.key.name] try: im, app.current_id = next(app.image_generator) app.image.set_data(im) app.counter += 1 textstr = "Image {}".format(app.counter) app.t1.text = textstr canvas.update() except StopIteration: app.dataset.put_overlay("classes", app.tags) app.quit()
def on_draw(self, event): if args.outputfile: faces = [[0, 0], [90, 0], [180, 0], [270, 0], [0, 90], [0, 270]] self.model = numpy.dot(rotate(faces[args.faces - 1][0], (0, 0, 1)), rotate(faces[args.faces - 1][0], (0, 1, 0))) self.shader_nodes['u_model'] = self.model self.shader_traces['u_model'] = self.model gloo.clear() self.program = self.shader_nodes self.program.draw('points') self.program = self.shader_traces self.program.draw('lines') if args.outputfile: self.im = _screenshot((0, 0, self.size[0], self.size[1])) app.quit()
def exit(*args, **kwargs): """Exit the sketch. `exit()` overrides Python's builtin exit() function and makes sure that necessary cleanup steps are performed before exiting the sketch. :param args: positional argumets to pass to Python's builtin `exit()` function. :param kwargs: keyword-arguments to pass to Python's builtin `exit()` function. """ default_sketch.show(visible=False) app.quit() builtins.exit(*args, **kwargs)
def exit(*args, **kwargs): """Exit the sketch. `exit()` overrides Python's builtin exit() function and makes sure that necessary cleanup steps are performed before exiting the sketch. :param args: positional argumets to pass to Python's builtin `exit()` function. :param kwargs: keyword-arguments to pass to Python's builtin `exit()` function. """ if not (p5.sketch is None): if builtins.current_renderer == "vispy": from vispy import app p5.sketch.show(visible=False) app.quit() p5.exit(*args, **kwargs)
def on_draw(self, event): max_quality = max(float(q.text) for q in self.quality) logger.debug("Signal quality is %.2f" % max_quality) if max_quality > SIGNAL_QUALITY_THRESHOLD: logger.debug("Signal quality poor, counter reset") self.quality_count = 0 else: self.quality_count += 1 logger.debug(f"Signal quality counter at {self.quality_count}") if self.quality_count >= SIGNAL_STABILITY_COUNT: logger.info("Signal stabilized!") return app.quit() super().on_draw(event)
def on_draw(self, event): main() app.quit()
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 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 draw(self): for i in range(4): if self._bufXglsl[i]: fragment = fragment_template % self._bufXglsl[i] self._bufXglsl[i] = None frag_handle = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(frag_handle, fragment) gl.glCompileShader(frag_handle) status = gl.glGetShaderParameter(frag_handle, gl.GL_COMPILE_STATUS) if not status: errors = gl.glGetShaderInfoLog(frag_handle) errors = self.process_errors(errors) print('Shader failed to compile:', file=sys.stderr) print(errors, file=sys.stderr) exit(1) else: self._BufX[i].set_shaders(vertex, fragment) gl.glDeleteShader(frag_handle) if self._glsl: fragment = fragment_template % self._glsl self._glsl = None # Check to see if the shader will compile successfully before we # set it. We do this here because the ShaderWatcher runs in a # different thread and so can't access the GL context. frag_handle = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(frag_handle, fragment) gl.glCompileShader(frag_handle) status = gl.glGetShaderParameter(frag_handle, gl.GL_COMPILE_STATUS) if not status: errors = gl.glGetShaderInfoLog(frag_handle) errors = self.process_errors(errors) print('Shader failed to compile:', file=sys.stderr) print(errors, file=sys.stderr) exit(1) # Switch to error shader self._glsl = error_shader self.update() else: self.program.set_shaders(vertex, fragment) gl.glDeleteShader(frag_handle) if self._interactive: for i in range(4): with self._fboX[self._doubleFboid][i]: gloo.set_clear_color((0.0, 0.0, 0.0, 0.0)) gloo.clear(color=True, depth=True) gloo.set_viewport(0, 0, *self.physical_size) self._BufX[i].draw() self.program.draw() if self._ffmpeg_pipe is not None: img = _screenshot() self.write_video_frame(img) self._render_frame_index += 1 if self._render_frame_count is not None \ and self._render_frame_index \ >= self._render_frame_count: app.quit() return self._doubleFbo = not self._doubleFbo self._doubleFboid=(0 if self._doubleFbo else 1) self.advance_time() self.program['iFrame'] = self._render_frame_index self.set_Buf_uniform('iFrame' , self._render_frame_index) self.set_channel_input() self.set_Buf_channel_input() else: for i in range(4): with self._fboX[self._doubleFboid][i]: gloo.set_clear_color((0.0, 0.0, 0.0, 0.0)) gloo.clear(color=True, depth=True) gloo.set_viewport(0, 0, *self.physical_size) self._BufX[i].draw() with self._fbo: rs = list(self._render_size) if self._tile_coord[0] + rs[0] > self._output_size[0]: rs[0] = self._output_size[0] - self._tile_coord[0] if self._tile_coord[1] + rs[1] > self._output_size[1]: rs[1] = self._output_size[1] - self._tile_coord[1] gloo.set_viewport(0, 0, *rs) self.program['iOffset'] = self._tile_coord self.program.draw() self._doubleFbo = not self._doubleFbo self._doubleFboid=(0 if self._doubleFbo else 1) self.program['iFrame'] = self._render_frame_index self.set_Buf_uniform('iFrame' , self._render_frame_index) self.set_channel_input() self.set_Buf_channel_input() img = _screenshot() row = self._output_size[1] - self._tile_coord[1] - rs[1] col = self._tile_coord[0] self._img[row:row + rs[1], col:col + rs[0], :] = img
def on_close(self, event): app.quit() super().on_close(event)
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, **kwargs): """ Visualization of the stimulus as a cube """ if not(os.path.isdir(figpath)): os.mkdir(figpath) 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 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 = scene.transforms.MatrixTransform() 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 = scene.transforms.MatrixTransform() 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 = scene.transforms.MatrixTransform() 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 on_close(self, event): app.quit()
def quit(self): app.quit()
def on_draw(self, event): self.program['iGlobalTime'] += 1.0 / self._rate self.program.draw() if self._duration is not None and self.program['iGlobalTime'] >= self._duration: app.quit()
return _screenshot((0,0,canvas.size[0],canvas.size[1]))[:,:,:3] #animation = VideoClip(make_frame, duration=5).resize(width=350) #animation = VideoClip(make_frame, duration=5).resize(width=800,height=600) animation = VideoClip(make_frame, duration=10) #animation.write_gif('otto.gif', fps=2, opt='OptimizePlus') animation.write_videofile("surfVideo.webm",preset="medium",fps=20,audio=False) ######### close canvas only here ... app.process_events() canvas.close() app.process_events() app.quit() #try to create sound version ... audioclip = AudioFileClip("../data/zkmaudio.wav") videoclip = VideoFileClip("surfVideo.webm") l = videoclip.duration print("video length:",l) audio = audioclip.set_duration(l) # same length as video videoclip.set_audio(audio) #textclip = TextClip("ZKM Open Codes", fontsize=20, color='white').set_pos("center","center") # get font list with: #TextClip.list("font") # we could also add the text directly, see above textclip = TextClip("ZKM Open Codes", font="FreeSans",fontsize=40, color='white',method='label') t = textclip.set_duration(l) # compose everything. make sure to set audio here!
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, **kwargs): """ Visualization of the Fourier spectrum by showing 3D contour plots at different thresholds parameters ---------- z : envelope of the cloud """ if not(os.path.isdir(figpath)): os.mkdir(figpath) 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 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) fourier_xy = scene.visuals.Image(np.rot90(energy_xy), **opts) tr_xy = scene.transforms.MatrixTransform() 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) fourier_xt = scene.visuals.Image(energy_xt, **opts) tr_xt = scene.transforms.MatrixTransform() 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 = scene.transforms.MatrixTransform() 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(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 receive_data(sock, canvas): global joints_coordinates global points global trajectory global env_number global point global joint global traject global view global stop stop = False obj_number = 0 while not stop: msg_byte, user = udp.recvfrom(1024) msg_list = json.loads(msg_byte) msg = np.array(msg_list) if msg[2] == 2: stop = True app.quit() sock.close() elif msg[2] == 3: env_number = int(msg[0]) if env_number == 1: env_shape = (1, 1) else: env_shape = msg[3] obj_number = int(msg[1]) joints_coordinates = np.empty((env_number, 4, 3)) points = np.empty((env_number, msg[1], 3)) trajectory = [np.empty((1, 3)) for _ in range(env_number)] view = canvas.central_widget.add_view() camera = scene.cameras.TurntableCamera(fov=100) camera.set_range((90, -90, -90), (-90, 90, -90), (90, -90, -90)) view.camera = camera threads = [] line, column = 0, 0 for i in range(env_number): point.append(visuals.Markers()) joint.append(visuals.LinePlot()) traject.append(visuals.Markers()) x = column*105 y = line*105 threads.append(threading.Thread(target=update, args=(i, x, y, obj_number))) if column < (env_shape[1]-1): column += 1 else: line += 1 column = 0 view.add(point[i]) view.add(joint[i]) view.add(traject[i]) threads[i].setDaemon(True) threads[i].start() elif msg[2] == 4: trajectory = [np.empty((1, 3)) for _ in range(env_number)] else: ide = int(msg[0]) msg = msg.reshape(-1, 3) index = msg[0, :] joints_coordinates[ide] = msg[1:5, :] points[ide] = msg[5:5+obj_number, :] if index[2] == 1: trajectory[ide] = np.array([0.0, 0.0, 51.3]) trajectory[ide] = np.vstack((trajectory[ide], msg[-1, :])) time.sleep(0.005)
def run_simulation(self): global_step = 0 level_step_counter = 1e10 current_net = self.net current_net.to(self.device) last_positions = self.net.positions pos_max = self.pos_max pos_min = self.pos_min centering = self.centering while True: position_change = torch.mean( torch.norm(current_net.positions - last_positions, 2, dim=1)) last_positions = current_net.positions.clone() if position_change < 0.001 and level_step_counter > self.min_num_steps: print("move to new level") level_step_counter = 0 if global_step > 0: current_net = current_net.give_positions_to_parent( perturbation=0.1) if current_net is None: break last_positions = current_net.positions.clone() current_net.to(self.device) centering = min( self.max_centering, centering + self.additional_centering_per_level) print("positions:", last_positions.shape, "centering:", centering) layout = NetworkForceLayout( current_net, spring_optimal_distance=1., attraction_normalization=0., repulsion=1., step_size=self.step_size, step_discount_factor=self.step_discount_factor, centering=centering, drag=0.2, noise=0., mac=0.5, num_dim=2, force_limit=1., distance_exponent=self.distance_exponent, device=self.device) for i in range(self.steps_per_frame): layout.simulation_step() level_step_counter += 1 global_step += 1 positions = layout.x.cpu().numpy()[np.newaxis, :].copy() n_pos_max = np.max(positions) n_pos_min = np.min(positions) pos_max = self.range_gamma * n_pos_max + ( 1 - self.range_gamma) * pos_max pos_min = self.range_gamma * n_pos_min + ( 1 - self.range_gamma) * pos_min positions -= pos_min positions /= (pos_max - pos_min) positions = positions * 0.8 + 0.1 if self.plot_connections: edges = np.zeros((current_net.num_connections * 3, 3), dtype=np.float32) edges[0::3, :2] = positions[ 0, current_net.connections[:, 0].cpu(), :] edges[1::3, :2] = positions[ 0, current_net.connections[:, 1].cpu(), :] edges[2::3, :] = float('nan') edges[0::3, 2] = 1. edges[1::3, 2] = 1. edges = pd.DataFrame(data=edges) edges.columns = ['x', 'y', 'val'] edges_lines = self.ds_canvas.line( edges, 'x', 'y', agg=ds.sum('val')).values.astype(np.float32) edges_lines[edges_lines != edges_lines] = 0. edges_lines = pow(edges_lines / edges_lines.max(), 0.25) # edges_lines = gaussian_filter(edges_lines, sigma=0.8) self.viz.edge_textures = edges_lines[np.newaxis, :, :] self.viz.set_new_node_positions( positions, new_weights=current_net.weights[None, :].cpu().numpy()) self.viz.update() # time.sleep(0.1) self.layout = layout.x.cpu().numpy() app.quit()