def _with_context(self, hdc, proc, flush=False):
old_hdc = wgl.wglGetCurrentDC()
old_ctx = wgl.wglGetCurrentContext()
result = wgl.wglMakeCurrent(hdc, self._win_context)
try:
self._with_share_group(proc)
if flush:
if self._win_dblbuf:
wgl.SwapBuffers(hdc)
else:
gl.glFlush()
finally:
wgl.wglMakeCurrent(old_hdc, old_ctx)
def _with_context(self, hdc, proc, flush=False):
old_hdc = wgl.wglGetCurrentDC()
old_ctx = wgl.wglGetCurrentContext()
result = wgl.wglMakeCurrent(hdc, self._win_context)
try:
self._with_share_group(proc)
if flush:
if self._win_dblbuf:
wgl.SwapBuffers(hdc)
else:
gl.glFlush()
finally:
wgl.wglMakeCurrent(old_hdc, old_ctx)
def viewer_init(self, w, h):
pangolin.CreateWindowAndBind('Map Viewer', w, h)
gl.glEnable(gl.GL_DEPTH_TEST)
self.scam = pangolin.OpenGlRenderState(
pangolin.ProjectionMatrix(w, h, 420, 420, w // 2, h // 2, 0.2,
10000),
pangolin.ModelViewLookAt(0, -10, -8, 0, 0, 0, 0, -1, 0))
self.handler = pangolin.Handler3D(self.scam)
# Create Interactive View in window
self.dcam = pangolin.CreateDisplay()
self.dcam.SetBounds(0.0, 1.0, 0.0, 1.0, w / h)
self.dcam.SetHandler(self.handler)
# hack to avoid small Pangolin, no idea why it's *2
self.dcam.Resize(pangolin.Viewport(0, 0, w * 2, h * 2))
self.dcam.Activate()
def main():
pangolin.CreateWindowAndBind('Main', 640, 480)
gl.glEnable(gl.GL_DEPTH_TEST)
# Define Projection and initial ModelView matrix
scam = pangolin.OpenGlRenderState(
pangolin.ProjectionMatrix(640, 480, 420, 420, 320, 240, 0.2, 100),
pangolin.ModelViewLookAt(-2, 2, -2, 0, 0, 0,
pangolin.AxisDirection.AxisY))
handler = pangolin.Handler3D(scam)
# Create Interactive View in window
dcam = pangolin.CreateDisplay()
dcam.SetBounds(0.0, 1.0, 0.0, 1.0, -640.0 / 480.0)
dcam.SetHandler(handler)
while not pangolin.ShouldQuit():
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glClearColor(1.0, 1.0, 1.0, 1.0)
dcam.Activate(scam)
# Render OpenGL Cube
pangolin.glDrawColouredCube()
# Draw Point Cloud
points = np.random.random((100000, 3)) * 10
colors = np.zeros((len(points), 3))
colors[:, 1] = 1 - points[:, 0] / 10.
colors[:, 2] = 1 - points[:, 1] / 10.
colors[:, 0] = 1 - points[:, 2] / 10.
gl.glPointSize(2)
gl.glColor3f(1.0, 0.0, 0.0)
# access numpy array directly(without copying data), array should be contiguous.
pangolin.DrawPoints(points, colors)
pangolin.FinishFrame()
def delete(self, ident, texlist=None):
if not texlist:
texlist = Texture.textures
OpenGL.glDeleteTextures(texlist[ident])
texlist.pop(ident)
def viewer_refresh(self, q):
while not q.empty():
self.state = q.get()
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
self.dcam.Activate(self.scam)
if self.state is not None:
if self.state[0].shape[0] >= 2:
# draw poses
gl.glColor3f(0.0, 1.0, 0.0)
pangolin.DrawCameras(self.state[0][:-1])
if self.state[0].shape[0] >= 1:
# draw current pose as yellow
gl.glColor3f(1.0, 1.0, 0.0)
pangolin.DrawCameras(self.state[0][-1:])
if self.state[1].shape[0] != 0:
# draw keypoints
gl.glPointSize(5)
gl.glColor3f(1.0, 0.0, 0.0)
pangolin.DrawPoints(self.state[1], self.state[2])
pangolin.FinishFrame()
#!/usr/bin/env python
import X11, OpenGL as GL
from X11.extensions import GLX
from OpenGL import utility as GLU
GL.require('GL_VERSION_1_0')
GLX.require('GLX_VERSION_1_0')
import X11.display, X11.window, X11.event
attributes = (X11.Integer*5)(GLX.RGBA, GLX.DOUBLEBUFFER, GLX.DEPTH_SIZE, 16, 0)
display = X11.Open()
screen = display.default_screen
root = display.root
info = GLX.ChooseVisual(display, screen, attributes)
context = GLX.CreateContext(display, info, None, True)
window = root.CreateSimpleWindow(width=640, height=400)
window.SelectInput(X11.event.Mask.StructureNotify)
GLX.MakeCurrent(display, window, context)
window.MapRaised()
GL.Enable(GL.DEPTH_TEST)
GL.ShadeModel(GL.SMOOTH)
def drawPlane(num_divs=200, div_size=10):
# Plane parallel to x-z at origin with normal -y
minx = -num_divs * div_size
minz = -num_divs * div_size
maxx = num_divs * div_size
maxz = num_divs * div_size
#gl.glLineWidth(2)
#gl.glColor3f(0.7,0.7,1.0)
gl.glColor3f(0.7, 0.7, 0.7)
gl.glBegin(gl.GL_LINES)
for n in range(2 * num_divs):
gl.glVertex3f(minx + div_size * n, 0, minz)
gl.glVertex3f(minx + div_size * n, 0, maxz)
gl.glVertex3f(minx, 0, minz + div_size * n)
gl.glVertex3f(maxx, 0, minz + div_size * n)
gl.glEnd()
def viewer_refresh(self, qmap, qvo, is_paused):
while not qmap.empty():
self.map_state = qmap.get()
while not qvo.empty():
self.vo_state = qvo.get()
# if pangolin.Pushed(self.button):
# print('You Pushed a button!')
self.do_follow = self.checkboxFollow.Get()
self.is_grid = self.checkboxGrid.Get()
self.draw_cameras = self.checkboxCams.Get()
self.draw_covisibility = self.checkboxCovisibility.Get()
self.draw_spanning_tree = self.checkboxSpanningTree.Get()
#if pangolin.Pushed(self.checkboxPause):
if self.checkboxPause.Get():
is_paused.value = 0
else:
is_paused.value = 1
# self.int_slider.SetVal(int(self.float_slider))
self.pointSize = self.int_slider.Get()
if self.do_follow and self.is_following:
self.scam.Follow(self.Twc, True)
elif self.do_follow and not self.is_following:
self.scam.SetModelViewMatrix(self.look_view)
self.scam.Follow(self.Twc, True)
self.is_following = True
elif not self.do_follow and self.is_following:
self.is_following = False
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glClearColor(1.0, 1.0, 1.0, 1.0)
self.dcam.Activate(self.scam)
if self.is_grid:
Viewer3D.drawPlane()
# ==============================
# draw map
if self.map_state is not None:
if self.map_state.cur_pose is not None:
# draw current pose in blue
gl.glColor3f(0.0, 0.0, 1.0)
gl.glLineWidth(2)
pangolin.DrawCamera(self.map_state.cur_pose)
gl.glLineWidth(1)
self.updateTwc(self.map_state.cur_pose)
if self.map_state.predicted_pose is not None and kDrawCameraPrediction:
# draw predicted pose in red
gl.glColor3f(1.0, 0.0, 0.0)
pangolin.DrawCamera(self.map_state.predicted_pose)
if len(self.map_state.poses) > 1:
# draw keyframe poses in green
if self.draw_cameras:
gl.glColor3f(0.0, 1.0, 0.0)
pangolin.DrawCameras(self.map_state.poses[:])
if len(self.map_state.points) > 0:
# draw keypoints with their color
gl.glPointSize(self.pointSize)
#gl.glColor3f(1.0, 0.0, 0.0)
pangolin.DrawPoints(self.map_state.points,
self.map_state.colors)
if self.map_state.reference_pose is not None and kDrawReferenceCamera:
# draw predicted pose in purple
gl.glColor3f(0.5, 0.0, 0.5)
gl.glLineWidth(2)
pangolin.DrawCamera(self.map_state.reference_pose)
gl.glLineWidth(1)
if len(self.map_state.covisibility_graph) > 0:
if self.draw_covisibility:
gl.glLineWidth(1)
gl.glColor3f(0.0, 1.0, 0.0)
pangolin.DrawLines(self.map_state.covisibility_graph, 3)
if len(self.map_state.spanning_tree) > 0:
if self.draw_spanning_tree:
gl.glLineWidth(1)
gl.glColor3f(0.0, 0.0, 1.0)
pangolin.DrawLines(self.map_state.spanning_tree, 3)
if len(self.map_state.loops) > 0:
if self.draw_spanning_tree:
gl.glLineWidth(2)
gl.glColor3f(0.5, 0.0, 0.5)
pangolin.DrawLines(self.map_state.loops, 3)
gl.glLineWidth(1)
# ==============================
# draw vo
if self.vo_state is not None:
if self.vo_state.poses.shape[0] >= 2:
# draw poses in green
if self.draw_cameras:
gl.glColor3f(0.0, 1.0, 0.0)
pangolin.DrawCameras(self.vo_state.poses[:-1])
if self.vo_state.poses.shape[0] >= 1:
# draw current pose in blue
gl.glColor3f(0.0, 0.0, 1.0)
current_pose = self.vo_state.poses[-1:]
pangolin.DrawCameras(current_pose)
self.updateTwc(current_pose[0])
if self.vo_state.traj3d_est.shape[0] != 0:
# draw blue estimated trajectory
gl.glPointSize(self.pointSize)
gl.glColor3f(0.0, 0.0, 1.0)
pangolin.DrawLine(self.vo_state.traj3d_est)
if self.vo_state.traj3d_gt.shape[0] != 0:
# draw red ground-truth trajectory
gl.glPointSize(self.pointSize)
gl.glColor3f(1.0, 0.0, 0.0)
pangolin.DrawLine(self.vo_state.traj3d_gt)
pangolin.FinishFrame()
def viewer_init(self, w, h):
# pangolin.ParseVarsFile('app.cfg')
pangolin.CreateWindowAndBind('Map Viewer', w, h)
gl.glEnable(gl.GL_DEPTH_TEST)
viewpoint_x = 0
viewpoint_y = -40
viewpoint_z = -80
viewpoint_f = 1000
self.proj = pangolin.ProjectionMatrix(w, h, viewpoint_f, viewpoint_f,
w // 2, h // 2, 0.1, 5000)
self.look_view = pangolin.ModelViewLookAt(viewpoint_x, viewpoint_y,
viewpoint_z, 0, 0, 0, 0, -1,
0)
self.scam = pangolin.OpenGlRenderState(self.proj, self.look_view)
self.handler = pangolin.Handler3D(self.scam)
# Create Interactive View in window
self.dcam = pangolin.CreateDisplay()
self.dcam.SetBounds(0.0, 1.0, kUiWidth / w, 1.0, -w / h)
self.dcam.SetHandler(pangolin.Handler3D(self.scam))
self.panel = pangolin.CreatePanel('ui')
self.panel.SetBounds(0.0, 1.0, 0.0, kUiWidth / w)
self.do_follow = True
self.is_following = True
self.draw_cameras = True
self.draw_covisibility = True
self.draw_spanning_tree = True
self.draw_loops = True
#self.button = pangolin.VarBool('ui.Button', value=False, toggle=False)
self.checkboxFollow = pangolin.VarBool('ui.Follow',
value=True,
toggle=True)
self.checkboxCams = pangolin.VarBool('ui.Draw Cameras',
value=True,
toggle=True)
self.checkboxCovisibility = pangolin.VarBool('ui.Draw Covisibility',
value=True,
toggle=True)
self.checkboxSpanningTree = pangolin.VarBool('ui.Draw Tree',
value=True,
toggle=True)
self.checkboxGrid = pangolin.VarBool('ui.Grid',
value=True,
toggle=True)
self.checkboxPause = pangolin.VarBool('ui.Pause',
value=False,
toggle=True)
#self.float_slider = pangolin.VarFloat('ui.Float', value=3, min=0, max=5)
#self.float_log_slider = pangolin.VarFloat('ui.Log_scale var', value=3, min=1, max=1e4, logscale=True)
self.int_slider = pangolin.VarInt('ui.Point Size',
value=kDefaultPointSize,
min=1,
max=10)
self.pointSize = self.int_slider.Get()
self.Twc = pangolin.OpenGlMatrix()
self.Twc.SetIdentity()
def delete(self, ident, texlist = None):
if not texlist:
texlist = Texture.textures
OpenGL.glDeleteTextures(texlist[ident])
texlist.pop(ident)
print ("Slowing Down")
Incr = Incr - 1
elif Key == b'q' or Key == b'Q':
print ("Bye")
sys.exit()
else:
print ("Invalid Key ",Key)
def timer(dummy):
display()
glutTimerFunc(30,timer,0)
def reshape(w, h):
print ("Width=",w,"Height=",h)
b=OpenGL(height=640,width=640)
b.glutInit(sys.argv)
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH)
glutInitWindowSize(640,640)
glutInitWindowPosition(100, 100)
glutCreateWindow(b"PyOpenGL Demo")
glClearColor(1,1,0,0)
# glPolygonMode(GL_FRONT_AND_BACK,GL_FILL)
# glEnable(GL_DEPTH_TEST)
# glDepthFunc(GL_LESS);
glutDisplayFunc(display)
# glutKeyboardFunc(keyHandler)
# glutTimerFunc(300,timer,0)
glMatrixMode (GL_PROJECTION)
