Demo code for the pupil labs workshop at ETRA 2018

README.md

Pupil Labs Workshop Demo Code

Dependencies

These instructions assume that the dependencies for running Pupil applications from source are already installed. You will have to install the pyglui etra branch in order to run the visualization:

git clone https://github.com/pupil-labs/pyglui/ --branch etra
cd pylgui
pip3 install . -U

Download Demo Code

Use the Download ZIP option in the top right to download the demo code. Extract the files after downloading.

Setup Pupil Capture

1. Start Pupil Capture
2. Make sure that the Pupil Remote is loaded -- this is the case by default
3. Load the Surface Tracker plugin
4. Setup surfaces as you like
5. Put on the headset and calibrate

Running the demo

1. Open a terminal
2. Change the current working directory to the folder that contains the extracted files
3. Run the demo code:

python3 demo.py

demo.py

import zmq

context = zmq.Context()
req = context.socket(zmq.REQ)
req.connect("tcp://127.0.0.1:50020")

req.send_string('SUB_PORT')
sub_port = req.recv_string()

sub = context.socket(zmq.SUB)
sub.connect("tcp://127.0.0.1:{}".format(sub_port))
sub.setsockopt_string(zmq.SUBSCRIBE, 'pupil.0')
sub.setsockopt_string(zmq.SUBSCRIBE, 'surface')
sub.setsockopt_string(zmq.SUBSCRIBE, 'face')

import msgpack
def recv_msg():
    topic = sub.recv_string()
    payload = sub.recv()  # msgpack-encoded bytes
    msg = msgpack.unpackb(payload, encoding='utf-8')
    return topic, msg

def extract_gaze(message):
    gaze_on_srf = message['gaze_on_srf']
    high_conf_gaze = [gp for gp in gaze_on_srf
                      if gp['confidence'] > 0.8
                      and gp['on_srf']]
    return high_conf_gaze

from plot_utils import Graph

visualizer = Graph(sum_values=True)
while True:
    topic, message = recv_msg()

    if topic.startswith('surface'):
        gaze = extract_gaze(message)
        visualizer.append_data(message['name'], len(gaze))

    visualizer.draw()

glfw.py

# -----------------------------------------------------------------------------
#  GLFW - An OpenGL framework
#  API version: 3.0.1
#  WWW:         http://www.glfw.org/
#  ----------------------------------------------------------------------------
#  Copyright (c) 2002-2006 Marcus Geelnard
#  Copyright (c) 2006-2010 Camilla Berglund
#
#  Python bindings - Copyright (c) 2013 Nicolas P. Rougier
#
#  This software is provided 'as-is', without any express or implied
#  warranty. In no event will the authors be held liable for any damages
#  arising from the use of this software.
#
#  Permission is granted to anyone to use this software for any purpose,
#  including commercial applications, and to alter it and redistribute it
#  freely, subject to the following restrictions:
#
#  1. The origin of this software must not be misrepresented; you must not
#     claim that you wrote the original software. If you use this software
#     in a product, an acknowledgment in the product documentation would
#     be appreciated but is not required.
#
#  2. Altered source versions must be plainly marked as such, and must not
#     be misrepresented as being the original software.
#
#  3. This notice may not be removed or altered from any source
#     distribution.
#
# ----------------
# changes by moritz kassner:
# small bugfixes, changed binary loading routine.
# Upgrade to 3.1.x api.
# -----------------------------------------------------------------------------

import sys,os
import ctypes
from ctypes import c_int,c_ushort,c_char_p,c_double,c_uint, c_char,c_float,Structure,CFUNCTYPE,byref,POINTER
import platform
from ctypes.util import find_library

import logging
logger = logging.getLogger(__name__)

os_name = platform.system()
del platform


if getattr(sys, 'frozen', False):
    # we are running in a |PyInstaller| bundle using a local version
    # you will need to add glfw.so/dylib in your spec file.
    if os_name == "Linux":
        filename = 'libglfw.so'
    elif os_name == "Darwin":
        filename = 'libglfw.dylib'
    elif os_name == "Windows":
        filename = 'glfw3.dll'
    else:
        filename = 'libglfw.dll'
    dll_path = os.path.join(sys._MEIPASS,filename)

else:
    # we are running in a normal Python environment
    if os_name == "Linux":
        dll_path = find_library('glfw')
    elif os_name == "Darwin":
        dll_path = find_library('glfw')
        if not dll_path:
            dll_path = find_library('glfw3')
            if dll_path:
                # deprecation warning, TODO: remove with next release
                logger.warning("Deprecation warning: Please update your homebrew glfw installation by running `brew migrate glfw`")
    elif os_name == "Windows":
        dll_path = find_library('glfw3') #os.path.join(os.path.dirname(os.path.abspath(os.path.curdir)), 'shared_modules', 'external', 'glfw3')
    else:
        dll_path = find_library('glfw')
    if not dll_path:
        raise RuntimeError('GLFW library not found')

