wxPython/wxPython/lib/vtk.py

   1 """
   2 VTK is now including a package for using VTK with wxPython, so this
   3 module is now officially nothing but ancient history.  If for some
   4 strange reason you really need this code (I don't know why, it didn't
   5 work all that well anyway,) then just remove the triple quotes below.
   6 I'm told that the module from Kitware is excellent and so you should
   7 really use it.  See the URL below to get a copy from CVS.
   8
   9 http://public.kitware.com/cgi-bin/cvsweb.cgi/VTK/Wrapping/Python/vtk/wx/
  10 """
  11
  12 print __doc__
  13
  14 """
  15 #----------------------------------------------------------------------
  16 # Name:        wxPython.lib.vtk
  17 # Purpose:     Provides a wrapper around the vtkRenderWindow from the
  18 #              VTK Visualization Toolkit.  Requires the VTK Python
  19 #              extensions from http://www.kitware.com/
  20 #
  21 # Author:      Robin Dunn
  22 #
  23 # Created:     16-Nov-1999
  24 # RCS-ID:      $Id$
  25 # Copyright:   (c) 1999 by Total Control Software
  26 # Licence:     wxWindows license
  27 #----------------------------------------------------------------------
  28
  29 # This class has been rewritten and improved by Prabhu Ramachandran
  30 # <prabhu@aero.iitm.ernet.in>.  It has been tested under Win32 and
  31 # Linux.  Many thanks to Eric Boix <frog@creatis.insa-lyon.fr> for
  32 # testing it under Windows and finding and fixing many errors.
  33 # Thanks also to Sebastien BARRE <sebastien@barre.nom.fr> for his
  34 # suggestions.
  35
  36
  37 try:
  38     from vtkpython import *
  39 except ImportError:
  40     raise ImportError, "VTK extension module not found"
  41
  42 from wxPython.wx import *
  43 import math
  44
  45 #----------------------------------------------------------------------
  46
  47 DEBUG = 0
  48
  49 def debug(msg):
  50     if DEBUG:
  51         print msg
  52
  53
  54 class wxVTKRenderWindowBase(wxWindow):
  55     """
  56     A base class that enables one to embed a vtkRenderWindow into
  57     a wxPython widget.  This class embeds the RenderWindow correctly
  58     under different platforms.  Provided are some empty methods that
  59     can be overloaded to provide a user defined interaction behaviour.
  60     The event handling functions have names that are similar to the
  61     ones in the vtkInteractorStyle class included with VTK.
  62     """
  63
  64     def __init__(self, parent, id, position=wxDefaultPosition,
  65                  size=wxDefaultSize, style=0):
  66         wxWindow.__init__(self, parent, id, position, size, style | wxWANTS_CHARS)
  67         self._RenderWindow = vtkRenderWindow()
  68
  69         self.__InExpose = 0
  70         self.__Created = 0
  71
  72         if wxPlatform != '__WXMSW__':
  73             # We can't get the handle in wxGTK until after the widget
  74             # is created, the window create event happens later so we'll
  75             # catch it there
  76             EVT_WINDOW_CREATE(self, self.OnCreateWindow)
  77             EVT_PAINT       (self, self.OnExpose)
  78         else:
  79             # but in MSW, the window create event happens durring the above
  80             # call to __init__ so we have to do it here.
  81             hdl = self.GetHandle()
  82             self._RenderWindow.SetWindowInfo(str(hdl))
  83             EVT_PAINT       (self, self.OnExpose)
  84             self.__Created = 1
  85
  86         # common for all platforms
  87         EVT_SIZE        (self, self.OnConfigure)
  88
  89         # setup the user defined events.
  90         self.SetupEvents()
  91
  92
  93     def SetupEvents(self):
  94         "Setup the user defined event bindings."
  95         # Remember to bind everything to self.box and NOT self
  96         EVT_LEFT_DOWN    (self, self.OnLeftButtonDown)
  97         EVT_MIDDLE_DOWN  (self, self.OnMiddleButtonDown)
  98         EVT_RIGHT_DOWN   (self, self.OnRightButtonDown)
  99         EVT_LEFT_UP      (self, self.OnLeftButtonUp)
 100         EVT_MIDDLE_UP    (self, self.OnMiddleButtonUp)
 101         EVT_RIGHT_UP     (self, self.OnRightButtonUp)
 102         EVT_MOTION       (self, self.OnMouseMove)
 103         EVT_ENTER_WINDOW (self, self.OnEnter)
 104         EVT_LEAVE_WINDOW (self, self.OnLeave)
 105         EVT_CHAR         (self, self.OnChar)
 106         # Add your bindings if you want them in the derived class.
 107
 108
 109     def GetRenderer(self):
 110         self._RenderWindow.GetRenderers().InitTraversal()
 111         return self._RenderWindow.GetRenderers().GetNextItem()
 112
 113
 114     def GetRenderWindow(self):
 115         return self._RenderWindow
 116
 117
 118     def Render(self):
 119         if self.__Created:
 120             # if block needed because calls to render before creation
 121             # will prevent the renderwindow from being embedded into a
 122             # wxPython widget.
 123             self._RenderWindow.Render()
 124
 125
 126     def OnExpose(self, event):
 127         # I need this for the MDIDemo.  Somehow OnCreateWindow was
 128         # not getting called.
 129         if not self.__Created:
 130             self.OnCreateWindow(event)
 131         if (not self.__InExpose):
 132             self.__InExpose = 1
 133             dc = wxPaintDC(self)
 134             self._RenderWindow.Render()
 135             self.__InExpose = 0
 136
 137
 138     def OnCreateWindow(self, event):
 139         hdl = self.GetHandle()
 140         try:
 141             self._RenderWindow.SetParentInfo(str(hdl))
 142         except:
 143             self._RenderWindow.SetWindowInfo(str(hdl))
 144             msg = "Warning:\n "\
 145                   "Unable to call vtkRenderWindow.SetParentInfo\n\n"\
 146                   "Using the SetWindowInfo method instead.  This\n"\
 147                   "is likely to cause a lot of flicker when\n"\
 148                   "rendering in the vtkRenderWindow.  Please\n"\
 149                   "use a recent Nightly VTK release (later than\n"\
 150                   "March 10 2001) to eliminate this problem."
 151             dlg = wxMessageDialog(NULL, msg, "Warning!",
 152                                    wxOK |wxICON_INFORMATION)
 153             dlg.ShowModal()
 154             dlg.Destroy()
 155         self.__Created = 1
 156
 157
 158     def OnConfigure(self, event):
 159         sz = self.GetSize()
 160         self.SetSize(sz)
 161         # Ugly hack that according to Eric Boix is necessary under
 162         # Windows.  If possible Try commenting this out and test under
 163         # Windows.
 164         #self._RenderWindow.GetSize()
 165         #
 166         self._RenderWindow.SetSize(sz.width, sz.height)
 167
 168
 169     def OnLeftButtonDown(self, event):
 170         "Left mouse button pressed."
 171         pass
 172
 173
 174     def OnMiddleButtonDown(self, event):
 175         "Middle mouse button pressed."
 176         pass
 177
 178
 179     def OnRightButtonDown(self, event):
 180         "Right mouse button pressed."
 181         pass
 182
 183
 184     def OnLeftButtonUp(self, event):
 185         "Left mouse button released."
 186         pass
 187
 188
 189     def OnMiddleButtonUp(self, event):
 190         "Middle mouse button released."
 191         pass
 192
 193
 194     def OnRightButtonUp(self, event):
 195         "Right mouse button released."
 196         pass
 197
 198
 199     def OnMouseMove(self, event):
 200         "Mouse has moved."
 201         pass
 202
 203
 204     def OnEnter(self, event):
 205         "Entering the vtkRenderWindow."
 206         pass
 207
 208
 209     def OnLeave(self, event):
 210         "Leaving the vtkRenderWindow."
 211         pass
 212
 213
 214     def OnChar(self, event):
 215         "Process Key events."
 216         pass
 217
 218
 219     def OnKeyDown(self, event):
 220         "Key pressed down."
 221         pass
 222
 223
 224     def OnKeyUp(self, event):
 225         "Key released."
 226         pass
 227
 228
 229
 230
 231 class wxVTKRenderWindow(wxVTKRenderWindowBase):
 232     """
 233     An example of a fully functional wxVTKRenderWindow that is
 234     based on the vtkRenderWidget.py provided with the VTK sources.
 235     """
 236
 237     def __init__(self, parent, id, position=wxDefaultPosition,
 238                  size=wxDefaultSize, style=0):
 239         wxVTKRenderWindowBase.__init__(self, parent, id, position, size,
 240                                        style)
 241
 242         self._CurrentRenderer = None
 243         self._CurrentCamera = None
 244         self._CurrentZoom = 1.0
 245         self._CurrentLight = None
 246
 247         self._ViewportCenterX = 0
 248         self._ViewportCenterY = 0
 249
 250         self._Picker = vtkCellPicker()
 251         self._PickedAssembly = None
 252         self._PickedProperty = vtkProperty()
 253         self._PickedProperty.SetColor(1,0,0)
 254         self._PrePickedProperty = None
 255
 256         self._OldFocus = None
 257
 258         # these record the previous mouse position
 259         self._LastX = 0
 260         self._LastY = 0
 261
 262
 263     def OnLeftButtonDown(self, event):
 264         "Left mouse button pressed."
 265         self.StartMotion(event)
 266
 267
 268     def OnMiddleButtonDown(self, event):
 269         "Middle mouse button pressed."
 270         self.StartMotion(event)
 271
 272
 273     def OnRightButtonDown(self, event):
 274         "Right mouse button pressed."
 275         self.StartMotion(event)
 276
 277
 278     def OnLeftButtonUp(self, event):
 279         "Left mouse button released."
 280         self.EndMotion(event)
 281
 282
 283     def OnMiddleButtonUp(self, event):
 284         "Middle mouse button released."
 285         self.EndMotion(event)
 286
 287
 288     def OnRightButtonUp(self, event):
 289         "Right mouse button released."
 290         self.EndMotion(event)
 291
 292
 293     def OnMouseMove(self, event):
 294         event.x, event.y = event.GetPositionTuple()
 295         if event.LeftIsDown():
 296             if event.ShiftDown():
 297                 self.Pan(event.x, event.y)
 298             else:
 299                 self.Rotate(event.x, event.y)
 300
 301         elif event.MiddleIsDown():
 302             self.Pan(event.x, event.y)
 303
 304         elif event.RightIsDown():
 305             self.Zoom(event.x, event.y)
 306
 307
 308     def OnEnter(self, event):
 309         self.__OldFocus = wxWindow_FindFocus()
 310         self.SetFocus()
 311         x, y = event.GetPositionTuple()
 312         self.UpdateRenderer(x,y)
 313
 314
 315     def OnLeave(self, event):
 316         if (self._OldFocus != None):
 317             self.__OldFocus.SetFocus()
 318
 319
 320     def OnChar(self, event):
 321         key = event.KeyCode()
 322         if (key == ord('r')) or (key == ord('R')):
 323             self.Reset()
 324         elif (key == ord('w')) or (key == ord('W')):
 325             self.Wireframe()
 326         elif (key == ord('s')) or (key == ord('S')):
 327             self.Surface()
 328         elif (key == ord('p')) or (key == ord('P')):
 329             x, y = event.GetPositionTuple()
 330             self.PickActor(x, y)
 331         else:
 332             event.Skip()
 333
 334
 335     # Start of internal functions
 336     def GetZoomFactor(self):
 337         return self._CurrentZoom
 338
 339
 340     def SetZoomFactor(self, zf):
 341         self._CurrentZoom = zf
 342
 343
 344     def GetPicker(self):
 345         return self._Picker
 346
 347
 348     def Render(self):
 349         if (self._CurrentLight):
 350             light = self._CurrentLight
 351             light.SetPosition(self._CurrentCamera.GetPosition())
 352             light.SetFocalPoint(self._CurrentCamera.GetFocalPoint())
 353
 354         wxVTKRenderWindowBase.Render(self)
 355
 356
 357     def UpdateRenderer(self, x, y):
 358         """
 359         UpdateRenderer will identify the renderer under the mouse and set
 360         up _CurrentRenderer, _CurrentCamera, and _CurrentLight.
 361         """
 362         sz = self.GetSize()
 363         windowX = sz.width
 364         windowY = sz.height
 365
 366         renderers = self._RenderWindow.GetRenderers()
 367         numRenderers = renderers.GetNumberOfItems()
 368
 369         self._CurrentRenderer = None
 370         renderers.InitTraversal()
 371         for i in range(0,numRenderers):
 372             renderer = renderers.GetNextItem()
 373             vx,vy = (0,0)
 374             if (windowX > 1):
 375                 vx = float (x)/(windowX-1)
 376             if (windowY > 1):
 377                 vy = (windowY-float(y)-1)/(windowY-1)
 378             (vpxmin,vpymin,vpxmax,vpymax) = renderer.GetViewport()
 379
 380             if (vx >= vpxmin and vx <= vpxmax and
 381                 vy >= vpymin and vy <= vpymax):
 382                 self._CurrentRenderer = renderer
 383                 self._ViewportCenterX = float(windowX)*(vpxmax-vpxmin)/2.0\
 384                                         +vpxmin
 385                 self._ViewportCenterY = float(windowY)*(vpymax-vpymin)/2.0\
 386                                         +vpymin
 387                 self._CurrentCamera = self._CurrentRenderer.GetActiveCamera()
 388                 lights = self._CurrentRenderer.GetLights()
 389                 lights.InitTraversal()
 390                 self._CurrentLight = lights.GetNextItem()
 391                 break
 392
 393         self._LastX = x
 394         self._LastY = y
 395
 396
 397     def GetCurrentRenderer(self):
 398         return self._CurrentRenderer
 399
 400
 401     def StartMotion(self, event):
 402         x, y = event.GetPositionTuple()
 403         self.UpdateRenderer(x,y)
 404         self.CaptureMouse()
 405
 406
 407     def EndMotion(self, event=None):
 408         if self._CurrentRenderer:
 409             self.Render()
 410         self.ReleaseMouse()
 411
 412
 413     def Rotate(self,x,y):
 414         if self._CurrentRenderer:
 415
 416             self._CurrentCamera.Azimuth(self._LastX - x)
 417             self._CurrentCamera.Elevation(y - self._LastY)
 418             self._CurrentCamera.OrthogonalizeViewUp()
 419
 420             self._LastX = x
 421             self._LastY = y
 422
 423             self._CurrentRenderer.ResetCameraClippingRange()
 424             self.Render()
 425
 426
 427     def PanAbsolute(self, x_vec, y_vec):
 428         if self._CurrentRenderer:
 429
 430             renderer = self._CurrentRenderer
 431             camera = self._CurrentCamera
 432             (pPoint0,pPoint1,pPoint2) = camera.GetPosition()
 433             (fPoint0,fPoint1,fPoint2) = camera.GetFocalPoint()
 434
 435             if (camera.GetParallelProjection()):
 436                 renderer.SetWorldPoint(fPoint0,fPoint1,fPoint2,1.0)
 437                 renderer.WorldToDisplay()
 438                 fx,fy,fz = renderer.GetDisplayPoint()
 439                 renderer.SetDisplayPoint(fx+x_vec,
 440                                          fy+y_vec,
 441                                          fz)
 442                 renderer.DisplayToWorld()
 443                 fx,fy,fz,fw = renderer.GetWorldPoint()
 444                 camera.SetFocalPoint(fx,fy,fz)
 445
 446                 renderer.SetWorldPoint(pPoint0,pPoint1,pPoint2,1.0)
 447                 renderer.WorldToDisplay()
 448                 fx,fy,fz = renderer.GetDisplayPoint()
 449                 renderer.SetDisplayPoint(fx+x_vec,
 450                                          fy+y_vec,
 451                                          fz)
 452                 renderer.DisplayToWorld()
 453                 fx,fy,fz,fw = renderer.GetWorldPoint()
 454                 camera.SetPosition(fx,fy,fz)
 455
 456             else:
 457                 (fPoint0,fPoint1,fPoint2) = camera.GetFocalPoint()
 458                 # Specify a point location in world coordinates
 459                 renderer.SetWorldPoint(fPoint0,fPoint1,fPoint2,1.0)
 460                 renderer.WorldToDisplay()
 461                 # Convert world point coordinates to display coordinates
 462                 dPoint = renderer.GetDisplayPoint()
 463                 focalDepth = dPoint[2]
 464
 465                 aPoint0 = self._ViewportCenterX + x_vec
 466                 aPoint1 = self._ViewportCenterY + y_vec
 467
 468                 renderer.SetDisplayPoint(aPoint0,aPoint1,focalDepth)
 469                 renderer.DisplayToWorld()
 470
 471                 (rPoint0,rPoint1,rPoint2,rPoint3) = renderer.GetWorldPoint()
 472                 if (rPoint3 != 0.0):
 473                     rPoint0 = rPoint0/rPoint3
 474                     rPoint1 = rPoint1/rPoint3
 475                     rPoint2 = rPoint2/rPoint3
 476
 477                 camera.SetFocalPoint((fPoint0 - rPoint0) + fPoint0,
 478                                      (fPoint1 - rPoint1) + fPoint1,
 479                                      (fPoint2 - rPoint2) + fPoint2)
 480
 481                 camera.SetPosition((fPoint0 - rPoint0) + pPoint0,
 482                                    (fPoint1 - rPoint1) + pPoint1,
 483                                    (fPoint2 - rPoint2) + pPoint2)
 484
 485             self.Render()
 486
 487
 488     def Pan(self, x, y):
 489         self.PanAbsolute(x - self._LastX, - y + self._LastY)
 490         self._LastX = x
 491         self._LastY = y
 492
 493
 494     def Zoom(self,x,y):
 495         if self._CurrentRenderer:
 496
 497             renderer = self._CurrentRenderer
 498             camera = self._CurrentCamera
 499
 500             zoomFactor = math.pow(1.02,(0.5*(self._LastY - y)))
 501             self._CurrentZoom = self._CurrentZoom * zoomFactor
 502
 503             if camera.GetParallelProjection():
 504                 parallelScale = camera.GetParallelScale()/zoomFactor
 505                 camera.SetParallelScale(parallelScale)
 506             else:
 507                 camera.Dolly(zoomFactor)
 508                 renderer.ResetCameraClippingRange()
 509
 510             self._LastX = x
 511             self._LastY = y
 512
 513             self.Render()
 514
 515
 516     def Reset(self):
 517         if self._CurrentRenderer:
 518             self._CurrentRenderer.ResetCamera()
 519
 520         self.Render()
 521
 522
 523     def Wireframe(self):
 524         actors = self._CurrentRenderer.GetActors()
 525         numActors = actors.GetNumberOfItems()
 526         actors.InitTraversal()
 527         for i in range(0,numActors):
 528             actor = actors.GetNextItem()
 529             actor.GetProperty().SetRepresentationToWireframe()
 530
 531         self.Render()
 532
 533
 534     def Surface(self):
 535         actors = self._CurrentRenderer.GetActors()
 536         numActors = actors.GetNumberOfItems()
 537         actors.InitTraversal()
 538         for i in range(0,numActors):
 539             actor = actors.GetNextItem()
 540             actor.GetProperty().SetRepresentationToSurface()
 541
 542         self.Render()
 543
 544
 545     def PickActor(self,x,y):
 546         if self._CurrentRenderer:
 547             renderer = self._CurrentRenderer
 548             picker = self._Picker
 549
 550             windowY = self.GetSize().height
 551             picker.Pick(x,(windowY - y - 1),0.0,renderer)
 552             assembly = picker.GetAssembly()
 553
 554             if (self._PickedAssembly != None and
 555                 self._PrePickedProperty != None):
 556                 self._PickedAssembly.SetProperty(self._PrePickedProperty)
 557                 # release hold of the property
 558                 self._PrePickedProperty.UnRegister(self._PrePickedProperty)
 559                 self._PrePickedProperty = None
 560
 561             if (assembly != None):
 562                 self._PickedAssembly = assembly
 563                 self._PrePickedProperty = self._PickedAssembly.GetProperty()
 564                 # hold onto the property
 565                 self._PrePickedProperty.Register(self._PrePickedProperty)
 566                 self._PickedAssembly.SetProperty(self._PickedProperty)
 567
 568             self.Render()
 569 """