def __init__(self, scale=500, filt=True): app.Canvas.__init__(self, title='EEG - Use your wheel to zoom!', keys='interactive') self.program = gloo.Program(VERT_SHADER, FRAG_SHADER) self.program['a_position'] = y.reshape(-1, 1) self.program['a_color'] = color self.program['a_index'] = index self.program['u_scale'] = (1., 1.) self.program['u_size'] = (nrows, ncols) self.program['u_n'] = n # text self.font_size = 48. self.names = [] self.quality = [] for ii in range(n_chan): text = visuals.TextVisual(ch_names[ii], bold=True, color='white') self.names.append(text) text = visuals.TextVisual('', bold=True, color='white') self.quality.append(text) self.quality_colors = color_palette("RdYlGn", 11)[::-1] self.scale = scale self.n_samples = n_samples self.filt = filt self.af = [1.0] self.data_f = np.zeros((n_samples, n_chan)) self.data = np.zeros((n_samples, n_chan)) self.bf = create_filter(self.data_f.T, sfreq, 3, 40., method='fir', fir_design='firwin') zi = lfilter_zi(self.bf, self.af) self.filt_state = np.tile(zi, (n_chan, 1)).transpose() self._timer = app.Timer('auto', connect=self.on_timer, start=True) gloo.set_viewport(0, 0, *self.physical_size) gloo.set_state(clear_color='black', blend=True, blend_func=('src_alpha', 'one_minus_src_alpha')) self.show()
def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 800), show=True) # Create several visuals demonstrating different features of Line self.lines = [ # agg-mode lines: # per-vertex color visuals.LineVisual(pos=pos, color=color, mode='agg'), # solid visuals.LineVisual(pos=pos, color=(0, 0.5, 0.3, 1), mode='agg'), # wide visuals.LineVisual(pos=pos, color=color, width=5, mode='agg'), # GL-mode lines: visuals.LineVisual(pos=pos, color=color, mode='gl'), visuals.LineVisual(pos=pos, color=(0, 0.5, 0.3, 1), mode='gl'), visuals.LineVisual(pos=pos, color=color, width=5, mode='gl'), # GL-mode: "connect" not available in AGG mode yet # only connect alternate vert pairs visuals.LineVisual(pos=pos, color=(0, 0.5, 0.3, 1), connect='segments', mode='gl'), # connect specific pairs visuals.LineVisual(pos=pos, color=(0, 0.5, 0.3, 1), connect=connect, mode='gl'), ] counts = [0, 0] for i, line in enumerate(self.lines): # arrange lines in a grid tidx = (line.mode == 'agg') x = 400 * tidx y = 140 * (counts[tidx] + 1) counts[tidx] += 1 line.transform = STTransform(translate=[x, y]) # redraw the canvas if any visuals request an update line.events.update.connect(lambda evt: self.update()) self.texts = [visuals.TextVisual('GL', bold=True, font_size=24, color='w', pos=(200, 40)), visuals.TextVisual('Agg', bold=True, font_size=24, color='w', pos=(600, 40))] for text in self.texts: text.transform = NullTransform() self.visuals = self.lines + self.texts # create a TransformSystem for each visual. # (these are stored as attributes of each visual for convenience) for visual in self.visuals: visual.tr_sys = visuals.transforms.TransformSystem(self) visual.tr_sys.visual_to_document = visual.transform
def __init__(self): app.Canvas.__init__(self, title='Bezier lines example', keys='interactive', size=(400, 750)) self.lines = [ visuals.LineVisual(curves.curve4_bezier((10, 0), (50, -190), (350, 190), (390, 0)), color='w', width=2, method='agg'), visuals.LineVisual(curves.curve4_bezier((10, 0), (190, -190), (210, 190), (390, 0)), color='w', width=2, method='agg'), visuals.LineVisual(curves.curve3_bezier((10, 0), (30, 200), (390, 0)), color='w', width=2, method='agg') ] # Translate each line visual downwards for i, line in enumerate(self.lines): x = 0 y = 200 * (i + 1) line.transform = STTransform(translate=[x, y]) self.texts = [ visuals.TextVisual('Third order curve', bold=True, color='w', font_size=14, pos=(200, 75)), visuals.TextVisual('Quadratic curve', bold=True, color='w', font_size=14, pos=(200, 525)), ] for text in self.texts: text.transform = NullTransform() self.visuals = self.lines + self.texts self.show()
def __init__(self, canvas, spike_data): self.canvas = canvas # Load data self.spike_data = mea.MEASpikeDict(spike_data) self.spike_data.sort() self.program = gloo.Program(RasterPlotVisualization.VERTEX_SHADER, RasterPlotVisualization.FRAGMENT_SHADER) self._t0 = 0 self._dt = self.spike_data.max_time() self.electrode = '' self.program['u_pan'] = self._t0 self.program['u_y_scale'] = self._dt / 2 self.program['u_top_margin'] = 20.0 * 2.0 / canvas.size[1] self._row_count = 120 self._display_selected = False self._unselected_row_count = 120 self.selected_electrodes = [] self.row_count = len(self.spike_data) self.resample() self.margin = {} self.margin['top'] = 20 self.velocity = 0 self.tick_separtion = 50 self.tick_labels = [ visuals.TextVisual('', font_size=10, color='w') for x in range(18) ] self.tick_marks = LineCollection() self.mouse_t = 0 self.extra_text = ''
def __init__(self, canvas, spike_data): super().__init__() self.canvas = canvas if 'conductance' not in spike_data.columns: spike_data['conductance'] = False self.spike_data = mea.MEASpikeDict(spike_data) self.spike_data.sort() self.program = gloo.Program(RasterPlotVisualization.VERTEX_SHADER, RasterPlotVisualization.FRAGMENT_SHADER) self._t0 = 0 self._dt = self.spike_data.max_time() self.electrode = '' self.program['u_pan'] = self._t0 self.program['u_y_scale'] = self._dt / 2 self.program['u_top_margin'] = 20.0 * 2.0 / canvas.size[1] self._row_count = 120 self._display_selected = False self.selected_electrodes = [] self.row_count = len(self.spike_data) self._unselected_row_count = self.row_count self._dim_conductance = False self.resample() self.margin = {'top': 20} self.velocity = 0 self.tick_separtion = 50 self.tick_labels = [visuals.TextVisual('', font_size=10, color='w') for x in range(14)] self.tick_marks = LineCollection() self.mouse_t = 0 self.extra_text = '' self.measuring = False self.measure_start = (0, 0) self.measure_line = visuals.LineVisual(np.array(((0, 0), (100, 100))), Theme.yellow)
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()
def make_text(self, _string): self.font_size = 150 self.color = (1, 1, 1, 1.0) # white text (for easy detection) self.canvas.text_renderer = visuals.TextVisual('', bold=True, color=self.color) self.tr_sys = visuals.transforms.TransformSystem(self.canvas) self.canvas.text_renderer.text = _string self.canvas.text_renderer.font_size = self.font_size # self.canvas.text_renderer.pos = 200, 200 self.canvas.text_renderer.pos = 0,0
def __init__(self): self.cars = [] self.lookup = np.zeros((field.n_grid_h * 4 + 4, field.n_grid_w * 4 + 4, initial_num_car), dtype=np.uint8) self.program = gloo.Program(car_vertex, car_fragment) self.textvisuals = [] for i in xrange(initial_num_car): self.cars.append(Car(self, index=i)) text = visuals.TextVisual("car %d" % i, color="white", anchor_x="left", anchor_y="top") text.font_size = 8 self.textvisuals.append(text)
def __init__(self, height, width): app.Canvas.__init__(self, title='Glyphs', keys='interactive', size=(50, 50)) self.text = visuals.TextVisual('', bold=True) self.font_size = 14 self.seconds = -1 self.text.text = 'Waiting to start training...' self.text.font_size = self.font_size self.text.pos = height / 2 - 2, width / 2 - 2 #260, 140 self.update()
def make_text(self, _string): self.font_size = 150 # self.color = (.1, .1, .1, 1.0) self.color = (1, 1, 1, 1.0) self.canvas.text_renderer = visuals.TextVisual('', bold=True, color=self.color) self.tr_sys = visuals.transforms.TransformSystem(self.canvas) self.canvas.text_renderer.text = _string self.canvas.text_renderer.font_size = self.font_size # self.canvas.text_renderer.pos = 200, 200 self.size = 500, 1500 self.canvas.text_renderer.pos = self.size[0] * 1.5, self.size[1] // 1.9
def __init__(self): app.Canvas.__init__(self, title='Bezier lines example', keys='interactive', size=(400, 750)) self.visuals = [ visuals.TextVisual('Third order curve', bold=True, color='w', font_size=14, pos=(200, 75)), visuals.LineVisual(np.array([[10, 10], [30, 10], [40, 40], [90, 40]]), color=(1, 0, 0, 1)) ]
def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 800)) self.translate = 20 # Z Start Location self.program = gloo.Program(vert, frag) self.view = translate((0, 0, -self.translate)) self.model = np.eye(4, dtype=np.float32) self.projection = np.eye(4, dtype=np.float32) # t1 = np.array(X.shape[0]) # for ind, val in enumerate(X): # t1[ind] = Text('Text in root scene (24 pt)', parent=c.scene, color='red') # t1[ind].font_size = 24 # t1[ind] = pos = val, Y[ind], Z[ind] self.font_size = self.physical_size[1] / 24 self.text_pos = self.physical_size[0] / 2, 5 * self.physical_size[ 1] / 6 self.text = visuals.TextVisual(' ', bold=True) self.text.color = 'white' self.apply_zoom() self.program.bind(gloo.VertexBuffer(data)) self.program['u_model'] = self.model self.program['u_view'] = self.view self.program['u_size'] = 50 / (self.translate) self.theta = 0 self.phi = 0 self.frame = 0 self.stop_rotation = False gloo.set_state('translucent', depth_test=False) self.program['u_frame'] = 0.0 xyzs[:, 3] = spikes[int(self.program['u_frame'][0])] self.program['a_xyzs'] = xyzs self._timer = app.Timer('auto', connect=self.on_timer, start=True) self.show()
def on_initialize(self, event): self.nodes = np.zeros(self.M + self.N, [('position', 'f4', 3), ('color', 'f4', 4), ('size', 'f4', 1)]) self.agents = self.nodes[:self.N] self.goods = self.nodes[self.N:] self.agents['position'][:] = np.random.uniform(-0.25, +0.25, (self.N, 3)) self.agents['size'] = 30 self.agents['color'][:] = 0, 0, 1, 1 self.goods['size'] = 20 self.goods['color'][:] = 0, 1, 0, 1 self.goods['position'][:] = np.random.uniform(-0.25, +0.25, (self.M, 3)) #Text self.width = self.size[0] self.height = self.size[1] self.font_size = 12. self.text = [ visuals.TextVisual(str(x), bold=True, color='white') for x in range(self.N) ] self.tr_sys = visuals.transforms.TransformSystem(self) self.program = gloo.Program(VERT_SHADER, FRAG_SHADER) # Set uniform and attribute self.vbo_position = gloo.VertexBuffer(self.nodes['position'].copy()) self.vbo_color = gloo.VertexBuffer(self.nodes['color'].copy()) self.vbo_size = gloo.VertexBuffer(self.nodes['size'].copy()) self.program['color'] = self.vbo_color self.program['size'] = self.vbo_size self.program['position'] = self.vbo_position gloo.set_state(clear_color='white', blend=True, blend_func=('src_alpha', 'one_minus_src_alpha'))
def __init__(self, canvas, analog_data, spike_data): super().__init__() self.canvas = canvas self.analog_data = analog_data self.raw_data = spike_data self.spike_data = mea.MEASpikeDict(spike_data) self.show_spikes = False self._dim_conductance = False self._t0 = 0 self._dt = 20 self._y_scale = 150 self._pan = 0 self._scale = 1 self.mouse_t = 0 self.electrode = '' self.selected_electrodes = ['h11'] # l5, m5 self.strip_program = gloo.Program(self.STRIP_VERTEX_SHADER, self.STRIP_FRAGMENT_SHADER) self.strip_program['u_color'] = Theme.blue self.point_program = gloo.Program(self.POINT_VERTEX_SHADER, self.POINT_FRAGMENT_SHADER) self.pan = self._t0 self.scale = (2.0 / self._dt, 1 / self._y_scale) self.velocity = 0 self.measuring = False self.measure_start = (0, 0) self.measure_line = visuals.LineVisual(np.array(((0, 0), (100, 100))), Theme.yellow) self.scale_bar = visuals.LineVisual(np.array(((10, 10), (200, 10))), Theme.black, width=10, method='agg') self.scale_label = visuals.TextVisual('', font_size=8) self.configure_transforms() self.extra_text = '' self._filtered = False self._filter_cutoff = [200, 4000] self.all_spike_colors = [] self.propagation_spike_colors = [] self.resample() self.background_color = Theme.background
def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 800)) self.n_iterations = 0 self.text_parts = [ 'This', 'is', 'a', 'multicolored', 'scattered', 'text' ] self.x = 100 + np.arange(len(self.text_parts)) * 100 self.y = 400 + (np.sin(2 * np.pi * (self.x / self.x[-1])) * 100) self.text_positions = np.c_[self.x, self.y] color = np.ones((len(self.text_parts), 4), dtype=np.float32) color[:, 0] = np.linspace(0, 1, len(self.text_parts)) color[:, 1] = color[::-1, 0] self.colors = color self.text = visuals.TextVisual(self.text_parts, bold=True, pos=self.text_positions, color=self.colors)
def __init__(self): app.Canvas.__init__(self, title='Glyphs', keys='interactive') self.font_size = 9. # Create a cross eye for easy see if text anchor positions are good l_pos = np.array([ [-1.0, 0.0], [1.0, 0.0], [0.0, 0.0], [0.0, 1.0], [0.0, -1.0], ]) self.cross_eye_line = visuals.LineVisual(pos=l_pos, color=(1.0, 0.0, 0.0, 1), method='gl') big_test_string = 'This is the big test string!\n' big_test_string += 'It includes all of the escape sequences known\n' big_test_string += 'to man:\n\n' big_test_string += '\t-\t\\n\n' big_test_string += '\t-\t\\v\n' big_test_string += '\t-\t\\t\n' big_test_string += '\t-\tetc..\v' big_test_string += 'So \bif \fthis \rlooks correct, somebody did a \n' big_test_string += 'decent job and deserves a beer ' big_test_string += 'and a digital salute\a! ;)' big_test_string += '\vThe end!' self.string_alternatives = [ '', 'Hello (scroll/arrows to change text properties)|\a|how are u', 'Hello (scroll/arrows to change text properties)|\b|how are u', 'Hello (scroll/arrows to change text properties)|\f|how are u', 'Hello (scroll/arrows to change text properties)|\n|how are u', 'Hello (scroll/arrows to change text properties)|\r|how are u', 'Hello (scroll/arrows to change text properties)|\t|how are u', 'Hello (scroll/arrows to change text properties)|\v|how are u', 'Hello (scroll/arrows to change text properties)|\\|how are u', 'Hello (scroll/arrows to change text properties)|\'|how are u', 'Hello (scroll/arrows to change text properties)|\"|how are u', 'Hello (scroll/arrows to change text properties)|?|how are u', big_test_string, ] self.str_ind = 0 # anchor_x , anchor_y self.anchor_variants = [ ['top', 'left'], ['center', 'left'], ['bottom', 'left'], ['top', 'center'], ['center', 'center'], ['bottom', 'center'], ['top', 'right'], ['center', 'right'], ['bottom', 'right'], ] self.anchor_ind = 0 self.text = visuals.TextVisual('', bold=True, pos=(0., 0.)) self.update_text()
def __init__(self, lsl_inlet, scale=500, filt=True): app.Canvas.__init__(self, title='EEG - Use your wheel to zoom!', keys='interactive') self.inlet = lsl_inlet info = self.inlet.info() description = info.desc() window = 10 self.sfreq = info.nominal_srate() n_samples = int(self.sfreq * window) self.n_chans = info.channel_count() ch = description.child('channels').first_child() ch_names = [ch.child_value('label')] for i in range(self.n_chans): ch = ch.next_sibling() ch_names.append(ch.child_value('label')) # Number of cols and rows in the table. n_rows = self.n_chans n_cols = 1 # Number of signals. m = n_rows * n_cols # Number of samples per signal. n = n_samples # Various signal amplitudes. amplitudes = np.zeros((m, n)).astype(np.float32) # gamma = np.ones((m, n)).astype(np.float32) # Generate the signals as a (m, n) array. y = amplitudes color = color_palette("RdBu_r", n_rows) color = np.repeat(color, n, axis=0).astype(np.float32) # Signal 2D index of each vertex (row and col) and x-index (sample index # within each signal). index = np.c_[np.repeat(np.repeat(np.arange(n_cols), n_rows), n), np.repeat(np.tile(np.arange(n_rows), n_cols), n), np.tile(np.arange(n), m)].astype(np.float32) self.program = gloo.Program(VERT_SHADER, FRAG_SHADER) self.program['a_position'] = y.reshape(-1, 1) self.program['a_color'] = color self.program['a_index'] = index self.program['u_scale'] = (1., 1.) self.program['u_size'] = (n_rows, n_cols) self.program['u_n'] = n # text self.font_size = 48. self.names = [] self.quality = [] for ii in range(self.n_chans): text = visuals.TextVisual(ch_names[ii], bold=True, color='white') self.names.append(text) text = visuals.TextVisual('', bold=True, color='white') self.quality.append(text) self.quality_colors = color_palette("RdYlGn", 11)[::-1] self.scale = scale self.n_samples = n_samples self.filt = filt self.af = [1.0] self.data_f = np.zeros((n_samples, self.n_chans)) self.data = np.zeros((n_samples, self.n_chans)) self.bf = create_filter(self.data_f.T, self.sfreq, 3, 40., method='fir') zi = lfilter_zi(self.bf, self.af) self.filt_state = np.tile(zi, (self.n_chans, 1)).transpose() self._timer = app.Timer('auto', connect=self.on_timer, start=True) gloo.set_viewport(0, 0, *self.physical_size) gloo.set_state(clear_color='black', blend=True, blend_func=('src_alpha', 'one_minus_src_alpha')) self.show()
def __init__(self, list_of_charts, theta, fi, kp, kd, l, scale, x, y, method, control, save_charts, dt, tmax, font_size): VisualModel.__init__(self) self.center = [400, 400] self.model = VehicleKinematicModel(list_of_charts) self.list_of_charts = list_of_charts self._set_up_system( l=l, theta=theta, fi=fi, x=x, y=y, kp=kp, kd=kd, scale=scale, method=method, control=control, save_charts=save_charts, dt=dt, tmax=tmax, font_size=font_size ) # Put up a text visual to display time info self.font_size = 24. if font_size is None else font_size self.text = visuals.TextVisual('0:00.00', color='white', pos=[15, 50, 0], anchor_x='left', anchor_y='bottom') self.text.font_size = self.font_size self.rear_wheelsL = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='yellow') self.rear_wheelsL.transform = transforms.MatrixTransform() self.rear_wheelsL.transform.scale((self.scale*2.0, self.scale*0.5, 1)) self.rear_wheelsL.transform.translate([0.0, -self.scale*0.5*4.0]) self.rear_wheelsL.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.rear_wheelsL.transform.translate([self.model.x, self.model.y]) self.rear_wheelsL.transform.translate(self.center) self.rear_wheelsR = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='yellow') self.rear_wheelsR.transform = transforms.MatrixTransform() self.rear_wheelsR.transform.scale((self.scale*2.0, self.scale*0.5, 1)) self.rear_wheelsR.transform.translate([0.0, self.scale*0.5*4.0]) self.rear_wheelsR.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.rear_wheelsR.transform.translate([self.model.x, self.model.y]) self.rear_wheelsR.transform.translate(self.center) self.front_wheelsL = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='pink') self.front_wheelsL.transform = transforms.MatrixTransform() self.front_wheelsL.transform.scale((self.scale*2.0, self.scale*0.5, 1)) self.front_wheelsL.transform.rotate(np.rad2deg(-self.model.fi), (0, 0, 1)) self.front_wheelsL.transform.translate([self.scale*l, -self.scale*0.5*4.0]) self.front_wheelsL.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.front_wheelsL.transform.translate([self.model.x, self.model.y]) self.front_wheelsL.transform.translate(self.center) self.front_wheelsR = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='pink') self.front_wheelsR.transform = transforms.MatrixTransform() self.front_wheelsR.transform.scale((self.scale*2.0, self.scale*0.5, 1)) self.front_wheelsR.transform.rotate(np.rad2deg(-self.model.fi), (0, 0, 1)) self.front_wheelsR.transform.translate([self.scale*l, self.scale*0.5*4.0]) self.front_wheelsR.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.front_wheelsR.transform.translate([self.model.x, self.model.y]) self.front_wheelsR.transform.translate(self.center) self.vehicle_body = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='green') self.vehicle_body.transform = transforms.MatrixTransform() self.vehicle_body.transform.translate([0.5, 0.0]) self.vehicle_body.transform.scale((self.scale*self.model.l, self.scale, 1)) self.vehicle_body.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.vehicle_body.transform.translate([self.model.x, self.model.y]) self.vehicle_body.transform.translate(self.center) self.vehicle_bodyF = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='red') self.vehicle_bodyF.transform = transforms.MatrixTransform() self.vehicle_bodyF.transform.scale((self.scale*0.25, self.scale*4.0, 1)) self.vehicle_bodyF.transform.translate([l*self.scale, 0.0]) self.vehicle_bodyF.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.vehicle_bodyF.transform.translate([self.model.x, self.model.y]) self.vehicle_bodyF.transform.translate(self.center) self.vehicle_bodyR = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='blue') self.vehicle_bodyR.transform = transforms.MatrixTransform() self.vehicle_bodyR.transform.scale((self.scale*0.25, self.scale*4.0, 1)) self.vehicle_bodyR.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.vehicle_bodyR.transform.translate([self.model.x, self.model.y]) self.vehicle_bodyR.transform.translate(self.center) # Append all the visuals self.visuals.append(self.vehicle_body) self.visuals.append(self.vehicle_bodyF) self.visuals.append(self.vehicle_bodyR) self.visuals.append(self.rear_wheelsL) self.visuals.append(self.rear_wheelsR) self.visuals.append(self.front_wheelsL) self.visuals.append(self.front_wheelsR) self.visuals.append(self.text)
def __init__(self, filename): self.basename = os.path.basename(filename) assert self.basename.endswith('.npz') self.accession_id = self.basename[0:-4] self.dump_prefix = './%s.' % self.accession_id self.dump_prefix = os.getenv('DUMP_PREFIX', self.dump_prefix) self.vol_slicer = SynspyImageManager(filename) self.vol_slicer.set_view() D, H, W, Nc = self.vol_slicer.data.shape app.Canvas.__init__(self, size=(min(800, W), min(800, H)), keys='interactive') self._hud_timer = None self.hud_items = [] self.program = gloo.Program() self.program.bind(gloo.VertexBuffer(quad)) self.textures, self.segment_map, self.segment_status = self.vol_slicer.get_textures( 0) self.program['u_image_texture'] = self.textures[0] self.program['u_map_texture'] = self.textures[1] self.program['u_measures_cube'] = self.textures[2] self.program['u_status_cube'] = self.textures[3] self.mouse_button_offset = 0 self.key_press_handlers = { 'B': self.toggle_blend, #'D': self.dump_or_report, 'D': self.report, 'E': self.toggle_erase, 'F': self.adjust_feature_level, 'G': self.adjust_gain, 'H': self.help, #'L': self.load_csv, 'N': self.adjust_neighbor_level, 'P': self.toggle_paint, 'R': self.reset, 'T': self.adjust_black_level, 'Up': self.adjust_depth, 'Down': self.adjust_depth, 'Left': self.adjust_paint_zoom, 'Right': self.adjust_paint_zoom, } self.frag_shaders = [ # green linear with binary segments (picked is brighter) ('green linear with binary segments', frag_shader( colorxfer='vec4(0.0, pixel.r * u_gain, 0.0, 1.0)', pick_off='vec3(0.2, 1, 1)', pick_on='vec3(1, 0.2, 1)', pick_def='vec3(1, 1, 0.2)', off='vec3(0.2, 0.6, 0.6)', on='vec3(0.6, 0.2, 0.6)', inrange='vec3(0.6, 0.6, 0.2)', )), ('gray intensity only', frag_shader( colorxfer= 'vec4(pixel.r, pixel.r, pixel.r, 1.0/u_gain) * u_gain', pick_off='vec3(0.2, 1, 1)', pick_on='vec3(1, 0.2, 1)', pick_def='vec3(1, 1, 1)', off='result.rgb', on='result.rgb', inrange='result.rgb', )), ('gray intensity with magenta=ON synapses', frag_shader( colorxfer= 'vec4(pixel.r, pixel.r, pixel.r, 1.0/u_gain) * u_gain', pick_off='vec3(0.2, 1, 1)', pick_on='vec3(1, 0.2, 1)', pick_def='vec3(1, 1, 1)', off='result.rgb', on='vec3(result.g, 0.2 * result.g, result.g) * 1.2', inrange='result.rgb', )), ('gray intensity with magenta=ON cyan=OFF yellow=neither synapses', frag_shader( colorxfer= 'vec4(pixel.r, pixel.r, pixel.r, 1.0/u_gain) * u_gain', pick_off='vec3(0.2, 1, 1)', pick_on='vec3(1, 0.2, 1)', pick_def='vec3(1, 1, 1)', off='vec3(0.2 * result.g, result.g, result.g) * 1.2', on='vec3(result.g, 0.2 * result.g, result.g) * 1.2', inrange='vec3(result.g, result.g, 0.2 * result.g) * 1.2', )) ] self.reset() self.text_hud = visuals.TextVisual('', color="white", font_size=12 * self.font_scale, anchor_x="left", bold=True) if not hasattr(self.text_hud, 'transforms'): # temporary backwards compatibility self.text_hud_transform = visuals.transforms.TransformSystem(self) self.prev_size = None self.set_viewport1((min(800, W), min(800, H))) self.show() # auto-load try: self.load_csv() except: pass # auto-dump self.auto_dumped = False @atexit.register def shutdown(): if not self.auto_dumped: sys.stderr.write('caught exit... dumping CSV...') self.dump_csv() sys.stderr.write('done.\n')
def __init__(self): app.Canvas.__init__(self, title='Glyphs', keys='interactive') self.font_size = 48. self.text = visuals.TextVisual('', bold=True) self.tr_sys = visuals.transforms.TransformSystem(self) self.apply_zoom()
def __init__(self, filename1): self.do_nuclei, footprints = get_mode_and_footprints() self.synapse_diam_microns, self.vicinity_diam_microns, self.redblur_microns = footprints base.Canvas.__init__(self, filename1) try: bn = os.path.basename(filename1) m = re.match('^(?P<id>.+)[.]ome[.]tif+$', bn) self.dump_prefix = './%s' % (m.groupdict()['id'],) except: # backwards compatible default self.dump_prefix = '%s-' % filename1 self.dump_prefix = os.getenv('DUMP_PREFIX', self.dump_prefix) print('Using DUMP_PREFIX="%s"' % self.dump_prefix) # textures prepared by self._reform_image() during base init above... self.volume_renderer.set_uniform('u_voxel_class_texture', self.voxel_class_texture) self.volume_renderer.set_uniform('u_measures_texture', self.measures_texture) self.volume_renderer.set_uniform('u_status_texture', self.status_texture) self.key_press_handlers['L'] = self.load_classified_segments self.key_press_handlers['E'] = self.endorse_or_expunge self.key_press_handlers['N'] = self.adjust_nuc_level self.key_press_handlers['M'] = self.adjust_msk_level self.key_press_handlers['T'] = self.adjust_zer_level self.key_press_handlers['U'] = self.adjust_top_level self.key_press_handlers['O'] = self.adjust_transp_level self.key_press_handlers['D'] = self.dump_params_or_classified self.key_press_handlers['H'] = self.dump_segment_heatmap self.key_press_handlers['?'] = self.help self.auto_dump_load = os.getenv('SYNSPY_AUTO_DUMP_LOAD', 'false').lower() == 'true' print('Using SYNSPY_AUTO_DUMP_LOAD=%s' % str(self.auto_dump_load).lower()) # provide better names for synspy parameters on HUD self.hud_display_names['u_floorlvl'] = 'core measure' self.hud_display_names['u_nuclvl'] = 'hollow measure' self.hud_display_names['u_msklvl'] = 'autofluourescence' self.hud_display_names['u_zerlvl'] = 'zero point' self.hud_display_names['u_toplvl'] = 'saturation point' self.hud_display_names['u_transp'] = 'opacity' self.user_notices = [] if os.getenv('USER_NOTICES_FILE'): f = open(os.getenv('USER_NOTICES_FILE')) self.user_notices = [] for line in f.readlines(): line = line.strip() parts = line.split(',') try: num = int(parts[0]) self.user_notices.append((num, ','.join(parts[1:]))) except: self.user_notices.append((line, None)) if self.user_notices[-1] == ('', None): del self.user_notices[-1] assert len(self.user_notices) <= 12 for i in range(len(self.user_notices)): self.key_press_handlers['F%d' % (i + 1)] = self.emit_notice # provide better value display for HUD def value_denorm(v): return "%.1f" % (v * (self.data_max - self.data_min) + self.data_min) for uniform in ['u_floorlvl', 'u_nuclvl', 'u_msklvl', 'u_zerlvl', 'u_toplvl']: self.hud_value_rewrite[uniform] = value_denorm self.pick_click = False self.centroids_batch = set() # store 0-based centroid IDs here... self.text_overlay = visuals.TextVisual('DUMMY', color="white", font_size=12) if not hasattr(self.text_overlay, 'transforms'): # temporary backwards compatibility self.text_overlay_transform = visuals.transforms.TransformSystem(self) try: self.size = tuple([ int(x) for x in os.getenv('WINDOW_SIZE', '').split('x') ]) assert len(self.size) == 2, 'WINDOW_SIZE must have form WxH' except: print('Using default WINDOW_SIZE=512x512') self.size = 512, 512 self.auto_dumped = False if self.auto_dump_load: try: self.load_classified_segments(None) except IOError as e: print('Skipping auto-load of segment status on error: %s' % e) @atexit.register def shutdown(): if not self.auto_dumped: self.on_close()
def __init__(self, filename, reset=True): app.Canvas.__init__( self, #vsync=True, keys='interactive', title='%s %s' % (os.path.basename(sys.argv[0]).replace('-viewer', ''), os.path.basename(filename)), ) self.vol_cropper = ImageManager(filename, self._reform_image) nc = self.vol_cropper.data.shape[3] try: channel = int(os.getenv('VIEW_CHANNEL')) except: channel = None if channel is not None and channel >= 0 and channel < nc: print("Starting single-channel mode with user-specified channel %d of %d total channels" % (channel, nc)) self.vol_channels = (channel,) elif nc > 4: print("%d channel image encountered, switching to single-channel mode" % nc) self.vol_channels = (0,) else: print("%d channel image encountered, using direct %d-channel mapping" % (nc, nc)) self.vol_channels = None self.vol_cropper.set_view(channels=self.vol_channels) self.vol_texture = self.vol_cropper.get_texture3d() self.vol_zoom = 1.0 W = self.vol_texture.shape[2] self.size = W, W self.prev_size = self.size self.perspective = True if self.vol_channels is not None: nc = len(self.vol_channels) else: nc = self.vol_cropper.data.shape[3] self.volume_renderer = VolumeRenderer( self.vol_cropper, self.vol_texture, nc, _default_view.copy(), # view (int(maxtexsize * 4), int(maxtexsize * 4)), # fbo_size frag_glsl_dicts=self._frag_glsl_dicts, pick_glsl_index=self._pick_glsl_index, vol_interp=self._vol_interp ) self.toggle_color_mode.__func__._keydocs = { 'B': 'Cycle through color blending modes %s. Reverse cycle with shift key.' % [ frag.get('desc', 'undocumented') for frag in self.volume_renderer.frag_glsl_dicts ] } self._timer = None self.fps_t0 = datetime.datetime.now() self.fps_count = 0 self.mouse_button_offset = 0 gloo.set_clear_color('black') self.frame = 0 # to allow over-riding by subclasses self.drag_button_handlers = { 1: lambda distance, delta, pos1, basis: self._mouse_drag_rotation(distance, delta), 2: lambda distance, delta, pos1, basis: self._mouse_drag_translation(delta) } self.end_drag_handlers = [ self._end_drag_xform, ] self.key_press_handlers = dict( [ ('P', self.toggle_projection), ('B', self.toggle_color_mode), ('C', self.toggle_channel), ('Z', self.adjust_zoom), ('R', self.r_key), ('F', self.adjust_floor_level), ('=', self.reorient), ('Space', self.toggle_slicing), ('?', self.help) ] + [ (k, self.adjust_gain) for k in 'G1234567890!@#$%^&*()' ] + [ (k, self.adjust_rotate) for k in [ 'Left', 'Right', 'Up', 'Down', '[', ']', '{', '}' ] ] ) self.hud_enable = os.getenv('HUD_ENABLE', 'true').lower() != 'false' and True or False self.hud_display_names = { 'u_picked': None, 'u_floorlvl': 'zero point', 'u_gain': 'gain', } self.hud_value_rewrite = {} self.viewport1 = (0, 0) + self.size try: self.font_scale = float(os.getenv('FONT_SCALE', 1)) except: print('Invalid FONT_SCALE "%s", using 1.0 instead') self.font_scale = 2.0 self.text_hud = visuals.TextVisual('', color="white", font_size=12 * self.font_scale, anchor_x="left", bold=True) if not hasattr(self.text_hud, 'transforms'): # temporary backwards compatibility self.text_hud_transform = visuals.transforms.TransformSystem(self) if reset: self.reset_ui()
def __init__(self, list_of_charts, theta, omega, g, m, kp, kd, l, scale, method, control, save_charts, dt, tmax, font_size): VisualModel.__init__(self) self.model = PendulumModel(list_of_charts) self.list_of_charts = list_of_charts self.vis_length = l self._set_up_system(l=l, g=g, m=m, theta=theta, omega=omega, kp=kp, kd=kd, scale=scale, method=method, control=control, save_charts=save_charts, dt=dt, tmax=tmax, font_size=font_size) # Put up a text visual to display time info self.font_size = 24. if font_size is None else font_size self.text = visuals.TextVisual('0:00.00', color='white', pos=[15, 50, 0], anchor_x='left', anchor_y='bottom') self.text.font_size = self.font_size self.params = [] self.params.append( visuals.TextVisual('td', color='white', pos=[15, 80, 0], anchor_x='left', anchor_y='bottom')) self.params.append( visuals.TextVisual('tr_1090', color='white', pos=[15, 100, 0], anchor_x='left', anchor_y='bottom')) self.params.append( visuals.TextVisual('tr_0595', color='white', pos=[15, 120, 0], anchor_x='left', anchor_y='bottom')) self.params.append( visuals.TextVisual('tr_0100', color='white', pos=[15, 140, 0], anchor_x='left', anchor_y='bottom')) self.params.append( visuals.TextVisual('tp', color='white', pos=[15, 160, 0], anchor_x='left', anchor_y='bottom')) self.params.append( visuals.TextVisual('over', color='white', pos=[15, 180, 0], anchor_x='left', anchor_y='bottom')) self.params.append( visuals.TextVisual('ts_2', color='white', pos=[15, 200, 0], anchor_x='left', anchor_y='bottom')) self.params.append( visuals.TextVisual('ts_5', color='white', pos=[15, 220, 0], anchor_x='left', anchor_y='bottom')) for param in self.params: param.font_size = 12 self.hook = visuals.BoxVisual(width=0.25, height=0.25, depth=0.25, color='grey') self.hook.transform = transforms.MatrixTransform() self.hook.transform.scale( (self.scale * self.model.l, self.scale * self.model.l, 0.0001)) self.hook.transform.translate(self.center) self.rod = visuals.BoxVisual(width=self.vis_length / 40, height=self.vis_length / 40, depth=self.vis_length, color='green') self.rod.transform = transforms.MatrixTransform() self.rod.transform.translate([0.0, self.vis_length / 2.0]) self.rod.transform.scale( (self.scale * self.model.l, self.scale * self.model.l, 0.0001)) self.rod.transform.rotate(np.rad2deg(self.model.theta), (0, 0, 1)) self.rod.transform.translate(self.center) # Append all the visuals self.visuals.append(self.rod) self.visuals.append(self.hook) self.visuals.append(self.text) for param in self.params: self.visuals.append(param)
def __init__(self, path, channel=0, start=0): app.Canvas.__init__(self, position=(300, 100), size=(800, 800), keys='interactive') self.program = gloo.Program(vertex, fragment) self.program['a_position'] = [(-1., -.5, 0.), (-1., +1., 0.), (+0.5, -.5, 0.), (+0.5, +1, 0.)] self.program['a_texcoord'] = [(0., 0.), (0., +1), (+1., 0.), (+1, +1)] self.program2 = gloo.Program(vertex, fragment) self.program2['a_position'] = [(-1., -1., 0.), (-1., -0.55, 0.), (+0.5, -1., 0.), (+0.5, -0.55, 0.)] self.program2['a_texcoord'] = [(0., 0.), (0., +1.), (+1., 0.), (+1., +1.)] self.program3 = gloo.Program(vertex, fragment) self.program3['a_position'] = [(0.55, -0.5, 0.), (0.55, +1., 0.), (+1., -0.5, 0.), (+1., +1., 0.)] self.program3['a_texcoord'] = [(0., 0.), (0., +1.), (+1., 0.), (+1., +1.)] if os.path.splitext(path)[-1] == '.sima': ds = ImagingDataset.load(path) self.sequence = ds.__iter__().next() else: self.sequence = Sequence.create('HDF5', path, 'tzyxc') self.frame_counter = start self.step_size = 1 self.channel = channel self.length = len(self.sequence) vol = self.sequence._get_frame(self.frame_counter).astype('float32') vol /= NORMING_VAL vol = np.clip(vol, 0, 1) #surf = np.sum(vol,axis=0)[:,:,channel]/vol.shape[0] surf = np.nanmean(vol, axis=0)[:, :, channel] self.program['u_texture'] = surf #surf2 = np.sum(vol,axis=1)[:,:,channel]/vol.shape[1] surf2 = np.nanmean(vol, axis=1)[:, :, channel] self.program2['u_texture'] = surf2 #surf3 = np.fliplr((np.sum(vol,axis=2)[:,:,channel]).T)/vol.shape[2] surf3 = np.fliplr((np.nanmean(vol, axis=2)[:, :, channel]).T) self.program3['u_texture'] = surf3 self.text = visuals.TextVisual('', font_size=14, color='r', pos=(700, 700)) self.text.text = "{} / {}".format(self.frame_counter, self.length) self.steptext = visuals.TextVisual('step_size: 1', font_size=10, color='r', pos=(700, 725)) self.tr_sys = visuals.transforms.TransformSystem(self) self.timer = app.Timer(0.25, connect=self.on_timer, start=True)
def __init__(self, lsl_inlet, name = "Unknown", scale=500, filt=True): app.Canvas.__init__(self, title='EEG - ' + name, keys='interactive') #Setup threading t = threading.Thread(target=self.worker) t.start() self.status = False self.name = name self.windowData = [] self.previousWindowData = [] self.alphaCounter = [] self.freq = 256 self.isClosed = False self.counter = 0 self.temp_cal_alplha = [] self.calibrate_alpha = 0 self.filename = os.path.join(os.getcwd(), 'recording_' + self.name + '_' + strftime("%Y-%m-%d-%H.%M.%S", gmtime()) + '.csv') self.inlet = lsl_inlet self.isAction = False info = self.inlet.info() description = info.desc() y_sig = np.sin(2 * np.pi * 8 * np.arange(256) / 256) y_sig = y_sig + np.sin(2 * np.pi * 9 * np.arange(256) / 256) y_sig = y_sig + np.sin(2 * np.pi * 10 * np.arange(256) / 256) y_sig = y_sig + np.sin(2 * np.pi * 11 * np.arange(256) / 256) y_sig = y_sig + np.sin(2 * np.pi * 12 * np.arange(256) / 256) self.y_sig = y_sig window = 10 self.sfreq = info.nominal_srate() n_samples = int(self.sfreq * window) self.n_chans = info.channel_count() ch = description.child('channels').first_child() ch_names = [ch.child_value('label')] for i in range(self.n_chans): ch = ch.next_sibling() ch_names.append(ch.child_value('label')) # Number of cols and rows in the table. n_rows = self.n_chans n_cols = 1 # Number of signals. m = n_rows * n_cols # Number of samples per signal. n = n_samples # Various signal amplitudes. amplitudes = np.zeros((m, n)).astype(np.float32) # gamma = np.ones((m, n)).astype(np.float32) # Generate the signals as a (m, n) array. y = amplitudes color = color_palette("RdBu_r", n_rows) color = np.repeat(color, n, axis=0).astype(np.float32) # Signal 2D index of each vertex (row and col) and x-index (sample index # within each signal). index = np.c_[np.repeat(np.repeat(np.arange(n_cols), n_rows), n), np.repeat(np.tile(np.arange(n_rows), n_cols), n), np.tile(np.arange(n), m)].astype(np.float32) self.program = gloo.Program(VERT_SHADER, FRAG_SHADER) self.program['a_position'] = y.reshape(-1, 1) self.program['a_color'] = color self.program['a_index'] = index self.program['u_scale'] = (1., 1.) self.program['u_size'] = (n_rows, n_cols) self.program['u_n'] = n # text self.font_size = 48. self.names = [] self.quality = [] for ii in range(self.n_chans): text = visuals.TextVisual(ch_names[ii], bold=True, color='white') self.names.append(text) text = visuals.TextVisual('', bold=True, color='white') self.quality.append(text) self.quality_colors = color_palette("RdYlGn", 11)[::-1] self.scale = scale self.n_samples = n_samples self.filt = filt self.af = [1.0] self.data_f = np.zeros((n_samples, self.n_chans)) self.data = np.zeros((n_samples, self.n_chans)) self.bf = create_filter(self.data_f.T, self.sfreq, 8, 15., method='fir') zi = lfilter_zi(self.bf, self.af) self.filt_state = np.tile(zi, (self.n_chans, 1)).transpose() self._timer = app.Timer('auto', connect=self.on_timer, start=True) gloo.set_viewport(0, 0, *self.physical_size) gloo.set_state(clear_color='black', blend=True, blend_func=('src_alpha', 'one_minus_src_alpha')) self.show()
def __init__(self, d1=None, d2=None, little_m=None, big_m=None, spring_k1=None, spring_k2=None, b=None, x=None, x_dot=None, theta=None, theta_dot=None, px_len=None, scale=None, pivot=False, method='Euler', dt=None, font_size=None): """ Main VisPy Canvas for simulation of physical system. Parameters ---------- d1 : float Length of rod (in meters) from pivot to upper spring. d2 : float Length of rod (in meters) from pivot to lower spring. little_m : float Mass of attached cube (in kilograms). big_m : float Mass of rod (in kilograms). spring_k1 : float Spring constant of lower spring (in N/m). spring_k2 : float Spring constant of upper spring (in N/m). b : float Coefficient of quadratic sliding friction (in kg/m). x : float Initial x-position of mass (in m). x_dot : float Initial x-velocity of mass (in m/s). theta : float Initial angle of rod, with respect to vertical (in radians). theta_dot : float Initial angular velocity of rod (in rad/s). px_len : int Length of the rod, in pixels. scale : int Scaling factor to change size of elements. pivot : bool Switch for showing/hiding pivot point. method : str Method to use for updating. dt : float Time step for simulation. font_size : float Size of font for text elements, in points. Notes ----- As of right now, the only supported methods are "euler" or "runge-kutta". These correspond to an Euler method or an order 3 Runge-Kutta method for updating x, theta, x dot, and theta dot. """ app.Canvas.__init__(self, title='Wiggly Bar', size=(800, 800)) # Some initialization constants that won't change self.standard_length = 0.97 + 0.55 self.center = np.asarray((500, 450)) self.visuals = [] self._set_up_system(d1=d1, d2=d2, little_m=little_m, big_m=big_m, spring_k1=spring_k1, spring_k2=spring_k2, b=b, x=x, x_dot=x_dot, theta=theta, theta_dot=theta_dot, px_len=px_len, scale=scale, pivot=pivot, method=method, dt=dt, font_size=font_size) piv_x_y_px = np.asarray( (self.pivot_loc_px * np.sin(self.theta), -1 * self.pivot_loc_px * (np.cos(self.theta)))) # Make the spring points points = make_spring(height=self.px_len / 4, radius=self.px_len / 24) # Put up a text visual to display time info self.font_size = 24. if font_size is None else font_size self.text = visuals.TextVisual('0:00.00', color='white', pos=[50, 250, 0], anchor_x='left', anchor_y='bottom') self.text.font_size = self.font_size # Let's put in more text so we know what method is being used to # update this self.method_text = visuals.TextVisual( 'Method: {}'.format(self.method), color='white', pos=[50, 250 + 2 / 3 * font_size, 0], anchor_x='left', anchor_y='top') self.method_text.font_size = 2 / 3 * self.font_size # Get the pivoting bar ready self.rod = visuals.BoxVisual(width=self.px_len / 40, height=self.px_len / 40, depth=self.px_len, color='white') self.rod.transform = transforms.MatrixTransform() self.rod.transform.scale( (self.scale, self.scale * self.rod_scale, 0.0001)) self.rod.transform.rotate(np.rad2deg(self.theta), (0, 0, 1)) self.rod.transform.translate(self.center - piv_x_y_px) # Show the pivot point (optional) pivot_center = (self.center[0], self.center[1], -self.px_len / 75) self.center_point = visuals.SphereVisual(radius=self.px_len / 75, color='red') self.center_point.transform = transforms.MatrixTransform() self.center_point.transform.scale((self.scale, self.scale, 0.0001)) self.center_point.transform.translate(pivot_center) # Get the upper spring ready. self.spring_2 = visuals.TubeVisual(points, radius=self.px_len / 100, color=(0.5, 0.5, 1, 1)) self.spring_2.transform = transforms.MatrixTransform() self.spring_2.transform.rotate(90, (0, 1, 0)) self.spring_2.transform.scale((self.scale, self.scale, 0.0001)) self.spring_2.transform.translate(self.center + self.s2_loc) # Get the lower spring ready. self.spring_1 = visuals.TubeVisual(points, radius=self.px_len / 100, color=(0.5, 0.5, 1, 1)) self.spring_1.transform = transforms.MatrixTransform() self.spring_1.transform.rotate(90, (0, 1, 0)) self.spring_1.transform.scale( (self.scale * (1.0 - (self.x * self.px_per_m) / (self.scale * self.px_len / 2)), self.scale, 0.0001)) self.spring_1.transform.translate(self.center + self.s1_loc) # Finally, prepare the mass that is being moved self.mass = visuals.BoxVisual(width=self.px_len / 4, height=self.px_len / 8, depth=self.px_len / 4, color='white') self.mass.transform = transforms.MatrixTransform() self.mass.transform.scale((self.scale, self.scale, 0.0001)) self.mass.transform.translate(self.center + self.mass_loc) # Append all the visuals self.visuals.append(self.center_point) self.visuals.append(self.rod) self.visuals.append(self.spring_2) self.visuals.append(self.spring_1) self.visuals.append(self.mass) self.visuals.append(self.text) self.visuals.append(self.method_text) # Set up a timer to update the image and give a real-time rendering self._timer = app.Timer('auto', connect=self.on_timer, start=True) self.show()
def __init__(self, list_of_charts, theta, omega, g, M, m, kp, kd, A, f, l, scale, x, V, method, control, noise, save_charts, dt, tmax, font_size): VisualModel.__init__(self) self.model = CranePhysicalModel(list_of_charts) self.list_of_charts = list_of_charts self._set_up_system(l=l, g=g, M=M, m=m, theta=theta, omega=omega, x=x, V=V, kp=kp, kd=kd, A=A, f=f, scale=scale, method=method, control=control, noise=noise, save_charts=save_charts, dt=dt, tmax=tmax, font_size=font_size) # Put up a text visual to display time info self.font_size = 24. if font_size is None else font_size self.text = visuals.TextVisual('0:00.00', color='white', pos=[15, 50, 0], anchor_x='left', anchor_y='bottom') self.text.font_size = self.font_size self.hook_length = self.scale * 30.0 self.hook_height = self.scale * 0.2 self.hook = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='grey') self.hook.transform = transforms.MatrixTransform() self.hook.transform.scale((self.hook_length, self.hook_height, 0.001)) self.hook.transform.translate( [self.hook_length / 2.016 + self.scale * self.model.x, 0.0]) self.hook.transform.translate(self.center) self.rod_width = self.scale * self.model.l / 20.0 self.rod = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='green') self.rod.transform = transforms.MatrixTransform() self.rod.transform.scale( (self.rod_width, self.scale * self.model.l, 0.0001)) self.rod.transform.translate([0.0, self.scale * self.model.l / 2.0]) self.rod.transform.rotate(np.rad2deg(self.model.theta), (0, 0, 1)) self.rod.transform.translate([self.scale * self.model.x, 0.0]) self.rod.transform.translate(self.center) # Append all the visuals self.visuals.append(self.rod) self.visuals.append(self.hook) self.visuals.append(self.text)