_glfw = ctypes.CDLL(dll_path)

# --- Version -----------------------------------------------------------------
GLFW_VERSION_MAJOR      = 3
GLFW_VERSION_MINOR      = 1
GLFW_VERSION_REVISION   = 1
__version__ = GLFW_VERSION_MAJOR, GLFW_VERSION_MINOR, GLFW_VERSION_REVISION

# --- Input handling definitions ----------------------------------------------
GLFW_RELEASE            = 0
GLFW_PRESS              = 1
GLFW_REPEAT             = 2

# --- Keys --------------------------------------------------------------------

# --- The unknown key ---------------------------------------------------------
GLFW_KEY_UNKNOWN          = -1

# --- Printable keys ----------------------------------------------------------
GLFW_KEY_SPACE            = 32
GLFW_KEY_APOSTROPHE       = 39 # ''
GLFW_KEY_COMMA            = 44 # ,
GLFW_KEY_MINUS            = 45 # -
GLFW_KEY_PERIOD           = 46 # .
GLFW_KEY_SLASH            = 47 # /
GLFW_KEY_0                = 48
GLFW_KEY_1                = 49
GLFW_KEY_2                = 50
GLFW_KEY_3                = 51
GLFW_KEY_4                = 52
GLFW_KEY_5                = 53
GLFW_KEY_6                = 54
GLFW_KEY_7                = 55
GLFW_KEY_8                = 56
GLFW_KEY_9                = 57
GLFW_KEY_SEMICOLON        = 59 # ;
GLFW_KEY_EQUAL            = 61 # =
GLFW_KEY_A                = 65
GLFW_KEY_B                = 66
GLFW_KEY_C                = 67
GLFW_KEY_D                = 68
GLFW_KEY_E                = 69
GLFW_KEY_F                = 70
GLFW_KEY_G                = 71
GLFW_KEY_H                = 72
GLFW_KEY_I                = 73
GLFW_KEY_J                = 74
GLFW_KEY_K                = 75
GLFW_KEY_L                = 76
GLFW_KEY_M                = 77
GLFW_KEY_N                = 78
GLFW_KEY_O                = 79
GLFW_KEY_P                = 80
GLFW_KEY_Q                = 81
GLFW_KEY_R                = 82
GLFW_KEY_S                = 83
GLFW_KEY_T                = 84
GLFW_KEY_U                = 85
GLFW_KEY_V                = 86
GLFW_KEY_W                = 87
GLFW_KEY_X                = 88
GLFW_KEY_Y                = 89
GLFW_KEY_Z                = 90
GLFW_KEY_LEFT_BRACKET     = 91  # [
GLFW_KEY_BACKSLASH        = 92  # \
GLFW_KEY_RIGHT_BRACKET    = 93  # ]
GLFW_KEY_GRAVE_ACCENT     = 96  # `
GLFW_KEY_WORLD_1          = 161 # non-US #1
GLFW_KEY_WORLD_2          = 162 # non-US #2

