home *** CD-ROM | disk | FTP | other *** search
/ Hackers Magazine 57 / CdHackersMagazineNr57.iso / Software / Multimedia / k3d-setup-0.7.11.0.exe / lib / site-packages / OpenGL / Tk / __init__.py
Encoding:
Python Source  |  2008-12-07  |  13.3 KB  |  559 lines
  1. #!/usr/bin/env python
  2.  
  3. # This is statement is required by the build system to query build info
  4. if __name__ == '__build__':
  5.     raise Exception
  6.  
  7. # A class that creates an opengl widget.
  8. # Mike Hartshorn
  9. # Department of Chemistry
  10. # University of York, UK
  11. # 
  12.  
  13. from OpenGL.GL import *
  14. from OpenGL.GLU import *
  15. from Tkinter import _default_root
  16. from Tkinter import *
  17. import math
  18. import os,sys
  19.  
  20. #
  21.  
  22. def glTranslateScene(s, x, y, mousex, mousey):
  23.     glMatrixMode(GL_MODELVIEW)
  24.     mat = glGetDoublev(GL_MODELVIEW_MATRIX)
  25.     glLoadIdentity()
  26.     glTranslatef(s * (x - mousex), s * (mousey - y), 0.0)
  27.     glMultMatrixd(mat)
  28.  
  29.  
  30. def glRotateScene(s, xcenter, ycenter, zcenter, x, y, mousex, mousey):
  31.     glMatrixMode(GL_MODELVIEW)
  32.     mat = glGetDoublev(GL_MODELVIEW_MATRIX)
  33.     glLoadIdentity()
  34.     glTranslatef(xcenter, ycenter, zcenter)
  35.     glRotatef(s * (y - mousey), 1., 0., 0.)
  36.     glRotatef(s * (x - mousex), 0., 1., 0.)
  37.     glTranslatef(-xcenter, -ycenter, -zcenter)
  38.     glMultMatrixd(mat)
  39.  
  40.  
  41. def sub(x, y):
  42.     return map(lambda a, b: a-b, x, y)
  43.  
  44.  
  45. def dot(x, y):
  46.     t = 0
  47.     for i in range(len(x)):
  48.         t = t + x[i]*y[i]
  49.     return t
  50.  
  51.  
  52. def glDistFromLine(x, p1, p2):
  53.     f = map(lambda x, y: x-y, p2, p1)
  54.     g = map(lambda x, y: x-y, x, p1)
  55.     return dot(g, g) - dot(f, g)**2/dot(f, f)
  56.  
  57.  
  58. # Keith Junius <junius@chem.rug.nl> provided many changes to Togl
  59. TOGL_NORMAL = 1
  60. TOGL_OVERLAY = 2
  61.  
  62. def v3distsq(a,b):
  63.     d = ( a[0] - b[0], a[1] - b[1], a[2] - b[2] )
  64.     return d[0]*d[0] + d[1]*d[1] + d[2]*d[2]
  65.  
  66. # new version from Daniel Faken (Daniel_Faken@brown.edu) for static 
  67. # loading comptability
  68. if _default_root is None:
  69.     _default_root = Tk()
  70.  
  71. # add this file's directory to Tcl's search path
  72. # on Linux Togl is installed in ./linux2-tk8.0
  73. # on Windows (Python2.0) in ./win32-tk8.3  
  74. try:
  75.     TOGL_DLL_PATH = os.path.join(
  76.         os.path.dirname(__file__),
  77.         sys.platform + "-tk" + _default_root.getvar("tk_version")
  78.     )
  79. except NameError, err:
  80.     # no __file__, likely running as an egg
  81.     TOGL_DLL_PATH = ""
  82. _default_root.tk.call('lappend', 'auto_path', TOGL_DLL_PATH)
  83. try:
  84.     _default_root.tk.eval('load {} Togl')
  85. except TclError:
  86.     pass
  87. _default_root.tk.call('package', 'require', 'Togl')
  88.  
  89. # This code is needed to avoid faults on sys.exit()
  90. # [DAA, Jan 1998]
  91. import sys
  92. oldexitfunc = None
  93. if hasattr(sys, 'exitfunc'):
  94.     oldexitfunc = sys.exitfunc
  95. def cleanup():
  96.     from Tkinter import _default_root, TclError
  97.     import Tkinter
  98.     try: 
  99.         if _default_root: _default_root.destroy()
  100.     except TclError:
  101.         pass
  102.     Tkinter._default_root = None
  103.     if oldexitfunc: oldexitfunc()
  104. sys.exitfunc = cleanup
  105. # [end DAA]
  106.  
  107. class Togl(Widget):
  108.     """
  109.     Togl Widget
  110.     Keith Junius
  111.     Department of Biophysical Chemistry
  112.     University of Groningen, The Netherlands
  113.     Very basic widget which provides access to Togl functions.
  114.     N.B. this requires a modified version of Togl 1.5 to gain access to the
  115.     extra functionality. This support should be included in Togl 1.6, I hope.
  116.     """
  117.  
  118.  
  119.     def __init__(self, master=None, cnf={}, **kw):
  120.         Widget.__init__(self, master, 'togl', cnf, kw)
  121.  
  122.  
  123.     def render(self):
  124.         return
  125.  
  126.  
  127.     def swapbuffers(self):
  128.         self.tk.call(self._w, 'swapbuffers')
  129.  
  130.  
  131.     def makecurrent(self):
  132.         self.tk.call(self._w, 'makecurrent')
  133.  
  134.  
  135.     def alloccolor(self, red, green, blue):
  136.         return self.tk.getint(self.tk.call(self._w, 'alloccolor', red, green, blue))
  137.  
  138.  
  139.     def freecolor(self, index):
  140.         self.tk.call(self._w, 'freecolor', index)
  141.  
  142.  
  143.     def setcolor(self, index, red, green, blue):
  144.         self.tk.call(self._w, 'setcolor', index, red, green, blue)
  145.  
  146.  
  147.     def loadbitmapfont(self, fontname):
  148.         return self.tk.getint(self.tk.call(self._w, 'loadbitmapfont', fontname))
  149.  
  150.  
  151.     def unloadbitmapfont(self, fontbase):
  152.         self.tk.call(self._w, 'unloadbitmapfont', fontbase)
  153.  
  154.  
  155.     def uselayer(self, layer):
  156.         self.tk.call(self._w, 'uselayer', layer)
  157.  
  158.  
  159.     def showoverlay(self):
  160.         self.tk.call(self._w, 'showoverlay')
  161.  
  162.  
  163.     def hideoverlay(self):
  164.         self.tk.call(self._w, 'hideoverlay')
  165.  
  166.  
  167.     def existsoverlay(self):
  168.         return self.tk.getboolean(self.tk.call(self._w, 'existsoverlay'))
  169.  
  170.  
  171.     def getoverlaytransparentvalue(self):
  172.         return self.tk.getint(self.tk.call(self._w, 'getoverlaytransparentvalue'))
  173.  
  174.  
  175.     def ismappedoverlay(self):
  176.         return self.tk.getboolean(self.tk.call(self._w, 'ismappedoverlay'))
  177.  
  178.  
  179.     def alloccoloroverlay(self, red, green, blue):
  180.         return self.tk.getint(self.tk.call(self._w, 'alloccoloroverlay', red, green, blue))
  181.  
  182.  
  183.     def freecoloroverlay(self, index):
  184.         self.tk.call(self._w, 'freecoloroverlay', index)
  185.  
  186.  
  187.  
  188. class RawOpengl(Widget, Misc):
  189.     """Widget without any sophisticated bindings\
  190.     by Tom Schwaller"""
  191.  
  192.  
  193.     def __init__(self, master=None, cnf={}, **kw):
  194.         Widget.__init__(self, master, 'togl', cnf, kw)
  195.         self.bind('<Map>', self.tkMap)
  196.         self.bind('<Expose>', self.tkExpose)
  197.         self.bind('<Configure>', self.tkExpose)
  198.  
  199.  
  200.     def tkRedraw(self, *dummy):
  201.         # This must be outside of a pushmatrix, since a resize event
  202.         # will call redraw recursively. 
  203.         self.update_idletasks()
  204.         self.tk.call(self._w, 'makecurrent')
  205.         _mode = glGetDoublev(GL_MATRIX_MODE)
  206.         try:
  207.             glMatrixMode(GL_PROJECTION)
  208.             glPushMatrix()
  209.             try:
  210.                 self.redraw()
  211.                 glFlush()
  212.             finally:
  213.                 glPopMatrix()
  214.         finally:
  215.             glMatrixMode(_mode)
  216.         self.tk.call(self._w, 'swapbuffers')
  217.  
  218.  
  219.     def tkMap(self, *dummy):
  220.         self.tkExpose()
  221.  
  222.  
  223.     def tkExpose(self, *dummy):
  224.         self.tkRedraw()
  225.  
  226.  
  227.  
  228.  
  229. class Opengl(RawOpengl):
  230.     """\
  231. Tkinter bindings for an Opengl widget.
  232. Mike Hartshorn
  233. Department of Chemistry
  234. University of York, UK
  235. http://www.yorvic.york.ac.uk/~mjh/
  236. """
  237.  
  238.     def __init__(self, master=None, cnf={}, **kw):
  239.         """\
  240.         Create an opengl widget.
  241.         Arrange for redraws when the window is exposed or when
  242.         it changes size."""
  243.  
  244.         #Widget.__init__(self, master, 'togl', cnf, kw)
  245.         apply(RawOpengl.__init__, (self, master, cnf), kw)
  246.         self.initialised = 0
  247.  
  248.         # Current coordinates of the mouse.
  249.         self.xmouse = 0
  250.         self.ymouse = 0
  251.  
  252.         # Where we are centering.
  253.         self.xcenter = 0.0
  254.         self.ycenter = 0.0
  255.         self.zcenter = 0.0
  256.  
  257.         # The _back color
  258.         self.r_back = 1.
  259.         self.g_back = 0.
  260.         self.b_back = 1.
  261.  
  262.         # Where the eye is
  263.         self.distance = 10.0
  264.  
  265.         # Field of view in y direction
  266.         self.fovy = 30.0
  267.  
  268.         # Position of clipping planes.
  269.         self.near = 0.1
  270.         self.far = 1000.0
  271.  
  272.         # Is the widget allowed to autospin?
  273.         self.autospin_allowed = 0
  274.  
  275.         # Is the widget currently autospinning?
  276.         self.autospin = 0
  277.  
  278.         # Basic bindings for the virtual trackball
  279.         self.bind('<Map>', self.tkMap)
  280.         self.bind('<Expose>', self.tkExpose)
  281.         self.bind('<Configure>', self.tkExpose)
  282.         self.bind('<Shift-Button-1>', self.tkHandlePick)
  283.         #self.bind('<Button-1><ButtonRelease-1>', self.tkHandlePick)
  284.         self.bind('<Button-1>', self.tkRecordMouse)
  285.         self.bind('<B1-Motion>', self.tkTranslate)
  286.         self.bind('<Button-2>', self.StartRotate)
  287.         self.bind('<B2-Motion>', self.tkRotate)
  288.         self.bind('<ButtonRelease-2>', self.tkAutoSpin)
  289.         self.bind('<Button-3>', self.tkRecordMouse)
  290.         self.bind('<B3-Motion>', self.tkScale)
  291.  
  292.  
  293.     def help(self):
  294.         """Help for the widget."""
  295.  
  296.         import Dialog
  297.         d = Dialog.Dialog(None, {'title': 'Viewer help',
  298.                                  'text': 'Button-1: Translate\n'
  299.                                          'Button-2: Rotate\n'
  300.                                          'Button-3: Zoom\n'
  301.                                          'Reset: Resets transformation to identity\n',
  302.                                  'bitmap': 'questhead',
  303.                                  'default': 0,
  304.                                  'strings': ('Done', 'Ok')})
  305.  
  306.  
  307.     def activate(self):
  308.         """Cause this Opengl widget to be the current destination for drawing."""
  309.  
  310.         self.tk.call(self._w, 'makecurrent')
  311.  
  312.  
  313.     # This should almost certainly be part of some derived class.
  314.     # But I have put it here for convenience.
  315.     def basic_lighting(self):
  316.         """\
  317.         Set up some basic lighting (single infinite light source).
  318.  
  319.         Also switch on the depth buffer."""
  320.    
  321.         self.activate()
  322.         light_position = (1, 1, 1, 0)
  323.         glLightfv(GL_LIGHT0, GL_POSITION, light_position)
  324.         glEnable(GL_LIGHTING)
  325.         glEnable(GL_LIGHT0)
  326.         glDepthFunc(GL_LESS)
  327.         glEnable(GL_DEPTH_TEST)
  328.         glMatrixMode(GL_MODELVIEW)
  329.         glLoadIdentity()
  330.  
  331.  
  332.     def report_opengl_errors(message = "OpenGL error:"):
  333.         """Report any opengl errors that occured while drawing."""
  334.  
  335.         print 'report_opengl_errors is now useless.  glGetError replaced by GLexception'
  336. #        while 1:
  337. #            err_value = glGetError()
  338. #            if not err_value: break     
  339. #            print message, gluErrorString(err_value)
  340.  
  341.  
  342.     def set_background(self, r, g, b):
  343.         """Change the background colour of the widget."""
  344.  
  345.         self.r_back = r
  346.         self.g_back = g
  347.         self.b_back = b
  348.  
  349.         self.tkRedraw()
  350.  
  351.  
  352.     def set_centerpoint(self, x, y, z):
  353.         """Set the new center point for the model.
  354.         This is where we are looking."""
  355.  
  356.         self.xcenter = x
  357.         self.ycenter = y
  358.         self.zcenter = z
  359.  
  360.         self.tkRedraw()
  361.  
  362.  
  363.     def set_eyepoint(self, distance):
  364.         """Set how far the eye is from the position we are looking."""
  365.  
  366.         self.distance = distance
  367.         self.tkRedraw()
  368.  
  369.  
  370.     def reset(self):
  371.         """Reset rotation matrix for this widget."""
  372.  
  373.         glMatrixMode(GL_MODELVIEW)
  374.         glLoadIdentity()
  375.         self.tkRedraw()
  376.  
  377.  
  378.     def tkHandlePick(self, event):
  379.         """Handle a pick on the scene."""
  380.  
  381.         if hasattr(self, 'pick'):
  382.             # here we need to use glu.UnProject
  383.  
  384.             # Tk and X have their origin top left, 
  385.             # while Opengl has its origin bottom left.
  386.             # So we need to subtract y from the window height to get
  387.             # the proper pick position for Opengl
  388.  
  389.             realy = self.winfo_height() - event.y
  390.  
  391.             p1 = gluUnProject(event.x, realy, 0.)
  392.             p2 = gluUnProject(event.x, realy, 1.)
  393.  
  394.             if self.pick(self, p1, p2):
  395.                 """If the pick method returns true we redraw the scene."""
  396.  
  397.                 self.tkRedraw()
  398.  
  399.  
  400.     def tkRecordMouse(self, event):
  401.         """Record the current mouse position."""
  402.  
  403.         self.xmouse = event.x
  404.         self.ymouse = event.y
  405.  
  406.  
  407.     def StartRotate(self, event):
  408.         # Switch off any autospinning if it was happening
  409.  
  410.         self.autospin = 0
  411.         self.tkRecordMouse(event)
  412.  
  413.  
  414.     def tkScale(self, event):
  415.         """Scale the scene.  Achieved by moving the eye position.
  416.  
  417.         Dragging up zooms in, while dragging down zooms out
  418.         """
  419.         scale = 1 - 0.01 * (event.y - self.ymouse)
  420.         # do some sanity checks, scale no more than
  421.         # 1:1000 on any given click+drag
  422.         if scale < 0.001:
  423.             scale = 0.001
  424.         elif scale > 1000:
  425.             scale = 1000
  426.         self.distance = self.distance * scale
  427.         self.tkRedraw()
  428.         self.tkRecordMouse(event)
  429.  
  430.  
  431.     def do_AutoSpin(self):
  432.         s = 0.5
  433.         self.activate()
  434.  
  435.         glRotateScene(0.5, self.xcenter, self.ycenter, self.zcenter, self.yspin, self.xspin, 0, 0)
  436.         self.tkRedraw()
  437.  
  438.         if self.autospin:
  439.             self.after(10, self.do_AutoSpin)
  440.  
  441.  
  442.     def tkAutoSpin(self, event):
  443.         """Perform autospin of scene."""
  444.  
  445.         self.after(4)
  446.         self.update_idletasks()
  447.  
  448.         # This could be done with one call to pointerxy but I'm not sure
  449.         # it would any quicker as we would have to split up the resulting
  450.         # string and then conv
  451.  
  452.         x = self.tk.getint(self.tk.call('winfo', 'pointerx', self._w))
  453.         y = self.tk.getint(self.tk.call('winfo', 'pointery', self._w))
  454.  
  455.         if self.autospin_allowed:
  456.             if x != event.x_root and y != event.y_root:
  457.                 self.autospin = 1
  458.  
  459.         self.yspin = x - event.x_root
  460.         self.xspin = y - event.y_root
  461.  
  462.         self.after(10, self.do_AutoSpin)
  463.  
  464.  
  465.     def tkRotate(self, event):
  466.         """Perform rotation of scene."""
  467.  
  468.         self.activate()
  469.         glRotateScene(0.5, self.xcenter, self.ycenter, self.zcenter, event.x, event.y, self.xmouse, self.ymouse)
  470.         self.tkRedraw()
  471.         self.tkRecordMouse(event)
  472.  
  473.  
  474.     def tkTranslate(self, event):
  475.         """Perform translation of scene."""
  476.  
  477.         self.activate()
  478.  
  479.         # Scale mouse translations to object viewplane so object tracks with mouse
  480.         win_height = max( 1,self.winfo_height() )
  481.         obj_c      = ( self.xcenter, self.ycenter, self.zcenter )
  482.         win        = gluProject( obj_c[0], obj_c[1], obj_c[2])
  483.         obj        = gluUnProject( win[0], win[1] + 0.5 * win_height, win[2])
  484.         dist       = math.sqrt( v3distsq( obj, obj_c ) )
  485.         scale      = abs( dist / ( 0.5 * win_height ) )
  486.  
  487.         glTranslateScene(scale, event.x, event.y, self.xmouse, self.ymouse)
  488.         self.tkRedraw()
  489.         self.tkRecordMouse(event)
  490.  
  491.  
  492.     def tkRedraw(self, *dummy):
  493.         """Cause the opengl widget to redraw itself."""
  494.  
  495.         if not self.initialised: return
  496.         self.activate()
  497.  
  498.         glPushMatrix()            # Protect our matrix
  499.         self.update_idletasks()
  500.         self.activate()
  501.         w = self.winfo_width()
  502.         h = self.winfo_height()
  503.         glViewport(0, 0, w, h)
  504.  
  505.         # Clear the background and depth buffer.
  506.         glClearColor(self.r_back, self.g_back, self.b_back, 0.)
  507.         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
  508.  
  509.         glMatrixMode(GL_PROJECTION)
  510.         glLoadIdentity()
  511.         gluPerspective(self.fovy, float(w)/float(h), self.near, self.far)
  512.  
  513.         if 0:
  514.             # Now translate the scene origin away from the world origin
  515.             glMatrixMode(GL_MODELVIEW)
  516.             mat = glGetDoublev(GL_MODELVIEW_MATRIX)
  517.             glLoadIdentity()
  518.             glTranslatef(-self.xcenter, -self.ycenter, -(self.zcenter+self.distance))
  519.             glMultMatrixd(mat)
  520.         else:
  521.             gluLookAt(self.xcenter, self.ycenter, self.zcenter + self.distance,
  522.                 self.xcenter, self.ycenter, self.zcenter,
  523.                 0., 1., 0.)
  524.             glMatrixMode(GL_MODELVIEW)
  525.     
  526.         # Call objects redraw method.
  527.         self.redraw(self)
  528.         glFlush()                # Tidy up
  529.         glPopMatrix()            # Restore the matrix
  530.  
  531.         self.tk.call(self._w, 'swapbuffers')
  532.     def redraw( self, *args, **named ):
  533.         """Prevent access errors if user doesn't set redraw fast enough"""
  534.  
  535.  
  536.     def tkMap(self, *dummy):
  537.         """Cause the opengl widget to redraw itself."""
  538.  
  539.         self.tkExpose()
  540.  
  541.  
  542.     def tkExpose(self, *dummy):
  543.         """Redraw the widget.
  544.         Make it active, update tk events, call redraw procedure and
  545.         swap the buffers.  Note: swapbuffers is clever enough to
  546.         only swap double buffered visuals."""
  547.  
  548.         self.activate()
  549.         if not self.initialised:
  550.             self.basic_lighting()
  551.             self.initialised = 1
  552.         self.tkRedraw()
  553.  
  554.  
  555.     def tkPrint(self, file):
  556.         """Turn the current scene into PostScript via the feedback buffer."""
  557.  
  558.         self.activate()
  559.