def glumpy_viewer(
img_array,
arrays_to_print=[],
commands=None,
cmap=glumpy.colormap.IceAndFire,
window_shape=(512, 512),
):
"""
Setup and start glumpy main loop to visualize Image array `img_array`.
img_array - an array-like object whose elements are float32 or uint8
ndarrays that glumpy can show. larray objects work here.
arrays_to_print - arrays whose elements will be printed to stdout
after a keypress changes the current position.
"""
try:
n_imgs = len(img_array)
except TypeError:
n_imgs = None
state = dict(window=glumpy.Window(*window_shape),
pos=0,
I=glumpy.Image(img_array[0], cmap=cmap),
len=n_imgs)
window = state['window'] # put in scope of handlers for convenience
if commands is None:
commands = _commands
@window.event
def on_draw():
window.clear()
state['I'].blit(0, 0, window.width, window.height)
@window.event
def on_key_press(symbol, modifiers):
if chr(symbol) not in commands:
print 'unused key', chr(symbol), modifiers
return
pos = state['pos']
commands[chr(symbol)](state)
if pos == state['pos']:
return
else:
img_i = img_array[state['pos']]
#print img_i.shape
#print img_i.dtype
#print img_i.max()
#print img_i.min()
state['I'] = glumpy.Image(img_array[state['pos']], cmap=cmap)
print state['pos'], [o[state['pos']] for o in arrays_to_print]
window.draw()
window.mainloop()
def show(interpolation='nearest'):
''' pylab show proxy function. '''
global frame
# Draw current figure to rgba buffer
fig = plt.gcf()
fig.canvas.draw()
buffer = fig.canvas.buffer_rgba(0, 0)
x, y, w, h = fig.bbox.bounds
F = numpy.fromstring(buffer, numpy.uint8).copy()
F.shape = h, w, 4
# Replace 'transparent' color with a real transparent color
v = numpy.array(_transparent, dtype=numpy.uint8).view(dtype=numpy.int32)[0]
Ft = numpy.where(F.view(dtype=numpy.int32) == v, 0, F)
# Create main frame
window = glumpy.Window(512, 512) #Ft.shape[1], Ft.shape[0])
frame = glumpy.Image(Ft, interpolation=interpolation)
frame.update()
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
@window.event
def on_resize(width, height):
global frame
fig = plt.gcf()
dpi = float(fig.dpi)
winch = width / dpi
hinch = height / dpi
fig.set_size_inches(winch, hinch)
fig.canvas.draw()
buffer = fig.canvas.buffer_rgba(0, 0)
x, y, w, h = fig.bbox.bounds
F = numpy.fromstring(buffer, numpy.uint8).copy()
F.shape = h, w, 4
# Replace 'transparent' color with a real transparent color
v = numpy.array(_transparent,
dtype=numpy.uint8).view(dtype=numpy.int32)[0]
Ft = numpy.where(F.view(dtype=numpy.int32) == v, 0, F)
# Create main frame
frame = glumpy.Image(Ft, interpolation=interpolation)
frame.update()
@window.event
def on_draw():
window.clear()
for image, axis, alpha in _items:
x, y, w, h = axis.get_axes().bbox.bounds
x /= float(frame.shape[1])
y /= float(frame.shape[0])
w /= float(frame.shape[1])
h /= float(frame.shape[0])
gl.glColor4f(1, 1, 1, alpha)
image.blit(x * window.width, y * window.height, w * window.width,
h * window.height)
gl.glColor4f(1, 1, 1, 1)
frame.blit(0, 0, window.width, window.height)
@window.event
def on_key_press(symbol, modifiers):
#if symbol == pyglet.window.key.SPACE:
# savefig('test.png', window.width, window.height)
if symbol == glumpy.key.ESCAPE:
if (window.width == frame.shape[1]
and window.height == frame.shape[0]):
sys.exit()
else:
window.set_size(frame.shape[1], frame.shape[0])
return True
return window
# find_stim(self, stim)
# ==============================================================================================
# ==============================================================================================
# ========================================= Plotting ===========================================
# ==============================================================================================
# ==============================================================================================
global ax, fig
fig = plt.figure(figsize=(7, 7))
ax = plt.subplot(111)
# ax.plot(data)
global window
w, h = fig.get_size_inches() * fig.dpi
window = glumpy.Window(int(w), int(h)) #Ft.shape[1], Ft.shape[0])
global channel
channel = 0
def get_channel():
global channel
return channel
def set_channel(c):
global channel
if (c > -1) and (c < 32):
channel = c
get_spikes()
global stim, stimI
visibles = numpy.zeros((opts.rows // 2, 28, 28), 'f')
hiddens = numpy.zeros((opts.rows // 2, opts.rows, opts.cols), 'f')
weights = numpy.zeros((opts.rows, opts.cols, 28, 28), 'f')
m = opts.binary and 1.5 or 0.5
kwargs = dict(cmap=glumpy.colormap.Grey, vmin=0, vmax=255)
_visibles = [glumpy.Image(v, **kwargs) for v in visibles]
_hiddens = [glumpy.Image(h) for h in hiddens]
_weights = [[glumpy.Image(w, vmin=-m, vmax=m) for w in ws]
for ws in weights]
W = 100 * (opts.cols + 1) + 4
H = 100 * opts.rows + 4
win = glumpy.Window(W, H)
loaded = False
updates = -1
batches = 0.
recent = collections.deque(maxlen=20)
errors = [collections.deque(maxlen=20) for _ in range(10)]
testset = [None] * 10
trainset = dict((i, []) for i in range(10))
loader = idx_reader.iterimages(opts.labels, opts.images, False)
rbm = opts.model and pickle.load(open(opts.model, 'rb')) or rbm.RBM(
28 * 28, opts.rows * opts.cols, opts.binary)
trainer = rbm.Trainer(
rbm,
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#-----------------------------------------------------------------------------
# Copyright (C) 2009-2010 Nicolas P. Rougier
#
# Distributed under the terms of the BSD License. The full license is in
# the file COPYING, distributed as part of this software.
#-----------------------------------------------------------------------------
import numpy, glumpy
window = glumpy.Window(512,512)
@window.timer(5.0)
def timer_1(dt):
print 'tick 1'
window.clear()
window.draw()
@window.timer(2.0)
def timer_2(dt):
print 'tick 2'
window.clear()
window.draw()
window.mainloop()
count = rows * columns
pixels = struct.unpack('%dB' % count, image_data[:count])
image_data = image_data[count:]
yield label, numpy.array(pixels).astype(float).reshape((rows, columns))
if __name__ == '__main__':
import sys
import glumpy
# pass in label_file, then image_file
iterator = iterimages(sys.argv[1], sys.argv[2], False)
composites = [numpy.zeros((28, 28), 'f') for _ in range(10)]
images = [glumpy.Image(c) for c in composites]
win = glumpy.Window(800, 600)
@win.event
def on_draw():
win.clear()
w, h = win.get_size()
for i, image in enumerate(images):
image.blit(w * (i % 5) / 5., h * (i // 5) / 2., w / 5., h / 2.)
@win.event
def on_idle(dt):
try:
label, pixels = iterator.next()
except StopIteration:
sys.exit()
composites[label] *= 0.3
i = yi * n + xi
self.indices[xi, yi] = i, i + 1, i + n + 1, i + n
def draw(self):
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY)
gl.glVertexPointerf(self.vertices)
gl.glTexCoordPointerf(self.texcoords)
gl.glDrawElementsus(gl.GL_QUADS, self.indices)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glDisableClientState(gl.GL_TEXTURE_COORD_ARRAY)
if __name__ == '__main__':
window = glumpy.Window(900, 600)
trackball = glumpy.Trackball(60, 30, 0.85)
mesh = Mesh(64)
def func3(x, y):
return (1 - x / 2 + x**5 + y**3) * numpy.exp(-x**2 - y**2)
dx, dy = .05, .05
x = numpy.arange(-3.0, 3.0, dx, dtype=numpy.float32)
y = numpy.arange(-3.0, 3.0, dy, dtype=numpy.float32)
Z = func3(*numpy.meshgrid(x, y))
I = glumpy.Image(Z,
interpolation='bicubic',
cmap=glumpy.colormap.Hot,
lighted=True,
gridsize=(31.0, 31.0, 0.0),
def __init__(self, c):
self.controller = c
self.tracker_view = TrackerView()
self.gui_frame_rate = 0.0
self.n_frames = 0
self.frame_count = 0
self.frame_rate_accum = 0.0
self.frame_rates = []
self.start_time = None
self.last_time = 0
self.last_update_time = time.time()
self.update_interval = 1 / 10000.
atb.init()
# Try grabbing current Width x Height for window to draw:
# W = self.controller.get_camera_attribute('Width')
# H = self.controller.get_camera_attribute('Height')
# print "DEFINING WINDOW!!!! " + str(W) + ", " + str(H)
self.window = glumpy.Window(656, 492) # (900, 700)
# ---------------------------------------------------------------------
# STAGE CONTROLS
# ---------------------------------------------------------------------
self.stages_bar = atb.Bar(
name='stages',
label='Stage Controls',
iconified='true',
help='Controls for adjusting stages',
position=(10, 10),
size=(200, 300),
)
self.stages_bar.add_var('X/x_set',
label='set value',
target=c,
attr='x_set')
self.stages_bar.add_button('go_rel_x',
lambda: c.go_rel_x(),
group='X',
label='move relative')
self.stages_bar.add_button('go_abs_x',
lambda: c.go_x(),
group='X',
label='move absolute')
self.stages_bar.add_var('Y/y_set',
label='set value',
target=c,
attr='y_set')
self.stages_bar.add_button('go_rel_y',
lambda: c.go_rel_y(),
group='Y',
label='move relative')
self.stages_bar.add_button('go_abs_y',
lambda: c.go_y(),
group='Y',
label='move absolute')
self.stages_bar.add_var('R/r_set',
label='set value',
target=c,
attr='r_set')
self.stages_bar.add_button('go_rel_r',
lambda: c.go_rel_r(),
group='R',
label='move relative')
self.stages_bar.add_button('go_abs_r',
lambda: c.go_r(),
group='R',
label='move absolute')
self.stages_bar.add_button('up',
lambda: c.up(),
group='Jog',
label='up')
self.stages_bar.add_button('down',
lambda: c.down(),
group='Jog',
label='down')
self.stages_bar.add_button('left',
lambda: c.left(),
group='Jog',
label='left')
self.stages_bar.add_button('right',
lambda: c.right(),
group='Jog',
label='right')
# ---------------------------------------------------------------------
# FOCUS AND ZOOM CONTROLS
# ---------------------------------------------------------------------
self.focus_zoom_bar = atb.Bar(
name='focus_and_zoom',
label='Focus/Zoom Controls',
iconified='true',
help='Controls for adjusting power focus and zoom',
position=(10, 10),
size=(200, 300),
)
self.focus_zoom_bar.add_var('Focus/focus_step',
label='focus step',
target=c,
attr='focus_step')
self.focus_zoom_bar.add_button('focus_plus',
lambda: c.focus_plus(),
group='Focus',
label='focus plus')
self.focus_zoom_bar.add_button('focus_minus',
lambda: c.focus_minus(),
group='Focus',
label='focus minus')
self.focus_zoom_bar.add_var('Zoom/zoom_step',
label='zoom step',
target=c,
attr='zoom_step')
self.focus_zoom_bar.add_button('zoom_plus',
lambda: c.zoom_plus(),
group='Zoom',
label='zoom plus')
self.focus_zoom_bar.add_button('zoom_minus',
lambda: c.zoom_minus(),
group='Zoom',
label='zoom minus')
# ---------------------------------------------------------------------
# LED CONTROLS
# ---------------------------------------------------------------------
self.led_bar = atb.Bar(
name='leds',
label='LED Controls',
iconified='true',
help='Controls for adjusting illumination',
position=(20, 20),
size=(200, 180),
)
self.led_bar.add_var(
'Side/Ch1_mA',
#target=c,
#attr='IsetCh1',
label='I Ch1 (mA)',
vtype=atb.TW_TYPE_UINT32,
setter=lambda x: c.led_set_current(1, x),
getter=lambda: c.led_soft_current(1),
min=0,
max=1000,
)
self.led_bar.add_var('Side/Ch1_status',
label='Ch1 status',
vtype=atb.TW_TYPE_BOOL8,
getter=lambda: c.led_soft_status(1),
setter=lambda x: c.led_set_status(1, x))
self.led_bar.add_var(
'Top/Ch2_mA',
#target=c,
#attr='IsetCh2',
label='I Ch2 (mA)',
vtype=atb.TW_TYPE_UINT32,
setter=lambda x: c.led_set_current(2, x),
getter=lambda: c.led_soft_current(2),
min=0,
max=1000,
)
self.led_bar.add_var('Top/Ch2_status',
vtype=atb.TW_TYPE_BOOL8,
getter=lambda: c.led_soft_status(2),
setter=lambda x: c.led_set_status(2, x))
# --------------------------------------------------------------------
# GUI
# --------------------------------------------------------------------
self.gui_bar = atb.Bar(
name='GUI',
label='GUI',
iconified='true',
help='GUI Status',
position=(60, 60),
size=(200, 180),
)
self.gui_bar.add_var('gui_framerate',
label='gui frame rate',
vtype=atb.TW_TYPE_FLOAT,
min=1,
max=200,
step=0.1,
readonly=True,
getter=lambda: float(self.gui_frame_rate))
# --------------------------------------------------------------------
# CAMERA
# --------------------------------------------------------------------
self.cam_bar = atb.Bar(
name='Camera',
label='Camera',
iconified='true',
help='Camera acquisition parameters',
position=(60, 60),
size=(200, 180),
)
self.cam_bar.add_var(
'Recording/status',
label='REC',
vtype=atb.TW_TYPE_UINT32,
getter=lambda: c.get_recording_status('recording'),
setter=lambda x: c.set_recording_status('recording', int(x)),
#attr='recording',
)
self.cam_bar.add_var(
'Recording/name',
label='name',
vtype=atb.TW_TYPE_CDSTRING,
getter=lambda: c.get_recording_name('subname'),
setter=lambda x: c.set_recording_name(str(x)),
#attr='recording',
)
PixelFormat = atb.enum('PixelFormat', {
'Mono8': 0,
'Mono12Packed': 1,
'Mono16': 2
})
self.cam_bar.add_var(
'PixelFormat',
label='pixel format',
vtype=PixelFormat,
getter=lambda: c.get_pixel_format('PixelFormat'),
setter=lambda x: c.set_pixel_format('PixelFormat', int(x)),
)
self.cam_bar.add_var(
'BytesPerFrame',
label='total bytes per frame',
vtype=atb.TW_TYPE_UINT32,
min=1,
max=645504,
step=1,
getter=lambda: c.get_camera_attribute('TotalBytesPerFrame'),
# setter=lambda x: c.set_camera_attribute('BinningX', int(x)),
)
self.cam_bar.add_var(
'framerate',
label='frame rate',
vtype=atb.TW_TYPE_FLOAT,
min=1,
max=125,
step=0.1,
readonly=True,
getter=lambda: float(c.get_frame_rate()),
)
self.cam_bar.add_var(
'Binning/binningX',
label='binning X',
vtype=atb.TW_TYPE_UINT32,
min=1,
max=4,
step=1,
getter=lambda: c.get_camera_attribute('BinningX'),
setter=lambda x: c.set_camera_attribute('BinningX', int(x)),
)
self.cam_bar.add_var(
'Binning/binningY',
label='binning Y',
vtype=atb.TW_TYPE_UINT32,
min=1,
max=4,
step=1,
getter=lambda: c.get_camera_attribute('BinningY'),
setter=lambda x: c.set_camera_attribute('BinningY', int(x)),
)
ExposureMode = atb.enum('ExposureMode', {
'Manual': 0,
'AutoOnce': 1,
'Auto': 2
})
self.cam_bar.add_var(
'Exposure/mode',
label='mode',
vtype=ExposureMode,
getter=lambda: c.get_exposure_mode('ExposureMode'),
setter=lambda x: c.set_exposure_mode('ExposureMode', int(x)),
)
self.cam_bar.add_var(
'Exposure/value',
label='time (us)',
vtype=atb.TW_TYPE_UINT32,
min=0,
max=150000,
step=1,
getter=lambda: c.get_camera_attribute('ExposureValue'),
setter=lambda x: c.set_camera_attribute('ExposureValue', int(x)),
)
self.cam_bar.add_var(
'gain',
label='Gain',
vtype=atb.TW_TYPE_UINT32,
min=1,
max=50,
step=1,
#target=c,
getter=lambda: c.get_camera_attribute('GainValue'),
setter=lambda x: c.set_camera_attribute('GainValue', int(x)),
attr='gain',
)
# self.cam_bar.add_var(
# 'exposure',
# label='exposure',
# vtype=atb.TW_TYPE_UINT32,
# min=5000,
# max=30000,
# step=1000,
# target=c,
# attr='exposure',
# )
self.cam_bar.add_var(
'ROI/roi_width',
label='width',
vtype=atb.TW_TYPE_UINT32,
min=1,
max=656, #656,
step=1,
#target=c,
getter=lambda: c.get_camera_attribute('Width'),
setter=lambda x: c.set_camera_attribute('Width', int(x)),
attr='roi_width',
)
self.cam_bar.add_var(
'ROI/roi_height',
label='height',
vtype=atb.TW_TYPE_UINT32,
min=1,
max=492, #492,
step=1,
#target=c,
getter=lambda: c.get_camera_attribute('Height'),
setter=lambda x: c.set_camera_attribute('Height', int(x)),
attr='roi_height',
)
# self.cam_bar.add_var(
# 'ROI/roi_offset_x',
# label='offset x',
# vtype=atb.TW_TYPE_UINT32,
# min=0,
# max=800,
# step=1,
# target=c,
# attr='roi_offset_x',
# )
# self.cam_bar.add_var(
# 'ROI/roi_offset_y',
# label='offset y',
# vtype=atb.TW_TYPE_UINT32,
# min=0,
# max=800,
# step=1,
# target=c,
# attr='roi_offset_y',
# )
# Event Handlers
def on_init():
self.tracker_view.prepare_opengl()
def on_draw():
self.tracker_view.draw((self.window.width, self.window.height))
def on_idle(dt):
self.update_tracker_view()
# time.sleep(0.05)
def on_key_press(symbol, modifiers):
if symbol == glumpy.key.ESCAPE:
c.stop_continuous_acquisition()
print "Controller has %i refs" % sys.getrefcount(c)
c.release()
self.controller = None
print "Controller has %i refs" % sys.getrefcount(c)
c.shutdown()
#print "Shutting down controller..."
#print "Shut down controller", c.shutdown()
#c.continuously_acquiring = False
#c.acq_thread.join()
sys.exit()
self.window.push_handlers(atb.glumpy.Handlers(self.window))
self.window.push_handlers(on_init, on_draw, on_key_press, on_idle)
self.window.draw()
gl.glVertex2i(x+width,y+height)
gl.glVertex2i(x,y+height)
gl.glEnd()
# -----------------------------------------------------------------------------
if __name__ == '__main__':
image = Image.open('lena.png')
S = numpy.asarray(image, dtype=numpy.float32)/256. # Visual scene
R = numpy.zeros((256,256,3),dtype=numpy.float32)
V = numpy.zeros((256,256,3),dtype=numpy.float32)
Px,Py = retinotopy(R.shape[:2],V.shape[:2])
X,Y = 0,0
window = glumpy.Window(S.shape[1]+2*V.shape[1],
max(S.shape[0],2*V.shape[0]))
Si = glumpy.Image(S, cmap=glumpy.colormap.Grey)
Vi = glumpy.Image(V, cmap=glumpy.colormap.Grey)
gl.glBlendFunc (gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
@window.event
def on_mouse_motion(x, y, dx, dy):
global X,Y
X = min(max(x-V.shape[1]//2,1), S.shape[1]-V.shape[1])
Y = min(max((window.height-y)-V.shape[0]//2,1), S.shape[0]-V.shape[0])
r,g,b = S[Y,X]
S[Y,X] = 0
V[...] = S[Y+Px,X+Py]
S[Y,X] = r,g,b
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#-----------------------------------------------------------------------------
# Copyright (C) 2009-2010 Nicolas P. Rougier
#
# Distributed under the terms of the BSD License. The full license is in
# the file COPYING, distributed as part of this software.
#-----------------------------------------------------------------------------
import sys
import glumpy
import OpenGL.GL as gl
import OpenGL.GLUT as glut
if __name__ == '__main__':
window = glumpy.Window(fullscreen=True)
trackball = glumpy.Trackball(65,135,1.25,3)
def draw_background():
viewport = gl.glGetIntegerv(gl.GL_VIEWPORT)
gl.glDisable (gl.GL_LIGHTING)
gl.glDisable (gl.GL_DEPTH_TEST);
gl.glBegin(gl.GL_QUADS)
gl.glColor(1.0,1.0,1.0)
gl.glVertex(0,0,-1)
gl.glVertex(viewport[2],0,-1)
gl.glColor(0.0,0.5,1.0)
gl.glVertex(viewport[2],viewport[3],0)
gl.glVertex(0,viewport[3],0)
gl.glEnd()
force = 1
source = 25.0
u = numpy.zeros((size,size), dtype=numpy.float32)
u_ = numpy.zeros((size,size), dtype=numpy.float32)
v = numpy.zeros((size,size), dtype=numpy.float32)
v_ = numpy.zeros((size,size), dtype=numpy.float32)
dens = numpy.zeros((size,size), dtype=numpy.float32)
dens_ = numpy.zeros((size,size), dtype=numpy.float32)
Z = numpy.zeros((N,N),dtype=numpy.float32)
cmap = glumpy.colormap.Colormap("BlueGrey",
(0., (0.,0.,0.)), (1., (0.75,0.75,1.00)))
I = glumpy.Image(Z, interpolation='bicubic', cmap=cmap, vmin=0, vmax=5)
t, t0, frames = 0,0,0
window = glumpy.Window(800,800)
window.last_drag = None
@window.event
def on_mouse_drag(x, y, dx, dy, button):
window.last_drag = x,y,dx,dy,button
@window.event
def on_mouse_motion(x, y, dx, dy):
window.last_drag = x,y,dx,dy,0
@window.event
def on_key_press(key, modifiers):
global dens, dens_, u, u_, v, v_
if key == glumpy.key.ESCAPE:
window.exit();
import numpy as np
from glumpy import app, gloo, gl, glm
import glumpy
window = glumpy.Window(700, 600, "hello")
V = np.zeros(8, [("position", np.float32, 3)])
V["position"] = [[1, 1, 1], [-1, 1, 1], [-1, -1, 1], [1, -1, 1], [1, -1, -1],
[1, 1, -1], [-1, 1, -1], [-1, -1, -1]]
I = np.array([
0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5, 0, 5, 6, 0, 6, 1, 1, 6, 7, 1, 7, 2, 7,
4, 3, 7, 3, 2, 4, 7, 6, 4, 6, 5
],
dtype=np.uint32)
V = V.view(gloo.VertexBuffer)
I = I.view(gloo.IndexBuffer)
vertex = """
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
attribute vec3 position;
void main()
{
gl_Position = projection * view * model * vec4(position,1.0);
} """
fragment = """
void main()
{
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
def __init__(self, c):
self.controller = c
self.tracker_view = TrackerView()
self.show_feature_map = c_bool(False)
self.display_starburst = c_bool(False)
self.n_frames = 0
self.frame_count = 0
self.frame_rate_accum = 0.0
self.frame_rates = []
self.start_time = None
self.last_time = 0
self.last_update_time = time.time()
self.calibration_file = ''
atb.init()
self.window = glumpy.Window(900, 600)
self.window.draw()
self.gaze_bar = atb.Bar(name='gaze',
label='Gaze Info',
iconified='false',
help='Current Gaze',
position=(10, 10),
size=(100, 200))
# self.gaze_bar.add_var('Gaze/Status', label='Calibration Status',
# target=c, attr='calibration_status', readonly=True)
self.gaze_bar.add_var('Gaze/H',
label='Horizontal Gaze',
target=c,
attr='gaze_azimuth',
readonly=True)
self.gaze_bar.add_var('Gaze/V',
label='Vertical Gaze',
target=c,
attr='gaze_elevation',
readonly=True)
# self.gaze_bar.add_var('FPS', label='FPS', target=c,
# attr='conduit_fps', readonly=True)
# ---------------------------------------------------------------------
# STAGE CONTROLS
# ---------------------------------------------------------------------
# self.stages_bar = atb.Bar(
# name='stages',
# label='Stage Controls',
# iconified='true',
# help='Controls for adjusting stages',
# position=(10, 10),
# size=(200, 300),
# )
# self.stages_bar.add_var('X/x_set', label='set value', target=c,
# attr='x_set')
# self.stages_bar.add_button('go_rel_x', lambda: c.go_rel_x(), group='X',
# label='move relative')
# self.stages_bar.add_button('go_abs_x', lambda: c.go_x(), group='X',
# label='move absolute')
# self.stages_bar.add_var('Y/y_set', label='set value', target=c,
# attr='y_set')
# self.stages_bar.add_button('go_rel_y', lambda: c.go_rel_y(), group='Y',
# label='move relative')
# self.stages_bar.add_button('go_abs_y', lambda: c.go_y(), group='Y',
# label='move absolute')
# self.stages_bar.add_var('R/r_set', label='set value', target=c,
# attr='r_set')
# self.stages_bar.add_button('go_rel_r', lambda: c.go_rel_r(), group='R',
# label='move relative')
# self.stages_bar.add_button('go_abs_r', lambda: c.go_r(), group='R',
# label='move absolute')
# self.stages_bar.add_button('up', lambda: c.up(), group='Jog',
# label='up')
# self.stages_bar.add_button('down', lambda: c.down(), group='Jog',
# label='down')
# self.stages_bar.add_button('left', lambda: c.left(), group='Jog',
# label='left')
# self.stages_bar.add_button('right', lambda: c.right(), group='Jog',
# label='right')
# ---------------------------------------------------------------------
# FOCUS AND ZOOM CONTROLS
# ---------------------------------------------------------------------
# self.focus_zoom_bar = atb.Bar(
# name='focus_and_zoom',
# label='Focus/Zoom Controls',
# iconified='true',
# help='Controls for adjusting power focus and zoom',
# position=(10, 10),
# size=(200, 300),
# )
# self.focus_zoom_bar.add_var('Focus/focus_step', label='focus step',
# target=c, attr='focus_step')
# self.focus_zoom_bar.add_button('focus_plus', lambda: c.focus_plus(),
# group='Focus', label='focus plus')
# self.focus_zoom_bar.add_button('focus_minus', lambda: c.focus_minus(),
# group='Focus', label='focus minus')
# self.focus_zoom_bar.add_var('Zoom/zoom_step', label='zoom step',
# target=c, attr='zoom_step')
# self.focus_zoom_bar.add_button('zoom_plus', lambda: c.zoom_plus(),
# group='Zoom', label='zoom plus')
# self.focus_zoom_bar.add_button('zoom_minus', lambda: c.zoom_minus(),
# group='Zoom', label='zoom minus')
# ---------------------------------------------------------------------
# LED CONTROLS
# ---------------------------------------------------------------------
# self.led_bar = atb.Bar(
# name='leds',
# label='LED Controls',
# iconified='true',
# help='Controls for adjusting illumination',
# position=(20, 20),
# size=(200, 180),
# )
# self.led_bar.add_var(
# 'Side/Ch1_mA',
# #target=c,
# #attr='IsetCh1',
# label='I Ch1 (mA)',
# vtype=atb.TW_TYPE_UINT32,
# setter=lambda x: c.leds.set_current(1, x),
# getter=lambda: c.leds.soft_current(1),
# min=0,
# max=1000,
# )
# self.led_bar.add_var('Side/Ch1_status', label='Ch1 status',
# vtype=atb.TW_TYPE_BOOL8,
# getter=lambda: c.leds.soft_status(1),
# setter=lambda x: c.leds.set_status(1, x))
# self.led_bar.add_var(
# 'Top/Ch2_mA',
# #target=c,
# #attr='IsetCh2',
# label='I Ch2 (mA)',
# vtype=atb.TW_TYPE_UINT32,
# setter=lambda x: c.leds.set_current(2, x),
# getter=lambda: c.leds.soft_current(2),
# min=0,
# max=1000,
# )
# self.led_bar.add_var('Top/Ch2_status', vtype=atb.TW_TYPE_BOOL8,
# getter=lambda: c.leds.soft_status(2),
# setter=lambda x: c.leds.set_status(2, x))
#self.led_bar.add_var(
# 'Channel3/Ch3_mA',
# target=c,
# attr='IsetCh3',
# label='I Ch3 (mA)',
# setter=lambda x: c.leds.set_current(3,x),
# min=0,
# max=250,
# )
# self.led_bar.add_var('Channel3/Ch3_status', label='Ch3 status',
# vtype=atb.TW_TYPE_BOOL8,
# getter=lambda: c.leds.soft_status(3),
# setter=lambda x: c.leds.set_status(3, x))
#
# self.led_bar.add_var(
# 'Channel4/Ch4_mA',
# target=c,
# attr='IsetCh4',
# label='I Ch4 (mA)',
# setter=lambda x: c.leds.set_current(4,x),
# min=0,
# max=250,
# )
# self.led_bar.add_var('Channel4/Ch4_status', label='Ch4 status',
# vtype=atb.TW_TYPE_BOOL8,
# getter=lambda: c.leds.soft_status(4),
# setter=lambda x: c.leds.set_status(4, x))
# ---------------------------------------------------------------------
# RADIAL FEATURE FINDER
# ---------------------------------------------------------------------
if True:
radial_ff = c.radial_ff
self.radial_ff_bar = atb.Bar(
name='RadialFF',
label='Radial Symmetry',
help='Parameters for initial (symmetry-based) image processing',
iconified='true',
position=(30, 30),
size=(250, 180),
)
self.radial_ff_bar.add_var(
'target_kpixels',
label='Target kPixels',
vtype=atb.TW_TYPE_FLOAT,
min=50.,
max=1000.,
step=10.,
target=radial_ff,
attr='target_kpixels',
)
self.radial_ff_bar.add_var(
'min_radius_fraction',
label='Min. radius (fraction)',
vtype=atb.TW_TYPE_FLOAT,
min=0.01,
max=0.5,
step=0.01,
target=radial_ff,
attr='min_radius_fraction',
)
self.radial_ff_bar.add_var(
'max_radius_fraction',
label='Max. radius (fraction)',
vtype=atb.TW_TYPE_FLOAT,
min=0.1,
max=0.8,
step=0.01,
target=radial_ff,
attr='max_radius_fraction',
)
self.radial_ff_bar.add_var(
'radius_steps',
label='Radius steps',
vtype=atb.TW_TYPE_UINT32,
min=1,
max=10,
step=1,
target=radial_ff,
attr='radius_steps',
)
self.radial_ff_bar.add_var(
'alpha',
label='Alpha',
vtype=atb.TW_TYPE_FLOAT,
min=1.,
max=50.,
step=1.,
target=radial_ff,
attr='alpha',
)
self.radial_ff_bar.add_var('show_transform',
label='Show Transform',
vtype=atb.TW_TYPE_BOOL8,
target=self,
attr='show_feature_map')
self.radial_ff_bar.add_var('Albino/albino_mode_enable',
label='Mode Enabled',
vtype=atb.TW_TYPE_BOOL8,
target=radial_ff,
attr='albino_mode')
self.radial_ff_bar.add_var(
'Albino/albino_threshold',
label='Threshold',
vtype=atb.TW_TYPE_FLOAT,
min=0.1,
max=50.,
step=1.,
target=radial_ff,
attr='albino_threshold',
)
self.radial_ff_bar.add_var(
'RestrictRegion/top',
label='top',
vtype=atb.TW_TYPE_UINT32,
min=0,
max=300,
step=1,
target=radial_ff,
attr='restrict_top',
)
self.radial_ff_bar.add_var(
'RestrictRegion/left',
label='left',
vtype=atb.TW_TYPE_UINT32,
min=0,
max=300,
step=1,
target=radial_ff,
attr='restrict_left',
)
self.radial_ff_bar.add_var(
'RestrictRegion/right',
label='right',
vtype=atb.TW_TYPE_UINT32,
min=0,
max=300,
step=1,
target=radial_ff,
attr='restrict_right',
)
self.radial_ff_bar.add_var(
'RestrictRegion/bottom',
label='bottom',
vtype=atb.TW_TYPE_UINT32,
min=0,
max=300,
step=1,
target=radial_ff,
attr='restrict_bottom',
)
# ---------------------------------------------------------------------
# STARBURST FEATURE FINDER
# ---------------------------------------------------------------------
self.sb_ff_bar = atb.Bar(
name='StarburstFF',
label='Starburst',
iconified='true',
help=
"Parameters for the refinement phase ('starburst') image processing",
position=(40, 40),
size=(200, 250),
)
sb_ff = c.starburst_ff
self.sb_ff_bar.add_var(
'Pupil/n_pupil_rays',
label='n rays',
vtype=atb.TW_TYPE_UINT32,
min=1,
max=100,
step=1,
target=sb_ff,
attr='pupil_n_rays',
)
self.sb_ff_bar.add_var(
'Pupil/pupil_min_radius',
label='min radius',
vtype=atb.TW_TYPE_UINT32,
min=1,
max=100,
step=1,
target=sb_ff,
attr='pupil_min_radius',
)
self.sb_ff_bar.add_var(
'Pupil/pupil_threshold',
label='edge detect threshold',
vtype=atb.TW_TYPE_FLOAT,
min=0.1,
max=5.0,
step=0.1,
target=sb_ff,
attr='pupil_threshold',
)
self.sb_ff_bar.add_var(
'CR/n_cr_rays',
label='n rays',
vtype=atb.TW_TYPE_UINT32,
min=1,
max=100,
step=1,
target=sb_ff,
attr='cr_n_rays',
)
self.sb_ff_bar.add_var(
'CR/cr_min_radius',
label='min radius',
vtype=atb.TW_TYPE_UINT32,
min=1,
max=100,
step=1,
target=sb_ff,
attr='cr_min_radius',
)
self.sb_ff_bar.add_var(
'CR/cr_threshold',
label='edge detect threshold',
vtype=atb.TW_TYPE_FLOAT,
min=0.1,
max=5.0,
step=0.1,
target=sb_ff,
attr='cr_threshold',
)
fit_algos = {
0: 'circle_least_squares',
1: 'circle_least_squares_ransac',
2: 'ellipse_least_squares'
}
fit_algos_rev = dict([(val, key)
for (key, val) in fit_algos.items()])
FittingAlgorithm = atb.enum('FittingAlgorithm', {
'circle lst sq': 0,
'circle ransac': 1,
'ellipse lst sq': 2
})
self.sb_ff_bar.add_var('Fitting/circle_fit', label='circle fit method',
vtype=FittingAlgorithm, getter=lambda: \
fit_algos_rev[sb_ff.fitting_algorithm],
setter=lambda x: \
setattr(sb_ff, 'fitting_algorithm', fit_algos[x]))
self.sb_ff_bar.add_var('Display/show_rays', self.display_starburst)
# ---------------------------------------------------------------------
# CALIBRATION
# ---------------------------------------------------------------------
# self.cal_bar = atb.Bar(
# name='Calibration',
# label='Calibration',
# iconified='true',
# help='Auto-calibration steps',
# position=(50, 50),
# size=(250, 300),
# refresh=0.5
# )
# self.cal_bar.add_button('calibrate', lambda: c.calibrate(),
# label='Calibrate (full)')
# self.cal_bar.add_separator('Sub-phases')
# self.cal_bar.add_button('cal_center_h', lambda: \
# c.calibrate_center_horizontal(),
# label='Center Horizontal')
# self.cal_bar.add_button('cal_center_v', lambda: \
# c.calibrate_center_vertical(),
# label='Center Vertical')
# self.cal_bar.add_button('cal_center_d', lambda: \
# c.calibrate_center_depth(), label='Center Depth'
# )
# self.cal_bar.add_button('cal_pupil_rad', lambda: \
# c.calibrate_find_pupil_radius(),
# label='Find Pupil Radius')
# self.cal_bar.add_separator('Info')
# self.cal_bar.add_var('d', label='Distance to CR curv. center',
# vtype=atb.TW_TYPE_FLOAT, target=c.calibrator,
# attr='d') # readonly = True,
# self.cal_bar.add_var('Rp', label='Pupil rotation radius (Rp)[mm]',
# vtype=atb.TW_TYPE_FLOAT, target=c.calibrator,
# attr='Rp_mm') # readonly = True,
# # Calibration Files
# try:
# self.refresh_calibration_file_list()
# self.cal_bar.add_separator('Calibration Files')
# self.cal_bar.add_var('current_calibration_file',
# vtype=self.cal_enum, label='Calibration File',
# getter=lambda: \
# self.get_calibration_file_atb(),
# setter=lambda x: \
# self.set_calibration_file_atb(x))
# # setter = lambda x: sb_ff.__dict__.__setitem__('fitting_algorithm', fit_algos[x]))
# # getter=lambda: self.get_calibration_file_atb,
# # setter=lambda x: self.set_calibration_file_atb(x))
# self.cal_bar.add_separator('Calibration Save')
# self.cal_file_save_name = ctypes.c_char_p('')
# self.cal_bar.add_var('calibration_file_save_name',
# vtype=atb.TW_TYPE_CDSTRING, target=self,
# attr='cal_file_save_name')
# self.cal_bar.add_button('save_calibration', lambda: \
# self.save_calibration_file_atb(self.cal_file_save_name))
# except Exception as E:
# logging.warning("Error setting calibration file list: %s" % E)
# logging.warning("""Unable to use calibration-file saving
# infrastructure. A patched version of glumpy
# is required to enable this feature.""")
# --------------------------------------------------------------------
# CAMERA
# --------------------------------------------------------------------
self.cam_bar = atb.Bar(
name='Camera',
label='Camera',
iconified='true',
help='Camera acquisition parameters',
position=(60, 60),
size=(200, 180),
)
cam = c.camera
# def saving(x=None):
# if not hasattr(c.feature_finder, 'save'):
# return False
# if x is None:
# return c.feature_finder.save
# c.feature_finder.save = x
# self.cam_bar.add_var(
# 'save',
# label='save',
# vtype=atb.TW_TYPE_BOOL8,
# getter=lambda: saving(),
# setter=lambda x: saving(x),
# )
# self.cam_bar.add_var(
# 'binning',
# label='binning',
# vtype=atb.TW_TYPE_UINT32,
# min=1,
# max=16,
# step=1,
# target=cam,
# attr='binning',
# )
# self.cam_bar.add_var(
# 'gain',
# label='gain',
# vtype=atb.TW_TYPE_UINT32,
# min=1,
# max=16,
# step=1,
# target=cam,
# attr='gain',
# )
# self.cam_bar.add_var(
# 'exposure',
# label='exposure',
# vtype=atb.TW_TYPE_UINT32,
# min=5000,
# max=30000,
# step=1000,
# target=c,
# attr='exposure',
# )
self.cam_bar.add_var(
'ROI/roi_width',
label='width',
vtype=atb.TW_TYPE_UINT32,
min=1,
max=800,
step=1,
target=cam,
attr='roi_width',
)
self.cam_bar.add_var(
'ROI/roi_height',
label='height',
vtype=atb.TW_TYPE_UINT32,
min=1,
max=800,
step=1,
target=cam,
attr='roi_height',
)
# Event Handlers
def on_init():
self.tracker_view.prepare_opengl()
def on_draw():
self.window.clear()
self.tracker_view.draw((self.window.width, self.window.height))
def on_idle(dt):
# if dt < 0.02:
# return
self.update_tracker_view()
self.window.draw()
def on_key_press(symbol, modifiers):
if symbol == glumpy.key.ESCAPE:
c.stop_continuous_acquisition()
logging.debug("Controller has %i refs" % sys.getrefcount(c))
c.release()
self.controller = None
logging.debug("Controller has %i refs" % sys.getrefcount(c))
c.shutdown()
sys.exit()
self.window.push_handlers(atb.glumpy.Handlers(self.window))
self.window.push_handlers(on_init, on_draw, on_key_press, on_idle)
self.window.draw()
i = yi * n + xi
self.indices[xi, yi] = i, i + 1, i + n + 1, i + n
def draw(self):
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY)
gl.glVertexPointerf(self.vertices)
gl.glTexCoordPointerf(self.texcoords)
gl.glDrawElementsus(gl.GL_QUADS, self.indices)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glDisableClientState(gl.GL_TEXTURE_COORD_ARRAY)
if __name__ == '__main__':
window = glumpy.Window(width=800, height=600)
trackball = glumpy.Trackball(60, 30, 0.75)
mesh = Mesh(64)
# def func3(x,y):
# return (1-x/2+x**5+y**3)*numpy.exp(-x**2-y**2)
# dx, dy = .01, .01
# x = numpy.arange(-3.0, 3.0, dx, dtype=numpy.float32)
# y = numpy.arange(-3.0, 3.0, dy, dtype=numpy.float32)
# Z = func3(*numpy.meshgrid(x, y))
n = 64.0
X = numpy.empty((n, n), dtype=numpy.float32)
X.flat = numpy.arange(n) * 2 * numpy.pi / n * 2
Y = numpy.empty((n, n), dtype=numpy.float32)
Y.flat = numpy.arange(n) * 2 * numpy.pi / n * 2
def ShowMesh3D(hmesh, nim, col, cmap, lighting, mode):
cm = gp.colormap.Grey
if cmap == 'Hot':
cm = gp.colormap.Hot
elif cmap == 'Fire':
cm = gp.colormap.Fire
elif cmap == 'Ice':
cm = gp.colormap.Ice
elif cmap == 'IceAndFire':
cm = gp.colormap.IceAndFire
wire = True
fill = True
if mode == 'Wire':
fill = False
elif mode == 'Fill':
wire = False
mesh = []
if type(hmesh) is list:
for i in range(len(hmesh)):
mesh.append(Mesh3D(hmesh[i], nim, cm))
else:
mesh.append(Mesh3D(hmesh, nim, cm))
window = gp.Window(800, 800)
trackball = gp.Trackball(0, 0, 2)
@window.event
def on_draw():
gl.glClearColor(0, 0, 0, 1)
window.clear()
trackball.push()
if lighting == True:
gl.glEnable(gl.GL_LIGHTING)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
#I.shader.bind(I.texture,I._lut)
for i in range(len(mesh)):
if type(col) is list:
c = col[i]
else:
c = col
gl.glColor4f(c[0], c[1], c[2], c[3])
if fill == True:
mesh[i].draw()
if wire == True:
gl.glPolygonMode(gl.GL_FRONT, gl.GL_LINE)
gl.glEnable(gl.GL_POLYGON_OFFSET_LINE)
gl.glPolygonOffset(-1, 0)
mesh[i].drawwire()
gl.glPolygonMode(gl.GL_FRONT, gl.GL_FILL)
gl.glDisable(gl.GL_POLYGON_OFFSET_LINE)
#I.shader.unbind()
trackball.pop()
@window.event
def on_init():
gl.glEnable(gl.GL_LIGHT0)
gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, (1.0, 0.7, 0.5, 1))
gl.glLightfv(gl.GL_LIGHT0, gl.GL_AMBIENT, (0.2, 0.2, 0.2, 1))
gl.glLightfv(gl.GL_LIGHT0, gl.GL_SPECULAR, (1.0, 1.0, 1.0, 1))
#gl.glLightfv (gl.GL_LIGHT0, gl.GL_POSITION,(-1.0, 2.0, -1.0, 0.0))
gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, (-0.5, -0.2, -1, 0))
gl.glEnable(gl.GL_BLEND)
#gl.glColorMaterial(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE)
gl.glColorMaterial(gl.GL_FRONT_AND_BACK, gl.GL_DIFFUSE)
gl.glMaterialfv(gl.GL_FRONT, gl.GL_SHININESS, 50.0)
gl.glEnable(gl.GL_COLOR_MATERIAL)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glPolygonMode(gl.GL_FRONT, gl.GL_FILL)
gl.glFrontFace(gl.GL_CW)
gl.glEnable(gl.GL_CULL_FACE)
gl.glShadeModel(gl.GL_SMOOTH)
@window.event
def on_mouse_drag(x, y, dx, dy, button):
trackball.drag_to(x, y, dx, dy)
window.draw()
@window.event
def on_mouse_scroll(x, y, dx, dy):
trackball.zoom_to(x, y, dx, dy)
window.draw()
window.mainloop()
# Initialization
I = np.zeros((n, n), dtype=np.float32) # input
Z = np.zeros((n, n), dtype=np.float32) # output
Z_ = np.zeros((n, n), dtype=np.float32) # membrane potential
# Kernel
K = fromdistance(w, (2 * n + 1, 2 * n + 1))
USV = scipy.linalg.svd(K)
# Output decoding
X, Y = np.mgrid[0:n, 0:n]
X = 2 * X / float(n - 1) - 1
Y = 2 * Y / float(n - 1) - 1
window = glumpy.Window(2 * 512, 512)
Ii = glumpy.Image(I,
interpolation='bicubic',
cmap=glumpy.colormap.Grey_r,
vmin=0.0,
vmax=2.5)
Zi = glumpy.Image(Z,
interpolation='bicubic',
cmap=glumpy.colormap.Grey_r,
vmin=0.0,
vmax=0.25)
@window.event
def on_draw():
global Zi, Ii
window.clear()