# --- Function keys -----------------------------------------------------------
GLFW_KEY_ESCAPE           = 256
GLFW_KEY_ENTER            = 257
GLFW_KEY_TAB              = 258
GLFW_KEY_BACKSPACE        = 259
GLFW_KEY_INSERT           = 260
GLFW_KEY_DELETE           = 261
GLFW_KEY_RIGHT            = 262
GLFW_KEY_LEFT             = 263
GLFW_KEY_DOWN             = 264
GLFW_KEY_UP               = 265
GLFW_KEY_PAGE_UP          = 266
GLFW_KEY_PAGE_DOWN        = 267
GLFW_KEY_HOME             = 268
GLFW_KEY_END              = 269
GLFW_KEY_CAPS_LOCK        = 280
GLFW_KEY_SCROLL_LOCK      = 281
GLFW_KEY_NUM_LOCK         = 282
GLFW_KEY_PRINT_SCREEN     = 283
GLFW_KEY_PAUSE            = 284
GLFW_KEY_F1               = 290
GLFW_KEY_F2               = 291
GLFW_KEY_F3               = 292
GLFW_KEY_F4               = 293
GLFW_KEY_F5               = 294
GLFW_KEY_F6               = 295
GLFW_KEY_F7               = 296
GLFW_KEY_F8               = 297
GLFW_KEY_F9               = 298
GLFW_KEY_F10              = 299
GLFW_KEY_F11              = 300
GLFW_KEY_F12              = 301
GLFW_KEY_F13              = 302
GLFW_KEY_F14              = 303
GLFW_KEY_F15              = 304
GLFW_KEY_F16              = 305
GLFW_KEY_F17              = 306
GLFW_KEY_F18              = 307
GLFW_KEY_F19              = 308
GLFW_KEY_F20              = 309
GLFW_KEY_F21              = 310
GLFW_KEY_F22              = 311
GLFW_KEY_F23              = 312
GLFW_KEY_F24              = 313
GLFW_KEY_F25              = 314
GLFW_KEY_KP_0             = 320
GLFW_KEY_KP_1             = 321
GLFW_KEY_KP_2             = 322
GLFW_KEY_KP_3             = 323
GLFW_KEY_KP_4             = 324
GLFW_KEY_KP_5             = 325
GLFW_KEY_KP_6             = 326
GLFW_KEY_KP_7             = 327
GLFW_KEY_KP_8             = 328
GLFW_KEY_KP_9             = 329
GLFW_KEY_KP_DECIMAL       = 330
GLFW_KEY_KP_DIVIDE        = 331
GLFW_KEY_KP_MULTIPLY      = 332
GLFW_KEY_KP_SUBTRACT      = 333
GLFW_KEY_KP_ADD           = 334
GLFW_KEY_KP_ENTER         = 335
GLFW_KEY_KP_EQUAL         = 336
GLFW_KEY_LEFT_SHIFT       = 340
GLFW_KEY_LEFT_CONTROL     = 341
GLFW_KEY_LEFT_ALT         = 342
GLFW_KEY_LEFT_SUPER       = 343
GLFW_KEY_RIGHT_SHIFT      = 344
GLFW_KEY_RIGHT_CONTROL    = 345
GLFW_KEY_RIGHT_ALT        = 346
GLFW_KEY_RIGHT_SUPER      = 347
GLFW_KEY_MENU             = 348
GLFW_KEY_LAST             = GLFW_KEY_MENU


# --- Modifiers ---------------------------------------------------------------
GLFW_MOD_SHIFT            = 0x0001
GLFW_MOD_CONTROL          = 0x0002
GLFW_MOD_ALT              = 0x0004
GLFW_MOD_SUPER            = 0x0008

# --- Mouse -------------------------------------------------------------------
GLFW_MOUSE_BUTTON_1       = 0
GLFW_MOUSE_BUTTON_2       = 1
GLFW_MOUSE_BUTTON_3       = 2
GLFW_MOUSE_BUTTON_4       = 3
GLFW_MOUSE_BUTTON_5       = 4
GLFW_MOUSE_BUTTON_6       = 5
GLFW_MOUSE_BUTTON_7       = 6
GLFW_MOUSE_BUTTON_8       = 7
GLFW_MOUSE_BUTTON_LAST    = GLFW_MOUSE_BUTTON_8
GLFW_MOUSE_BUTTON_LEFT    = GLFW_MOUSE_BUTTON_1
GLFW_MOUSE_BUTTON_RIGHT   = GLFW_MOUSE_BUTTON_2
GLFW_MOUSE_BUTTON_MIDDLE  = GLFW_MOUSE_BUTTON_3


# --- Joystick ----------------------------------------------------------------
GLFW_JOYSTICK_1           = 0
GLFW_JOYSTICK_2           = 1
GLFW_JOYSTICK_3           = 2
GLFW_JOYSTICK_4           = 3
GLFW_JOYSTICK_5           = 4
GLFW_JOYSTICK_6           = 5
GLFW_JOYSTICK_7           = 6
GLFW_JOYSTICK_8           = 7
GLFW_JOYSTICK_9           = 8
GLFW_JOYSTICK_10          = 9
GLFW_JOYSTICK_11          = 10
GLFW_JOYSTICK_12          = 11
GLFW_JOYSTICK_13          = 12
GLFW_JOYSTICK_14          = 13
GLFW_JOYSTICK_15          = 14
GLFW_JOYSTICK_16          = 15
GLFW_JOYSTICK_LAST        = GLFW_JOYSTICK_16


# --- Error codes -------------------------------------------------------------
GLFW_NOT_INITIALIZED        = 0x00010001
GLFW_NO_CURRENT_CONTEXT     = 0x00010002
GLFW_INVALID_ENUM           = 0x00010003
GLFW_INVALID_VALUE          = 0x00010004
GLFW_OUT_OF_MEMORY          = 0x00010005
GLFW_API_UNAVAILABLE        = 0x00010006
GLFW_VERSION_UNAVAILABLE    = 0x00010007
GLFW_PLATFORM_ERROR         = 0x00010008
GLFW_FORMAT_UNAVAILABLE     = 0x00010009

