def gl_display_in_window(self):
active_window = glfwGetCurrentContext()
if glfwWindowShouldClose(self._window):
self.close_window()
return
glfwMakeContextCurrent(self._window)
clear_gl_screen()
hdpi_factor = glfwGetFramebufferSize(
self._window)[0] / glfwGetWindowSize(self._window)[0]
r = 110 * self.marker_scale * hdpi_factor
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
p_window_size = glfwGetFramebufferSize(self._window)
gl.glOrtho(0, p_window_size[0], p_window_size[1], 0, -1, 1)
# Switch back to Model View Matrix
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
def map_value(value, in_range=(0, 1), out_range=(0, 1)):
ratio = (out_range[1] - out_range[0]) / (in_range[1] - in_range[0])
return (value - in_range[0]) * ratio + out_range[0]
pad = .7 * r
screen_pos = map_value(
self.display_pos[0],
out_range=(pad, p_window_size[0] - pad)), map_value(
self.display_pos[1], out_range=(p_window_size[1] - pad, pad))
alpha = interp_fn(
self.screen_marker_state, 0., 1.,
float(self.sample_duration + self.lead_in + self.lead_out),
float(self.lead_in), float(self.sample_duration + self.lead_in))
draw_concentric_circles(screen_pos, r, 4, alpha)
#some feedback on the detection state
if self.detected and self.on_position:
draw_points([screen_pos],
size=10 * self.marker_scale,
color=RGBA(0., .8, 0., alpha),
sharpness=0.5)
else:
draw_points([screen_pos],
size=10 * self.marker_scale,
color=RGBA(0.8, 0., 0., alpha),
sharpness=0.5)
if self.clicks_to_close < 5:
self.glfont.set_size(int(p_window_size[0] / 30.))
self.glfont.draw_text(
p_window_size[0] / 2., p_window_size[1] / 4.,
'Touch {} more times to cancel {}.'.format(
self.clicks_to_close, self.mode_pretty))
glfwSwapBuffers(self._window)
glfwMakeContextCurrent(active_window)
def gl_display_in_window(self):
active_window = glfwGetCurrentContext()
glfwMakeContextCurrent(self._window)
clear_gl_screen()
hdpi_factor = glfwGetFramebufferSize(self._window)[0] / glfwGetWindowSize(self._window)[0]
r = 110 * self.marker_scale * hdpi_factor
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
p_window_size = glfwGetWindowSize(self._window)
gl.glOrtho(0, p_window_size[0], p_window_size[1], 0, -1, 1)
# Switch back to Model View Matrix
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
def map_value(value, in_range=(0, 1), out_range=(0, 1)):
ratio = (out_range[1] - out_range[0]) / (in_range[1] - in_range[0])
return (value - in_range[0]) * ratio + out_range[0]
pad = 0.6 * r
screen_pos = (
map_value(self.display_pos[0], out_range=(pad, p_window_size[0] - pad)),
map_value(self.display_pos[1], out_range=(p_window_size[1] - pad, pad)),
)
alpha = interp_fn(
self.screen_marker_state,
0.0,
1.0,
float(self.sample_duration + self.lead_in + self.lead_out),
float(self.lead_in),
float(self.sample_duration + self.lead_in),
)
draw_concentric_circles(screen_pos, r, 6, alpha)
# some feedback on the detection state
if self.detected and self.on_position:
draw_points([screen_pos], size=5, color=RGBA(0.0, 0.8, 0.0, alpha), sharpness=0.5)
else:
draw_points([screen_pos], size=5, color=RGBA(0.8, 0.0, 0.0, alpha), sharpness=0.5)
if self.clicks_to_close < 5:
self.glfont.set_size(int(p_window_size[0] / 30.0))
self.glfont.draw_text(
p_window_size[0] / 2.0,
p_window_size[1] / 4.0,
"Touch %s more times to cancel calibration." % self.clicks_to_close,
)
glfwSwapBuffers(self._window)
glfwMakeContextCurrent(active_window)
def gl_display_in_window(self):
active_window = glfwGetCurrentContext()
glfwMakeContextCurrent(self._window)
clear_gl_screen()
# Set Matrix unsing gluOrtho2D to include padding for the marker of radius r
#
############################
# r #
# 0,0##################w,h #
# # # #
# # # #
#r# #r#
# # # #
# # # #
# 0,h##################w,h #
# r #
############################
hdpi_factor = glfwGetFramebufferSize(self._window)[0]/glfwGetWindowSize(self._window)[0]
r = 110*self.marker_scale * hdpi_factor
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
p_window_size = glfwGetWindowSize(self._window)
# compensate for radius of marker
gl.glOrtho(-r*.6,p_window_size[0]+r*.6,p_window_size[1]+r*.7,-r*.7 ,-1,1)
# Switch back to Model View Matrix
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
screen_pos = denormalize(self.display_pos,p_window_size,flip_y=True)
alpha = interp_fn(self.screen_marker_state,0.,1.,float(self.sample_duration+self.lead_in+self.lead_out),float(self.lead_in),float(self.sample_duration+self.lead_in))
draw_concentric_circles(screen_pos,r,6,alpha)
#some feedback on the detection state
if self.detected and self.on_position:
draw_points([screen_pos],size=5,color=RGBA(0.,1.,0.,alpha),sharpness=0.95)
else:
draw_points([screen_pos],size=5,color=RGBA(1.,0.,0.,alpha),sharpness=0.95)
if self.clicks_to_close <5:
self.glfont.set_size(int(p_window_size[0]/30.))
self.glfont.draw_text(p_window_size[0]/2.,p_window_size[1]/4.,'Touch %s more times to cancel calibration.'%self.clicks_to_close)
glfwSwapBuffers(self._window)
glfwMakeContextCurrent(active_window)
def gl_display_in_window(self):
active_window = glfwGetCurrentContext()
if glfwWindowShouldClose(self._window):
self.close_window()
return
glfwMakeContextCurrent(self._window)
clear_gl_screen()
gl.glColor3f(.80, .80, .8)
self.draw_rect(0, 0, 2000, 2000)
self.draw_markers()
hdpi_factor = glfwGetFramebufferSize(self._window)[0]/glfwGetWindowSize(self._window)[0]
r = 110*self.marker_scale * hdpi_factor
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
p_window_size = glfwGetFramebufferSize(self._window)
gl.glOrtho(0, p_window_size[0], p_window_size[1], 0, -1, 1)
# Switch back to Model View Matrix
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
def map_value(value,in_range=(0,1),out_range=(0,1)):
ratio = (out_range[1]-out_range[0])/(in_range[1]-in_range[0])
return (value-in_range[0])*ratio+out_range[0]
#pad = 0.1*1920
pad = .7*r
screen_pos = map_value(self.display_pos[0],out_range=(pad,p_window_size[0]-pad)),map_value(self.display_pos[1],out_range=(p_window_size[1]-pad,pad))
alpha = interp_fn(self.screen_marker_state,0.,1.,float(self.sample_duration+self.lead_in+self.lead_out),float(self.lead_in),float(self.sample_duration+self.lead_in))
if self.screen_marker_state < self.sample_duration+self.lead_in+self.lead_out:
draw_concentric_circles(screen_pos,r,6,alpha)
#some feedback on the detection state
if self.detected and self.on_position:
draw_points([screen_pos],size=10*self.marker_scale,color=RGBA(0.,.8,0.,alpha),sharpness=0.5)
elif self.screen_marker_state < self.sample_duration+self.lead_in+self.lead_out:
draw_points([screen_pos],size=10*self.marker_scale,color=RGBA(0.8,0.,0.,alpha),sharpness=0.5)
#if self.clicks_to_close <5:
# self.glfont.set_size(int(p_window_size[0]/30.))
# self.glfont.draw_text(p_window_size[0]/2.,p_window_size[1]/4.,'Touch {} more times to cancel calibration.'.format(self.clicks_to_close))
glfwSwapBuffers(self._window)
glfwMakeContextCurrent(active_window)
def demo():
global quit
quit = False
# Callback functions
def on_resize(window,w, h):
h = max(h,1)
w = max(w,1)
hdpi_factor = glfwGetFramebufferSize(window)[0]/glfwGetWindowSize(window)[0]
w,h = w*hdpi_factor,h*hdpi_factor
gui.update_window(w,h)
active_window = glfwGetCurrentContext()
glfwMakeContextCurrent(window)
# norm_size = normalize((w,h),glfwGetWindowSize(window))
# fb_size = denormalize(norm_size,glfwGetFramebufferSize(window))
adjust_gl_view(w,h,window)
glfwMakeContextCurrent(active_window)
def on_iconify(window,iconfied):
pass
def on_key(window, key, scancode, action, mods):
gui.update_key(key,scancode,action,mods)
if action == GLFW_PRESS:
if key == GLFW_KEY_ESCAPE:
on_close(window)
if mods == GLFW_MOD_SUPER:
if key == 67:
# copy value to system clipboard
# ideally copy what is in our text input area
test_val = "copied text input"
glfwSetClipboardString(window,test_val)
print("set clipboard to: %s" %(test_val))
if key == 86:
# copy from system clipboard
clipboard = glfwGetClipboardString(window)
print("pasting from clipboard: %s" %(clipboard))
def on_char(window,char):
gui.update_char(char)
def on_button(window,button, action, mods):
gui.update_button(button,action,mods)
# pos = normalize(pos,glfwGetWindowSize(window))
# pos = denormalize(pos,(frame.img.shape[1],frame.img.shape[0]) ) # Position in img pixels
def on_pos(window,x, y):
hdpi_factor = float(glfwGetFramebufferSize(window)[0]/glfwGetWindowSize(window)[0])
x,y = x*hdpi_factor,y*hdpi_factor
gui.update_mouse(x,y)
def on_scroll(window,x,y):
gui.update_scroll(x,y)
def on_close(window):
global quit
quit = True
logger.info('Process closing from window')
# get glfw started
glfwInit()
window = glfwCreateWindow(width, height, "pyglui demo", None, None)
if not window:
exit()
glfwSetWindowPos(window,0,0)
# Register callbacks for the window
glfwSetWindowSizeCallback(window,on_resize)
glfwSetWindowCloseCallback(window,on_close)
glfwSetWindowIconifyCallback(window,on_iconify)
glfwSetKeyCallback(window,on_key)
glfwSetCharCallback(window,on_char)
glfwSetMouseButtonCallback(window,on_button)
glfwSetCursorPosCallback(window,on_pos)
glfwSetScrollCallback(window,on_scroll)
# test out new paste function
glfwMakeContextCurrent(window)
init()
basic_gl_setup()
print(glGetString(GL_VERSION))
class Temp(object):
"""Temp class to make objects"""
def __init__(self):
pass
foo = Temp()
foo.bar = 34
foo.sel = 'mi'
foo.selection = ['€','mi', u"re"]
foo.mytext = "some text"
def set_text_val(val):
foo.mytext = val
# print 'setting to :',val
print("pyglui version: %s" %(ui.__version__))
gui = ui.UI()
gui.scale = 1.0
sidebar = ui.Scrolling_Menu("MySideBar",pos=(-300,0),size=(0,0),header_pos='left')
sm = ui.Growing_Menu("SubMenu",pos=(0,0),size=(0,100))
sm.append(ui.Slider("bar",foo))
sm.append(ui.Text_Input('mytext',foo,setter=set_text_val))
sm.append(ui.Selector('sel',foo,selection=foo.selection))
sidebar.append(sm)
gui.append(sidebar)
menu = ui.Scrolling_Menu('My Window 1', pos=(200,100), size=(50, 200),header_pos='top')
menu.append(ui.Slider("bar",foo))
gui.append(menu)
menu = ui.Scrolling_Menu('My Window 2', pos=(200,100), size=(50, 200),header_pos='top')
menu.append(ui.Text_Input('mytext',foo,setter=set_text_val))
gui.append(menu)
label = 'Ï'
# label = 'R'
gui.append(ui.Thumb('mytext',foo,label=label,hotkey='r',label_font='fontawesome',label_offset_x=5,label_offset_y=0,label_offset_size=-20))
import os
import psutil
pid = os.getpid()
ps = psutil.Process(pid)
ts = time.time()
from pyglui import graph
print(graph.__version__)
cpu_g = graph.Line_Graph()
cpu_g.pos = (50,100)
cpu_g.update_fn = ps.cpu_percent
cpu_g.update_rate = 5
cpu_g.label = 'CPU %0.1f'
fps_g = graph.Line_Graph()
fps_g.pos = (50,100)
fps_g.update_rate = 5
fps_g.label = "%0.0f FPS"
fps_g.color[:] = .1,.1,.8,.9
on_resize(window,*glfwGetWindowSize(window))
while not quit:
dt,ts = time.time()-ts,time.time()
clear_gl_screen()
draw_concentric_circles( (500,250), 200, 6 , 1.0 )
draw_concentric_circles( (600,250), 200, 7 , 1.0 )
draw_concentric_circles( (700,250), 200, 8 , 0.1 )
cpu_g.update()
cpu_g.draw()
fps_g.add(1./dt)
fps_g.draw()
gui.update()
glfwSwapBuffers(window)
glfwPollEvents()
gui.terminate()
glfwTerminate()
logger.debug("Process done")
