class btvizGL:
running = True
leftMouseDown = False
rotate = False
mouseXY = [0, 0]
camera = None
index = GL.GLuint()
lists = []
poly = False
scalefactor = 100
root = [0, 0, 0]
displaysize = (0, 0)
animate = False
imagecount = 0
filename = None
axis = 'z'
rotation = 0
showStats = True
graph = False
backgroundColour = [0, 0, 0]
Neuron = None
Graph = None
gb = None
def drawLine(self, parent, child, color, linewidth):
GL.glLineWidth(linewidth)
GL.glColor3f(color[0], color[1], color[2])
GL.glBegin(GL.GL_LINES)
GL.glVertex3f(parent[0], parent[1], parent[2])
GL.glVertex3f(child[0], child[1], child[2])
GL.glEnd()
def RenderText(self, text, x, y):
GL.glColor3f(1.0, 0.0, 0.0)
GL.glWindowPos2f(x, y)
GLUT.glutBitmapString(GLUT.GLUT_BITMAP_HELVETICA_10, text)
def initGL(self, multisample):
GL.glShadeModel(GL.GL_SMOOTH)
GL.glColorMaterial(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE)
GL.glClearColor(self.backgroundColour[0], self.backgroundColour[1],
self.backgroundColour[2], 1)
GL.glDepthFunc(GL.GL_LEQUAL)
GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glEnable(GL.GL_CULL_FACE)
if multisample:
GL.glEnable(GL.GL_MULTISAMPLE)
self.camera = camera(self.root)
def display(self):
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glLoadIdentity()
self.camera.update()
self.drawObjects()
if self.showStats:
self.drawText()
GLUT.glutSwapBuffers()
if self.Animate:
self.SaveImage(self.imagecount)
self.imagecount += 1
self.camera.phi += 1
if self.imagecount == 360:
filenames = listdir('captures/images/')
filenames = [int(x.split(".")[0]) for x in filenames]
filenames.sort()
filenames = [str(x) + ".bmp" for x in filenames]
with imageio.get_writer('captures/animations/' +
self.filename + '.gif',
mode='I',
fps=30) as writer:
from os import remove
for filename in filenames:
image = imageio.imread('captures/images/' + filename)
writer.append_data(image)
remove('captures/images/' + filename)
GLUT.glutSetOption(GLUT.GLUT_ACTION_ON_WINDOW_CLOSE,
GLUT.GLUT_ACTION_GLUTMAINLOOP_RETURNS)
self.running = False
GLUT.glutPostRedisplay()
def drawObjects(self):
if self.poly:
if self.graph:
self.gb.determineVisGraphPlanes(self.camera.phi,
self.camera.theta)
if self.animate:
if self.axis is 'x':
GL.glRotate(self.rotation, 1, 0, 0)
if self.axis is 'y':
GL.glRotate(self.rotation, 0, 0, 1)
if self.axis is 'z':
GL.glRotate(self.rotation, 0, 1, 0)
self.rotation += 1
GL.glCallList(self.Neuron)
else:
if len(self.vertices_gl) > 0:
GL.glPushMatrix()
self.vertices_gl.bind()
GL.glEnableClientState(GL.GL_VERTEX_ARRAY)
GL.glVertexPointer(3, GLUT.GL_FLOAT, 0, self.vertices_gl)
self.colors_gl.bind()
GL.glEnableClientState(GL.GL_COLOR_ARRAY)
GL.glColorPointer(3, GLUT.GL_FLOAT, 0, self.colors_gl)
GL.glDrawArrays(GL.GL_LINES, 0, len(self.vertices_gl))
GL.glPopMatrix()
def drawText(self):
self.RenderText(
('CamPos %f,%f,%f') %
(self.camera.pos[0], self.camera.pos[1], self.camera.pos[2]), 10,
575)
self.RenderText(
('theta %f, phi %f') % (self.camera.theta, self.camera.phi), 10,
555)
self.RenderText(('radius %f') % (self.camera.rad), 10, 495)
self.RenderText(
('CentrePos %f,%f,%f') %
(self.camera.focus[0], self.camera.focus[1], self.camera.focus[2]),
10, 515)
self.RenderText(
('MousePos %f,%f') % (self.mouseXY[0], self.mouseXY[1]), 10, 535)
self.RenderText(('rotate ' + self.rotate.__str__()), 10, 475)
def reshape(self, width, height):
if height == 0:
height = 1
aspect = width / height
GL.glViewport(0, 0, width, height)
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
GLU.gluPerspective(90, aspect, 0.01, 100)
def mouse(self, button, state, x, y):
self.rotate = False
if button == GLUT.GLUT_LEFT_BUTTON and state == GLUT.GLUT_DOWN:
self.leftMouseDown = True
self.mouseXY = [x, y]
self.rotate = True
elif button == GLUT.GLUT_LEFT_BUTTON and state == GLUT.GLUT_UP:
self.leftMouseDown = False
def mouseMove(self, x, y):
if (self.rotate):
self.camera.phi += (x - self.mouseXY[0]) * 0.1
if self.camera.phi > 180:
self.camera.phi = self.camera.phi - 360
elif self.camera.phi < -180:
self.camera.phi = self.camera.phi + 360
self.camera.theta = self.clamp(
self.camera.theta + (y - self.mouseXY[1]) * 0.1, -89.999,
89.999)
self.mouseXY = [x, y]
GLUT.glutPostRedisplay()
def clamp(self, n, minn, maxn):
return max(min(maxn, n), minn)
def mouseWheel(self, wheel, direction, x, y):
if direction > 0:
self.camera.rad = max(0.1, self.camera.rad - 0.1)
elif direction < 0:
self.camera.rad = min(100, self.camera.rad + 0.1)
GLUT.glutPostRedisplay()
def keyDown(self, key, x, y):
'''
if key == 'w':
self.camera.forward = True
if key == 's':
self.camera.backward = True
if key == 'a':
self.camera.left = True
if key == 'd':
self.camera.right = True
'''
if key == 'q':
self.camera.up = True
if key == 'e':
self.camera.down = True
GLUT.glutPostRedisplay()
def keyUp(self, key, x, y):
'''
if key == 'w':
self.camera.forward = False
if key == 's':
self.camera.backward = False
if key == 'a':
self.camera.left = False
if key == 'd':
self.camera.right = False
'''
if key == 'q':
self.camera.up = False
if key == 'e':
self.camera.down = False
if key == 'r':
self.camera.focus = self.root
self.camera.phi = 0
self.camera.theta = 0
if key == 'p':
self.SaveImage(0)
if key == 'h':
self.showStats = not self.showStats
if key == 'g':
self.graph = not self.graph
if key == 'q':
self.running = False
GLUT.glutPostRedisplay()
def SaveImage(self, index):
buff = GL.glReadPixels(0, 0, self.displaysize[0], self.displaysize[1],
GL.GL_RGB, GLUT.GL_UNSIGNED_BYTE)
image = Image.frombytes(mode="RGB",
size=(self.displaysize[0],
self.displaysize[1]),
data=buff)
image = image.transpose(Image.FLIP_TOP_BOTTOM)
image.save('captures/images/' + str(index) + '.bmp')
def Animate(self,
neuronObject,
filename,
displaysize=(800, 600),
radius=5,
poly=True,
axis='z',
graph=False):
self.Animate = True
self.filename = filename
self.axis = axis
self.showStats = False
self.main(neuronObject, displaysize, radius, poly, False, True, graph)
def Plot(self,
neuronObject,
displaysize=(800, 600),
radius=5,
poly=True,
fast=False,
multisample=True,
graph=True):
self.Animate = False
self.showStats = True
self.main(neuronObject, displaysize, radius, poly, fast, multisample,
graph)
def main(self,
neuronObject,
displaysize=(800, 600),
radius=5,
poly=True,
fast=False,
multisample=True,
graph=True):
self.poly = poly
self.displaysize = displaysize
self.graph = graph
title = 'btmorph OpenGL Viewer'
GLUT.glutInit(sys.argv)
if multisample:
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE)
else:
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE
| GLUT.GLUT_MULTISAMPLE)
GLUT.glutInitWindowSize(self.displaysize[0], self.displaysize[1])
GLUT.glutInitWindowPosition(50, 50)
GLUT.glutCreateWindow(title)
GLUT.glutDisplayFunc(self.display)
GLUT.glutReshapeFunc(self.reshape)
GLUT.glutMouseFunc(self.mouse)
GLUT.glutMotionFunc(self.mouseMove)
GLUT.glutMouseWheelFunc(self.mouseWheel)
GLUT.glutKeyboardFunc(self.keyDown)
GLUT.glutKeyboardUpFunc(self.keyUp)
mb = modelbuilder()
self.root, self.vertices_gl, self.colors_gl, self.Neuron = \
mb.build(neuronObject, self.poly, 100, fast)
if graph:
self.gb = graphbuilder()
self.Graph, mid = \
self.gb.build(neuronObject, scalefactor=100)
self.initGL(multisample)
self.camera.rad = radius
self.camera.focus = mid
while self.running:
GLUT.glutMainLoopEvent()
GLUT.glutDestroyWindow(GLUT.glutGetWindow())
def main():
# declare draw method so it can be reused during resizing
def draw():
gl.glClearColor(0.2, 0.3, 0.3, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glUseProgram(shaderProgram)
gl.glBindVertexArray(VAO)
gl.glDrawElements(gl.GL_TRIANGLES, 3 * indices.shape[0],
gl.GL_UNSIGNED_INT, None)
gl.glBindVertexArray(0)
glfw.swap_buffers(window)
# declaring resize callback in main to allow access to variables
def window_size_callback(window, width, height):
gl.glViewport(0, 0, width, height)
# calling draw to allow drawing while resizing
draw()
# glfw: initialize and configure
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE,
glfw.OPENGL_CORE_PROFILE) # No deprecated functions
glfw.window_hint(glfw.RESIZABLE, gl.GL_TRUE)
# checking if run on Mac OS X
if sys.platform == 'darwin':
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, gl.GL_TRUE)
# glfw window creation
window = glfw.create_window(WIDTH, HEIGHT, 'LearnOpenGL', None,
None) # tutorial: (800, 600...
if window is None:
glfw.terminate()
raise Exception("ERROR: Failed to create GLFW window")
glfw.make_context_current(window)
glfw.set_key_callback(window, key_callback)
width, height = glfw.get_framebuffer_size(window)
glfw.set_window_size_callback(window, window_size_callback)
# build and compile shader program
# vertex shader
vertexShader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource(vertexShader, vertexShaderSource)
gl.glCompileShader(vertexShader)
if not gl.glGetShaderiv(vertexShader, gl.GL_COMPILE_STATUS):
infoLog = gl.glGetShaderInfoLog(vertexShader).decode()
raise Exception("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" +
infoLog)
# fragment shader
fragmentShader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(fragmentShader, fragmentShaderSource)
gl.glCompileShader(fragmentShader)
if not gl.glGetShaderiv(fragmentShader, gl.GL_COMPILE_STATUS):
infoLog = gl.glGetShaderInfoLog(fragmentShader).decode()
raise Exception("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" +
infoLog)
# link shaders
shaderProgram = gl.glCreateProgram()
gl.glAttachShader(shaderProgram, vertexShader)
gl.glAttachShader(shaderProgram, fragmentShader)
gl.glLinkProgram(shaderProgram)
if not gl.glGetProgramiv(shaderProgram, gl.GL_LINK_STATUS):
infoLog = gl.glGetProgramInfoLog(shaderProgram).decode()
raise Exception("ERROR::SHADER::PROGRAM::LINKING_FAILED\n" + infoLog)
gl.glDeleteShader(vertexShader)
gl.glDeleteShader(fragmentShader)
# set up vertex data (and buffer(s)) and configure vertex attributes
vertices = np.array(
[
[0.5, 0.5, 0.0], # Left
[0.5, -0.5, 0.0], # Right
[-0.5, -0.5, 0.0],
[-0.5, 0.5, 0.0]
], # Top
dtype=np.float32)
indices = np.array(
[
[0, 1, 3], # first triangle
[1, 2, 3]
], # second triangle
dtype=np.int32)
VBO, VAO, EBO = gl.GLuint(), gl.GLuint(), gl.GLuint()
gl.glGenVertexArrays(1, VAO) # 1 -> 1 buffer to be generated
gl.glGenBuffers(1, VBO)
gl.glGenBuffers(1, EBO)
# bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s)
gl.glBindVertexArray(VAO)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER,
VBO) # bind = make active/current for subsequent ops
gl.glBufferData(gl.GL_ARRAY_BUFFER, vertices, gl.GL_STATIC_DRAW)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, EBO)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, indices, gl.GL_STATIC_DRAW)
stride = vertices.itemsize * vertices.shape[1]
offset = gl.ctypes.c_void_p(vertices.itemsize * 0)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, stride, offset)
gl.glEnableVertexAttribArray(0) # location = 0
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
gl.glBindVertexArray(0)
# to put in wireframe mode
gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_LINE)
# render loop
while not glfw.window_should_close(window):
glfw.poll_events()
draw()
glfw.terminate()
return 0
def main():
if not glfw.init():
return -1
if not glfw.init():
return -1
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 2)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 1)
window = glfw.create_window(800, 600, "Oculus Test", None, None)
if not window:
glfw.terminate()
glfw.make_context_current(window)
glfw.swap_interval(0)
if failure(initialize()):
return -1
if failure(create()):
shutdown()
return -1
hmdInfo = getHmdInfo()
for eye, fov in enumerate(hmdInfo.defaultEyeFov):
setEyeRenderFov(eye, fov)
texSizeLeft = calcEyeBufferSize(EYE_LEFT)
texSizeRight = calcEyeBufferSize(EYE_RIGHT)
bufferW = texSizeLeft[0] + texSizeRight[0]
bufferH = max(texSizeLeft[1], texSizeRight[1])
createTextureSwapChainGL(TEXTURE_SWAP_CHAIN0, bufferW, bufferH)
for eye in range(EYE_COUNT):
setEyeColorTextureSwapChain(eye, TEXTURE_SWAP_CHAIN0)
eye_w = int(bufferW / 2)
eye_h = bufferH
viewports = ((0, 0, eye_w, eye_h), (eye_w, 0, eye_w, eye_h))
for eye, vp in enumerate(viewports):
setEyeRenderViewport(eye, vp)
setHighQuality(True)
fboId = GL.GLuint()
GL.glGenFramebuffers(1, ctypes.byref(fboId))
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, fboId)
depthRb_id = GL.GLuint()
GL.glGenRenderbuffers(1, ctypes.byref(depthRb_id))
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, depthRb_id)
GL.glRenderbufferStorage(GL.GL_RENDERBUFFER, GL.GL_DEPTH24_STENCIL8,
int(bufferW),
int(bufferH)) # buffer size used here!
GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT,
GL.GL_RENDERBUFFER, depthRb_id)
GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_STENCIL_ATTACHMENT,
GL.GL_RENDERBUFFER, depthRb_id)
GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, 0)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
mirrorFbo = GL.GLuint()
GL.glGenFramebuffers(1, ctypes.byref(mirrorFbo))
createMirrorTexture(800, 600, mirrorOptions=MIRROR_OPTION_DEFAULT)
frame_index = 0
projectionMatrix = []
for eye in range(EYE_COUNT):
projectionMatrix.append(getEyeProjectionMatrix(eye))
planePose = LibOVRPose((0., 0., -2.))
# begin application loop
while not glfw.window_should_close(window):
waitToBeginFrame(frame_index)
abs_time = getPredictedDisplayTime(frame_index)
tracking_state = getTrackingState(abs_time, True)
calcEyePoses(tracking_state.headPose.thePose)
beginFrame(frame_index)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, fboId)
_, swapIdx = getTextureSwapChainCurrentIndex(TEXTURE_SWAP_CHAIN0)
_, tex_id = getTextureSwapChainBufferGL(TEXTURE_SWAP_CHAIN0, swapIdx)
GL.glFramebufferTexture2D(GL.GL_DRAW_FRAMEBUFFER,
GL.GL_COLOR_ATTACHMENT0, GL.GL_TEXTURE_2D,
tex_id, 0)
for eye in range(EYE_COUNT):
vp = getEyeRenderViewport(eye)
GL.glViewport(*vp)
GL.glScissor(*vp)
P = projectionMatrix[eye]
MV = getEyeViewMatrix(eye)
GL.glEnable(GL.GL_SCISSOR_TEST)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadTransposeMatrixf(P)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glLoadTransposeMatrixf(MV)
GL.glClearColor(0.0, 0.0, 0.0, 1.0)
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glPushMatrix()
GL.glMultTransposeMatrixf(planePose.modelMatrix)
GL.glBegin(GL.GL_QUADS)
GL.glColor3f(1.0, 0.0, 0.0)
GL.glVertex3f(-1.0, -1.0, 0.0)
GL.glColor3f(0.0, 1.0, 0.0)
GL.glVertex3f(-1.0, 1.0, 0.0)
GL.glColor3f(0.0, 0.0, 1.0)
GL.glVertex3f(1.0, 1.0, 0.0)
GL.glColor3f(1.0, 1.0, 1.0)
GL.glVertex3f(1.0, -1.0, 0.0)
GL.glEnd()
GL.glPopMatrix()
GL.glDisable(GL.GL_DEPTH_TEST)
commitTextureSwapChain(TEXTURE_SWAP_CHAIN0)
GL.glBindFramebuffer(GL.GL_DRAW_FRAMEBUFFER, 0)
endFrame(frame_index)
frame_index += 1
GL.glBindFramebuffer(GL.GL_READ_FRAMEBUFFER, mirrorFbo)
GL.glBindFramebuffer(GL.GL_DRAW_FRAMEBUFFER, 0)
_, mirrorId = getMirrorTexture()
GL.glFramebufferTexture2D(GL.GL_READ_FRAMEBUFFER,
GL.GL_COLOR_ATTACHMENT0, GL.GL_TEXTURE_2D,
mirrorId, 0)
GL.glViewport(0, 0, 800, 600)
GL.glScissor(0, 0, 800, 600)
GL.glClearColor(0.0, 0.0, 0.0, 1.0)
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
GL.glBlitFramebuffer(0, 0, 800, 600, 0, 600, 800, 0,
GL.GL_COLOR_BUFFER_BIT, GL.GL_NEAREST)
GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
glfw.swap_buffers(window)
updateInputState(CONTROLLER_TYPE_TOUCH)
A = getButton(CONTROLLER_TYPE_TOUCH, BUTTON_A, 'falling')
B = getButton(CONTROLLER_TYPE_TOUCH, BUTTON_B, 'falling')
if A[0]:
recenterTrackingOrigin()
elif B[0]:
break
glfw.poll_events()
_, sessionStatus = getSessionStatus()
if sessionStatus.shouldQuit:
break
destroyMirrorTexture()
destroyTextureSwapChain(TEXTURE_SWAP_CHAIN0)
destroy()
# shutdown() causes access violation on exit
return 0