# ---
GLFW_FOCUSED                = 0x00020001
GLFW_ICONIFIED              = 0x00020002
GLFW_RESIZABLE              = 0x00020003
GLFW_VISIBLE                = 0x00020004
GLFW_DECORATED              = 0x00020005

# ---
GLFW_RED_BITS               = 0x00021001
GLFW_GREEN_BITS             = 0x00021002
GLFW_BLUE_BITS              = 0x00021003
GLFW_ALPHA_BITS             = 0x00021004
GLFW_DEPTH_BITS             = 0x00021005
GLFW_STENCIL_BITS           = 0x00021006
GLFW_ACCUM_RED_BITS         = 0x00021007
GLFW_ACCUM_GREEN_BITS       = 0x00021008
GLFW_ACCUM_BLUE_BITS        = 0x00021009
GLFW_ACCUM_ALPHA_BITS       = 0x0002100A
GLFW_AUX_BUFFERS            = 0x0002100B
GLFW_STEREO                 = 0x0002100C
GLFW_SAMPLES                = 0x0002100D
GLFW_SRGB_CAPABLE           = 0x0002100E
GLFW_REFRESH_RATE           = 0x0002100F

# ---
GLFW_CLIENT_API             = 0x00022001
GLFW_CONTEXT_VERSION_MAJOR  = 0x00022002
GLFW_CONTEXT_VERSION_MINOR  = 0x00022003
GLFW_CONTEXT_REVISION       = 0x00022004
GLFW_CONTEXT_ROBUSTNESS     = 0x00022005
GLFW_OPENGL_FORWARD_COMPAT  = 0x00022006
GLFW_OPENGL_DEBUG_CONTEXT   = 0x00022007
GLFW_OPENGL_PROFILE         = 0x00022008

# ---
GLFW_OPENGL_API             = 0x00030001
GLFW_OPENGL_ES_API          = 0x00030002

# ---
GLFW_NO_ROBUSTNESS          =          0
GLFW_NO_RESET_NOTIFICATION  = 0x00031001
GLFW_LOSE_CONTEXT_ON_RESET  = 0x00031002

# ---
GLFW_OPENGL_ANY_PROFILE     =          0
GLFW_OPENGL_CORE_PROFILE    = 0x00032001
GLFW_OPENGL_COMPAT_PROFILE  = 0x00032002

# ---
GLFW_CURSOR                 = 0x00033001
GLFW_STICKY_KEYS            = 0x00033002
GLFW_STICKY_MOUSE_BUTTONS   = 0x00033003

# ---
GLFW_CURSOR_NORMAL          = 0x00034001
GLFW_CURSOR_HIDDEN          = 0x00034002
GLFW_CURSOR_DISABLED        = 0x00034003

# ---
GLFW_CONNECTED              = 0x00040001
GLFW_DISCONNECTED           = 0x00040002


# --- Structures --------------------------------------------------------------
class GLFWvidmode(Structure):
    _fields_ = [ ('width',       c_int),
                 ('height',      c_int),
                 ('redBits',     c_int),
                 ('greenBits',   c_int),
                 ('blueBits',    c_int),
                 ('refreshRate', c_int) ]

class GLFWgammaramp(Structure):
    _fields_ = [ ('red',     POINTER(c_ushort)),
                 ('green',   POINTER(c_ushort)),
                 ('blue',    POINTER(c_ushort)),
                 ('size',    c_int) ]

class GLFWwindow(Structure): pass
class GLFWmonitor(Structure): pass

# --- Callbacks ---------------------------------------------------------------
errorfun           = CFUNCTYPE(None, c_int, c_char_p)
windowposfun       = CFUNCTYPE(None, POINTER(GLFWwindow), c_int, c_int)
windowsizefun      = CFUNCTYPE(None, POINTER(GLFWwindow), c_int, c_int)
windowclosefun     = CFUNCTYPE(None, POINTER(GLFWwindow))
windowrefreshfun   = CFUNCTYPE(None, POINTER(GLFWwindow))
windowfocusfun     = CFUNCTYPE(None, POINTER(GLFWwindow), c_int)
windowiconifyfun   = CFUNCTYPE(None, POINTER(GLFWwindow), c_int)
framebuffersizefun = CFUNCTYPE(None, POINTER(GLFWwindow), c_int, c_int)
mousebuttonfun     = CFUNCTYPE(None, POINTER(GLFWwindow), c_int, c_int, c_int)
cursorposfun       = CFUNCTYPE(None, POINTER(GLFWwindow), c_double, c_double)
cursorenterfun     = CFUNCTYPE(None, POINTER(GLFWwindow), c_int)
scrollfun          = CFUNCTYPE(None, POINTER(GLFWwindow), c_double, c_double)
keyfun             = CFUNCTYPE(None, POINTER(GLFWwindow), c_int, c_int, c_int, c_int)
charfun            = CFUNCTYPE(None, POINTER(GLFWwindow), c_uint)
monitorfun         = CFUNCTYPE(None, POINTER(GLFWmonitor), c_int)
dropfun            = CFUNCTYPE(None, POINTER(GLFWmonitor), c_int, POINTER(c_char_p))

