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)