# --- Init --------------------------------------------------------------------
# glfwInit                        = _glfw.glfwInit
glfwTerminate                   = _glfw.glfwTerminate
#glfwGetVersion                 = _glfw.glfwGetVersion
glfwGetVersionString            = _glfw.glfwGetVersionString
glfwGetVersionString.restype    = c_char_p


# --- Error -------------------------------------------------------------------
#glfwSetErrorCallback            = _glfw.glfwSetErrorCallback

# --- Monitor -----------------------------------------------------------------
# glfwGetMonitors                 = _glfw.glfwGetMonitors
# glfwGetMonitors.restype         = POINTER(GLFWmonitor)
glfwGetPrimaryMonitor           = _glfw.glfwGetPrimaryMonitor
glfwGetPrimaryMonitor.restype = POINTER(GLFWmonitor)
# glfwGetMonitorPos               = _glfw.glfwGetMonitorPos
# glfwGetMonitorPhysicalSize      = _glfw.glfwGetMonitorPhysicalSize
glfwGetMonitorName              = _glfw.glfwGetMonitorName
glfwGetMonitorName.restype = c_char_p
# glfwSetMonitorCallback          = _glfw.glfwSetMonitorCallback
# glfwGetVideoModes               = _glfw.glfwGetVideoModes
# glfwGetVideoMode                = _glfw.glfwGetVideoMode

# --- Gama --------------------------------------------------------------------
glfwSetGamma                   = _glfw.glfwSetGamma
# glfwGetGammaRamp               = _glfw.glfwGetGammaRamp
# glfwSetGammaRamp               = _glfw.glfwSetGammaRamp

# --- Window ------------------------------------------------------------------
glfwDefaultWindowHints         = _glfw.glfwDefaultWindowHints
glfwWindowHint                 = _glfw.glfwWindowHint
# glfwCreateWindow              = _glfw.glfwCreateWindow
# glfwDestroyWindow              = _glfw.glfwDestroyWindow
glfwWindowShouldClose          = _glfw.glfwWindowShouldClose
glfwSetWindowShouldClose       = _glfw.glfwSetWindowShouldClose
glfwSetWindowTitle             = _glfw.glfwSetWindowTitle
# glfwGetWindowPos              = _glfw.glfwGetWindowPos
glfwSetWindowPos               = _glfw.glfwSetWindowPos
# glfwGetWindowSize             = _glfw.glfwGetWindowSize
glfwSetWindowSize              = _glfw.glfwSetWindowSize
# glfwGetFramebufferSize        = _glfw.glfwGetFramebufferSize
glfwIconifyWindow              = _glfw.glfwIconifyWindow
glfwRestoreWindow              = _glfw.glfwRestoreWindow
glfwShowWindow                 = _glfw.glfwShowWindow
glfwHideWindow                 = _glfw.glfwHideWindow
glfwGetWindowMonitor           = _glfw.glfwGetWindowMonitor
glfwGetWindowAttrib            = _glfw.glfwGetWindowAttrib
glfwSetWindowUserPointer       = _glfw.glfwSetWindowUserPointer
glfwGetWindowUserPointer       = _glfw.glfwGetWindowUserPointer
# glfwSetWindowPosCallback       = _glfw.glfwSetWindowPosCallback
# glfwSetWindowSizeCallback      = _glfw.glfwSetWindowSizeCallback
# glfwSetWindowCloseCallback     = _glfw.glfwSetWindowCloseCallback
# glfwSetWindowRefreshCallback   = _glfw.glfwSetWindowRefreshCallback
# glfwSetWindowFocusCallback     = _glfw.glfwSetWindowFocusCallback
# glfwSetWindowIconifyCallback   = _glfw.glfwSetWindowIconifyCallback
# glfwSetFramebufferSizeCallback = _glfw.glfwSetFramebufferSizeCallback
glfwPollEvents                 = _glfw.glfwPollEvents
glfwWaitEvents                 = _glfw.glfwWaitEvents

# --- Input -------------------------------------------------------------------
glfwGetInputMode               = _glfw.glfwGetInputMode
glfwSetInputMode               = _glfw.glfwSetInputMode
glfwGetKey                     = _glfw.glfwGetKey
glfwGetMouseButton             = _glfw.glfwGetMouseButton
# glfwGetCursorPos               = _glfw.glfwGetCursorPos
glfwSetCursorPos               = _glfw.glfwSetCursorPos
# glfwSetKeyCallback             = _glfw.glfwSetKeyCallback
# glfwSetCharCallback            = _glfw.glfwSetCharCallback
# glfwSetMouseButtonCallback     = _glfw.glfwSetMouseButtonCallback
# glfwSetCursorPosCallback       = _glfw.glfwSetCursorPosCallback
# glfwSetCursorEnterCallback     = _glfw.glfwSetCursorEnterCallback
# glfwSetScrollCallback          = _glfw.glfwSetScrollCallback
glfwJoystickPresent            = _glfw.glfwJoystickPresent
# glfwGetJoystickAxes            = _glfw.glfwGetJoystickAxes
# glfwGetJoystickButtons         = _glfw.glfwGetJoystickButtons
glfwGetJoystickName            = _glfw.glfwGetJoystickName
glfwGetJoystickName.restype = c_char_p

# --- Clipboard ---------------------------------------------------------------
glfwSetClipboardString         = _glfw.glfwSetClipboardString
glfwGetClipboardString         = _glfw.glfwGetClipboardString
glfwGetClipboardString.restype = c_char_p

# --- Timer -------------------------------------------------------------------
glfwGetTime                    = _glfw.glfwGetTime
glfwGetTime.restype = c_double
glfwSetTime                    = _glfw.glfwSetTime

# --- Context -----------------------------------------------------------------
glfwMakeContextCurrent         = _glfw.glfwMakeContextCurrent
# glfwGetCurrentContext          = _glfw.glfwGetCurrentContext
glfwSwapBuffers                = _glfw.glfwSwapBuffers
glfwSwapInterval               = _glfw.glfwSwapInterval
glfwExtensionSupported         = _glfw.glfwExtensionSupported
glfwGetProcAddress             = _glfw.glfwGetProcAddress



# --- Pythonizer --------------------------------------------------------------

# This keeps track of current windows
__windows__ = []

# This is to prevent garbage collection on callbacks
__c_callbacks__ = {}
__py_callbacks__ = {}


def glfwInit():
    import os
    # glfw changes the directory,so we change it back.
    cwd = os.getcwd()
    # Initialize
    res = _glfw.glfwInit()
    # Restore the old cwd.
    os.chdir(cwd)
    del os
    if res < 0:
        raise Exception("GLFW could not be initialized")


def glfwCreateWindow(width=640, height=480, title="GLFW Window", monitor=None, share=None):
    _glfw.glfwCreateWindow.restype = POINTER(GLFWwindow)
    window = _glfw.glfwCreateWindow(width,height,title.encode('utf-8'),monitor,share)
    if window:
        __windows__.append(window)
        index = __windows__.index(window)
        __c_callbacks__[index] = {}
        __py_callbacks__[index] = { 'errorfun'           : None,
                                    'monitorfun'         : None,
                                    'windowposfun'       : None,
                                    'windowsizefun'      : None,
                                    'windowclosefun'     : None,
                                    'windowrefreshfun'   : None,
                                    'windowfocusfun'     : None,
                                    'windowiconifyfun'   : None,
                                    'framebuffersizefun' : None,
                                    'keyfun'             : None,
                                    'charfun'            : None,
                                    'mousebuttonfun'     : None,
                                    'cursorposfun'       : None,
                                    'cursorenterfun'     : None,
                                    'scrollfun'          : None,
                                    'dropfun'            : None,}
        return window
    else:
        raise Exception("GLFW window failed to create.")
def glfwDestroyWindow(window):
    index = __windows__.index(window)
    try:
        __c_callbacks__[index]
    except KeyError:
        logger.error('Window already destroyed.')
    else:
        _glfw.glfwDestroyWindow(window)
        # We do not delete window from the list (or it would impact windows numbering)
        # del __windows__[index]
        del __c_callbacks__[index]
        del __py_callbacks__[index]

def glfwGetVersion():
    major, minor, rev = c_int(0), c_int(0), c_int(0)
    _glfw.glfwGetVersion( byref(major), byref(minor), byref(rev) )
    return major.value, minor.value, rev.value

def glfwGetWindowPos(window):
    xpos, ypos = c_int(0), c_int(0)
    _glfw.glfwGetWindowPos(window, byref(xpos), byref(ypos))
    return xpos.value, ypos.value

def glfwGetCursorPos(window):
    xpos, ypos = c_double(0), c_double(0)
    _glfw.glfwGetCursorPos(window, byref(xpos), byref(ypos))
    return xpos.value, ypos.value

def glfwGetWindowSize(window):
    width, height = c_int(0), c_int(0)
    _glfw.glfwGetWindowSize(window, byref(width), byref(height))
    return width.value, height.value

def glfwGetCurrentContext():
    _glfw.glfwGetCurrentContext.restype = POINTER(GLFWwindow)
    return _glfw.glfwGetCurrentContext()


def glfwGetFramebufferSize(window):
    width, height = c_int(0), c_int(0)
    _glfw.glfwGetFramebufferSize(window, byref(width), byref(height))
    return width.value, height.value


def glfwGetMonitors():
    count = c_int(0)
    _glfw.glfwGetMonitors.restype = POINTER(POINTER(GLFWmonitor))
    c_monitors = _glfw.glfwGetMonitors( byref(count) )
    return [c_monitors[i] for i in range(count.value)]

def glfwGetVideoModes(monitor):
    count = c_int(0)
    _glfw.glfwGetVideoModes.restype = POINTER(GLFWvidmode)
    c_modes = _glfw.glfwGetVideoModes( monitor, byref(count) )
    modes = []
    for i in range(count.value):
        modes.append( (c_modes[i].width,
                       c_modes[i].height,
                       c_modes[i].redBits,
                       c_modes[i].blueBits,
                       c_modes[i].greenBits,
                       c_modes[i].refreshRate ) )
    return modes

def glfwGetMonitorPos(monitor):
    xpos, ypos = c_int(0), c_int(0)
    _glfw.glfwGetMonitorPos(monitor, byref(xpos), byref(ypos))
    return xpos.value, ypos.value

def glfwGetMonitorPhysicalSize(monitor):
    width, height = c_int(0), c_int(0)
    _glfw.glfwGetMonitorPhysicalSize(monitor, byref(width), byref(height))
    return width.value, height.value

def glfwGetVideoMode(monitor):
    _glfw.glfwGetVideoMode.restype = POINTER(GLFWvidmode)
    c_mode = _glfw.glfwGetVideoMode(monitor)
    return (c_mode.contents.width,
            c_mode.contents.height,
            c_mode.contents.redBits,
            c_mode.contents.blueBits,
            c_mode.contents.greenBits,
            c_mode.contents.refreshRate )

def GetGammaRamp(monitor):
    _glfw.glfwGetGammaRamp.restype = POINTER(GLFWgammaramp)
    c_gamma = _glfw.glfwGetGammaRamp(monitor).contents
    gamma = {'red':[], 'green':[], 'blue':[]}
    if c_gamma:
        for i in range(c_gamma.size):
            gamma['red'].append(c_gamma.red[i])
            gamma['green'].append(c_gamma.green[i])
            gamma['blue'].append(c_gamma.blue[i])
    return gamma

def glfwGetJoystickAxes(joy):
    count = c_int(0)
    _glfw.glfwGetJoystickAxes.restype = POINTER(c_float)
    c_axes = _glfw.glfwGetJoystickAxes(joy, byref(count))
    axes = [c_axes[i].value for i in range(count)]

def glfwGetJoystickButtons(joy):
    count = c_int(0)
    _glfw.glfwGetJoystickButtons.restype = POINTER(c_int)
    c_buttons = _glfw.glfwGetJoystickButtons(joy, byref(count))
    buttons = [c_buttons[i].value for i in range(count)]


# --- Callbacks ---------------------------------------------------------------

def __callback__(name):
    callback = 'glfwSet{}Callback'.format(name)
    fun      = '{}fun'.format(name.lower())
    code = """
def {callback}(window, callback = None):
    index = __windows__.index(window)
    old_callback = __py_callbacks__[index]['{fun}']
    __py_callbacks__[index]['{fun}'] = callback
    if callback: callback = {fun}(callback)
    __c_callbacks__[index]['{fun}'] = callback
    _glfw.{callback}(window, callback)
    return old_callback""".format(callback=callback, fun=fun)
    return code

exec(__callback__('Error'))
exec(__callback__('Monitor'))
exec(__callback__('WindowPos'))
exec(__callback__('WindowSize'))
exec(__callback__('WindowClose'))
exec(__callback__('WindowRefresh'))
exec(__callback__('WindowFocus'))
exec(__callback__('WindowIconify'))
exec(__callback__('FramebufferSize'))
exec(__callback__('Key'))
exec(__callback__('Char'))
exec(__callback__('MouseButton'))
exec(__callback__('CursorPos'))
exec(__callback__('Scroll'))
exec(__callback__('Drop'))


def getHDPIFactor(window):
    try:
        return float(glfwGetFramebufferSize(window)[0] /
                     glfwGetWindowSize(window)[0])
    except ZeroDivisionError:
        return 1.

plot_utils.py

# -*- coding: utf-8 -*-
import logging
from itertools import cycle, chain
from collections import Counter

from glfw import *
from OpenGL.GL import *

import numpy as np
# create logger for the context of this function

import time

from pyglui import __etra__
from pyglui.graph import ETRA_Graph
from pyglui.cygl.utils import init
from pyglui.cygl.utils import RGBA
from pyglui.pyfontstash import fontstash as fs
from pyglui.cygl.shader import Shader

colors = cycle(((0.66015625, 0.859375, 0.4609375, 0.8),
                (0.46875, 0.859375, 0.90625, 0.8),
                (0.99609375, 0.84375, 0.3984375, 0.8),
                (0.984375, 0.59375, 0.40234375, 0.8),
                (0.66796875, 0.61328125, 0.9453125, 0.8),
                (0.99609375, 0.37890625, 0.53125, 0.8)))


class Graph(object):
    def __init__(self, width=1280, height=300, fps=30, sum_values=False):
        self.quit = False
        self.fps = fps

        self.sum_values =  sum_values
        self.recent_value = Counter()

        glfwInit()
        # get glfw started

        self.window = glfwCreateWindow(width, height, 'Graph', None, None)
        if not self.window:
            exit()

        glfwSetWindowPos(self.window, 0, 0)
        # Register callbacks for the window
        glfwSetWindowSizeCallback(self.window,self.on_resize)
        glfwSetWindowCloseCallback(self.window, self.on_close)
        # test out new paste function

        glfwMakeContextCurrent(self.window)
        init()

        self.basic_gl_setup()
        self.plots = {}
        self.on_resize(self.window, *glfwGetFramebufferSize(self.window))
        self.draw_time = 0

    def setup_plot(self, name):
        plot = ETRA_Graph(data_points=250., max_val=30)
        plot.color = RGBA(*next(colors))
        plot.pos = (10, 10)
        plot.update_rate = 1
        plot.legend_idx = len(self.plots)
        plot.legend_margin = 75.
        plot.label = name
        plot.scale = 5
        self.plots[name] = plot
        self.recent_value[name] = 0
        self.on_resize(self.window, *glfwGetFramebufferSize(self.window))
        self.draw_time = 0

    def append_data(self, target, datum):
        if target not in self.recent_value:
            self.setup_plot(target)
        if self.sum_values:
            self.recent_value[target] += datum
        else:
            self.recent_value[target] = datum

    def basic_gl_setup(self):
        glEnable(GL_POINT_SPRITE )
        glEnable(GL_VERTEX_PROGRAM_POINT_SIZE) # overwrite pointsize
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
        glEnable(GL_BLEND)
        glClearColor(.8,.8,.8,1.)
        glEnable(GL_LINE_SMOOTH)
        # glEnable(GL_POINT_SMOOTH)
        glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)
        glEnable(GL_LINE_SMOOTH)
        glEnable(GL_POLYGON_SMOOTH)
        glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST)


    def adjust_gl_view(self, w, h, window):
        """
        adjust view onto our scene.
        """
        glViewport(0, 0, int(w), int(h))
        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        glOrtho(0, w, h, 0, -1, 1)
        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()

    # Callback functions
    def on_resize(self, window, w, h):
        h = max(h, 1)
        w = max(w, 1)
        hdpi_factor = getHDPIFactor(self.window)
        w, h = w * hdpi_factor, h * hdpi_factor
        active_window = glfwGetCurrentContext()
        glfwMakeContextCurrent(active_window)
        self.adjust_gl_view(w, h, window)
        glfwMakeContextCurrent(active_window)

        for plot in self.plots.values():
            plot.adjust_window_size(w, h)

    def on_close(self, window):
        self.quit = True
        logger.info('Process closing from window')

    def draw(self):
        if self.quit:
            sys.exit()

        if time.time() - self.draw_time < 1/self.fps:
            return

        try:
            data_gen = (plot.data for plot in self.plots.values())
            max_val = max(chain.from_iterable(data_gen))
        except ValueError:
            pass # no plots setup yet
        else:
            for t, plot in self.plots.items():
                plot.add(self.recent_value[t])
                plot.max_val = max(max_val, 1)
                plot.draw()

        glfwSwapBuffers(self.window)
        glfwPollEvents()
        glClearColor(.0,.0,.0,1)
        glClear(GL_COLOR_BUFFER_BIT)

        self.draw_time = time.time()

    def __del__(self):
        glfwTerminate()


if __name__ == '__main__':
    g = Graph()
    while True:
        g.append_data('Watch', np.random.randn(1))
        g.append_data('Phone', np.random.randn(1))
        g.append_data('Flyer', np.random.randn(1))
        g.draw()