vtk-ruby 5.0.4.0-x86-mswin32-60

data/lib/VTK/tk/vtkLoadRubyTkWidgets.rb.rule

@@ -0,0 +1 @@
+# generated from CMake

data/lib/VTK/tk/vtkTkImageViewerWidget.rb

@@ -0,0 +1,377 @@
+=begin
+A vtkTkImageViewerWidget for ruby, which is based on the
+vtkTkImageWindowWidget.
+
+Specify double=1 to get a double-buffered window.
+
+=end
+
+require 'tk'
+require 'vtk'
+require 'vtk/tk/vtkLoadRubyTkWidgets'
+
+
+class VtkTkImageViewerWidget < TkWindow
+=begin
+    A vtkTkImageViewerWidget for Ruby.
+
+    Use GetImageViewer() to get the vtkImageViewer.
+
+    Create with the keyword double=1 in order to generate a
+    double-buffered viewer.
+    
+    Create with the keyword focus_on_enter=1 to enable
+    focus-follows-mouse.  The default is for a click-to-focus mode.    
+=end
+  TkCommandNames = ['vtkTkImageViewerWidget'.freeze].freeze
+
+  def initialize(master, kw={})
+=begin
+        Constructor.
+
+        Keyword arguments:
+
+          iv -- Use passed image viewer instead of creating a new one.
+
+          double -- If True, generate a double-buffered viewer.
+          Defaults to False.
+
+          focus_on_enter -- If True, use a focus-follows-mouse mode.
+          Defaults to False where the widget will use a click-to-focus
+          mode.
+=end
+    # load the necessary extensions into tk
+    vtkLoadRubyTkWidgets()
+
+    _symbolkey2str(kw)
+
+    if kw['iv']
+      @ImageViewer = kw['iv']
+    else
+      @ImageViewer = Vtk::ImageViewer.new
+    end
+
+    doubleBuffer = 0
+    if kw['double']
+      doubleBuffer = 1
+      kw.delete('double')
+    end
+ 
+    # check if focus should follow mouse
+    if kw['focus_on_enter']
+      @FocusOnEnter = 1
+    else
+      @FocusOnEnter = 0
+    end
+
+    kw['iv'] = @ImageViewer.GetAddressAsString("vtkImageViewer")
+    kw['widgetname'] = 'vtkTkImageViewerWidget'
+    super(master, kw)
+
+    if doubleBuffer
+      @ImageViewer.GetRenderWindow.DoubleBufferOn
+    end
+
+    self.BindTkImageViewer
+  end
+
+  def GetImageViewer
+    return @ImageViewer
+  end
+
+  def Render
+    @ImageViewer.Render
+  end
+
+  def BindTkImageViewer
+    imager = @ImageViewer.GetRenderer
+        
+    # stuff for window level text.
+    mapper = Vtk::TextMapper.new
+    mapper.SetInput("none")
+    t_prop = mapper.GetTextProperty
+    t_prop.SetFontFamilyToTimes
+    t_prop.SetFontSize(18)
+    t_prop.BoldOn
+    t_prop.ShadowOn
+        
+    @LevelMapper = mapper
+
+    actor = Vtk::Actor2D.new
+    actor.SetMapper(mapper)
+    actor.SetLayerNumber(1)
+    actor.GetPositionCoordinate.SetValue(4,22)
+    actor.GetProperty.SetColor(1,1,0.5)
+    actor.SetVisibility(0)
+    imager.AddActor2D(actor)
+
+    @LevelActor = actor
+                
+    mapper = Vtk::TextMapper.new
+    mapper.SetInput("none")
+    t_prop = mapper.GetTextProperty
+    t_prop.SetFontFamilyToTimes
+    t_prop.SetFontSize(18)
+    t_prop.BoldOn
+    t_prop.ShadowOn
+    
+    @WindowMapper = mapper
+
+    actor = Vtk::Actor2D.new
+    actor.SetMapper(mapper)
+    actor.SetLayerNumber(1)
+    actor.GetPositionCoordinate.SetValue(4,4)
+    actor.GetProperty.SetColor(1,1,0.5)
+    actor.SetVisibility(0)
+    imager.AddActor2D(actor)
+
+    @WindowActor = actor
+
+    @LastX = 0
+    @LastY = 0
+    @OldFocus = 0
+    @InExpose = 0
+    
+    # bindings
+    # window level
+    self.bind("ButtonPress-1"){|e,s| s||s=self; s.StartWindowLevelInteraction(e.x,e.y) }
+    self.bind("B1-Motion"){|e,s| s||s=self; s.UpdateWindowLevelInteraction(e.x,e.y) }
+    self.bind("ButtonRelease-1"){|e,s| s||s=self; s.EndWindowLevelInteraction }
+    
+    # Get the value
+    self.bind("ButtonPress-3"){|e,s| s||s=self; s.StartQueryInteraction(e.x,e.y) }
+    self.bind("B3-Motion"){|e,s| s||s=self; s.UpdateQueryInteraction(e.x,e.y) }
+    self.bind("ButtonRelease-3"){|e,s| s||s=self; s.EndQueryInteraction }
+
+    self.bind("Expose"){|e,s| s||s=self; s.ExposeTkImageViewer }
+    self.bind("Enter"){|e,s| s||s=self; s.EnterTkViewer }
+    self.bind("Leave"){|e,s| s||s=self; s.LeaveTkViewer }
+    self.bind("KeyPress-e"){|e,s| s||s=self; exit }
+    self.bind("KeyPress-r"){|e,s| s||s=self; s.ResetTkImageViewer }
+  end
+
+  def GetImageViewer
+    return @ImageViewer
+  end
+
+  def Render
+    return @ImageViewer.Render
+  end
+
+  def _GrabFocus
+    @OldFocus = self.focus
+    self.focus
+  end
+        
+  def EnterTkViewer
+    if @FocusOnEnter
+      self._GrabFocus
+    end
+    return nil
+  end
+
+  def LeaveTkViewer
+    if @FocusOnEnter && @OldFocus != nil
+      @OldFocus.focus
+    end
+    return nil
+  end
+
+  def ExposeTkImageViewer
+    if @InExpose == 0
+      @InExpose = 1
+      self.update()
+      @ImageViewer.Render()
+      @InExpose = 0
+    end
+    return nil
+  end
+
+  def StartWindowLevelInteraction(x,y)
+    if ! @FocusOnEnter
+      _GrabFocus
+    end
+    viewer = @ImageViewer
+    @LastX = x
+    @LastY = y
+    @Window = viewer.GetColorWindow.to_f
+    @Level = viewer.GetColorLevel.to_f
+
+    # make the window level text visible
+    @LevelActor.SetVisibility(1)
+    @WindowActor.SetVisibility(1)
+
+    self.UpdateWindowLevelInteraction(x,y)
+    return nil
+  end
+
+  def EndWindowLevelInteraction
+    # make the window level text invisible
+    @LevelActor.SetVisibility(0)
+    @WindowActor.SetVisibility(0)
+    self.Render
+  end
+
+  def UpdateWindowLevelInteraction(x,y)
+    # compute normalized delta
+    dx = 4.0*(x - @LastX)/self.winfo_width*@Window
+    dy = 4.0*(@LastY - y)/self.winfo_height*@Level
+
+    # abs so that direction does not flip
+    if @Window < 0.0
+      dx = -dx
+    end
+    if @Level < 0.0
+      dy = -dy
+    end
+
+    # compute new window level
+    window = @Window + dx
+    if window < 0.0
+      level = @Level + dy
+    else
+      level = @Level - dy
+    end
+
+    viewer = @ImageViewer
+    viewer.SetColorWindow(window)
+    viewer.SetColorLevel(level)
+
+    @WindowMapper.SetInput("Window: %g" % window)
+    @LevelMapper.SetInput("Level: %g" % level)
+    
+    self.Render
+  end
+
+  def ResetTkImageViewer
+    # Reset: Set window level to show all values
+    viewer = @ImageViewer
+    input = viewer.GetInput
+    if input == nil
+      return nil
+    end
+
+    # Get the extent in viewer
+    z = viewer.GetZSlice
+
+    input.SetUpdateExtent(-99999,99999,-99999,99999,z,z)
+    input.Update
+
+    low,high = input.GetScalarRange
+   
+    viewer.SetColorWindow(high - low)
+    viewer.SetColorLevel((high + low) * 0.5)
+
+    self.Render
+  end
+
+  def StartQueryInteraction(x,y)
+    if ! @FocusOnEnter
+      _GrabFocus()
+    end
+    # Query PixleValue stuff
+    @WindowActor.SetVisibility(1)
+    self.UpdateQueryInteraction(x,y)
+  end
+
+  def EndQueryInteraction
+    @WindowActor.SetVisibility(0)
+    self.Render
+  end
+
+  def UpdateQueryInteraction(x,y)
+    viewer = @ImageViewer
+    input = viewer.GetInput
+    z = viewer.GetZSlice
+
+    # y is flipped upside down
+    y = self.winfo_height - y
+
+    # make sure point is in the whole extent of the image.
+    xMin,xMax,yMin,yMax,zMin,zMax = input.GetWholeExtent
+    if (x < xMin || x > xMax || y < yMin || y > yMax || z < zMin || z > zMax)
+      return nil
+    end
+
+    input.SetUpdateExtent(x,x,y,y,z,z)
+    input.Update
+    numComps = input.GetNumberOfScalarComponents
+    text = ""
+    for i in 0...numComps
+      val = input.GetScalarComponentAsDouble(x,y,z,i)
+      text = "#{text}  #{"%.1f"%val}"
+    end
+
+    @WindowMapper.SetInput("(#{"%d"%x}, #{"%d"%y}): #{text}")
+        
+    self.Render
+  end
+
+end
+
+#-----------------------------------------------------------------------------
+# an example of how to use this widget
+if $0 == __FILE__
+  canvas = Vtk::ImageCanvasSource2D.new
+  canvas.SetNumberOfScalarComponents(3)
+  canvas.SetScalarType(3)
+  canvas.SetExtent(0,511,0,511,0,0)
+  canvas.SetDrawColor(100,100,0)
+  canvas.FillBox(0,511,0,511)
+  canvas.SetDrawColor(200,0,200)
+  canvas.FillBox(32,511,100,500)
+  canvas.SetDrawColor(100,0,0)
+  canvas.FillTube(550,20,30,400,5)
+  canvas.SetDrawColor(255,255,255)
+  canvas.DrawSegment3D(10,20,0,90,510,0)
+  canvas.SetDrawColor(200,50,50)
+  canvas.DrawSegment3D(510,90,0,10,20,0)
+
+  # Check segment clipping
+  canvas.SetDrawColor(0,200,0)
+  canvas.DrawSegment(-10,30,30,-10)
+  canvas.DrawSegment(-10,481,30,521)
+  canvas.DrawSegment(481,-10,521,30)
+  canvas.DrawSegment(481,521,521,481)
+
+  # Check Filling a triangle
+  canvas.SetDrawColor(20,200,200)
+  canvas.FillTriangle(-100,100,190,150,40,300)
+
+  # Check drawing a circle
+  canvas.SetDrawColor(250,250,10)
+  canvas.DrawCircle(350,350,200.0)
+
+  # Check drawing a point
+  canvas.SetDrawColor(250,250,250)
+  canvas.DrawPoint(350,350)
+  canvas.DrawPoint(350,550)
+
+  # Test filling functionality
+  canvas.SetDrawColor(55,0,0)
+  canvas.DrawCircle(450,350,80.0)
+  canvas.SetDrawColor(100,255,100)
+  canvas.FillPixel(450,350)
+
+  # Create the GUI: two renderer widgets and a quit button
+
+  frame = TkFrame.new
+
+  widget = VtkTkImageViewerWidget.new(frame,'width'=>512,'height'=>512,'double'=>1)
+  viewer = widget.GetImageViewer
+  viewer.SetInput(canvas.GetOutput)
+  viewer.SetColorWindow(256)
+  viewer.SetColorLevel(127.5)
+
+  button = TkButton.new(frame){
+    text "Quit"
+    command { exit }
+  }
+
+  widget.pack('side'=>'top','padx'=>3,'pady'=>3,'fill'=>'both','expand'=>true)
+  frame.pack('fill'=>'both','expand'=>true)
+  button.pack('fill'=>'x')
+
+  frame.mainloop
+
+end

data/lib/VTK/tk/vtkTkImageViewerWidget.rb.rule

@@ -0,0 +1 @@
+# generated from CMake

data/lib/VTK/tk/vtkTkPhotoImage.rb

@@ -0,0 +1,28 @@
+=begin
+A subclass of Tkinter.PhotoImage that connects a
+vtkImageData to a photo widget.
+=end
+
+require 'tk'
+require 'vtk'
+require 'vtk/tk/vtkLoadRubyTkWidgets'
+
+class Vtk::TkPhotoImage < TkPhotoImage
+=begin
+    A subclass of PhotoImage with helper functions
+    A subend
+    for displaying vtkImageData
+=end
+  def initialize( kw={} )
+    # Caller the superclass
+    super( kw )
+    Vtk.LoadRubyTkWidgets
+  end
+  def PutImageSlice ( image, z, options={} )
+    default_options = { 'orientation'=>'transverse', 'window'=>256, 'level'=>128 }
+    default_options.update( options )
+    options = default_options
+    t = "_"+image.GetAddressAsString('vtkImageData')[5..-1]+"_"+image.GetClassName
+    Tk.tk_call("vtkImageDataToTkPhoto", t, @path, "%d"%z, options['orientation'], "%d"%options['window'], "%d"%options['level'])
+  end
+end

data/lib/VTK/tk/vtkTkPhotoImage.rb.rule

@@ -0,0 +1 @@
+# generated from CMake

data/lib/VTK/tk/vtkTkRenderWidget.rb

@@ -0,0 +1,486 @@
+=begin
+A simple vtkTkRenderWidget for Tk.
+
+
+A few important notes:
+
+This class is meant to be used as a base-class widget for
+doing VTK rendering in Ruby
+
+In VTK (and C++) there is a very important distinction between
+public ivars (attributes in rubyspeak), protected ivars, &&
+private ivars.  When you write a ruby class that you want
+to 'look && feel' like a VTK class, you should follow these rules.
+
+1) Attributes should never be public.  Attributes should always be
+   either protected (prefixed with a single underscore) || private
+   (prefixed with a double underscore).  You can provide access to
+   attributes through public Set/Get methods (same as VTK).
+
+2) Use a single underscore to denote a protected attribute, e.g.
+   @RenderWindow is protected (can be accessed from this
+   class || a derived class).
+
+3) Use a double underscore to denote a private attribute, e.g.
+   @InExpose can not be accessed outside of this class.
+
+All attributes should be 'declared' in the __init__ function
+i.e. set to some initial value.  Don't forget that 'nil' means
+'NULL' - the ruby/vtk wrappers guarantee their equivalence.
+=end
+
+require 'tk'
+require 'vtk'
+require 'vtk/tk/vtkLoadRubyTkWidgets'
+
+
+class Vtk::TkRenderWidget < TkWindow
+=begin
+    A vtkTkRenderWidget for Ruby
+
+    Use GetRenderWindow to get the vtkRenderWindow.
+
+    Create with the keyword stereo=1 in order to generate a
+    stereo-capable window.
+
+    Create with the keyword focus_on_enter=1 to enable
+    focus-follows-mouse.  The default is for a click-to-focus mode.
+=end
+  TkCommandNames = ['vtkTkRenderWidget'.freeze].freeze
+
+  def initialize( master, kw={} )
+=begin
+        Constructor.
+
+        Keyword arguments:
+
+          rw -- Use passed render window instead of creating a new one.
+
+          stereo -- If True, generate a stereo-capable window.
+          Defaults to False.
+
+          focus_on_enter -- If True, use a focus-follows-mouse mode.
+          Defaults to False where the widget will use a click-to-focus
+          mode.
+=end
+    # load the necessary extensions into tk
+    Vtk.LoadRubyTkWidgets
+
+    _symbolkey2str(kw)
+
+    if kw['rw']
+      renderWindow = kw['rw']
+    else
+      renderWindow = Vtk::RenderWindow.new
+    end
+
+    if kw['stereo']
+      renderWindow.StereoCapableWindowOn
+      kw.delete('stereo')
+    end
+
+    # check if focus should follow mouse
+    if kw['focus_on_enter']
+      @FocusOnEnter = true
+      kw.delete('focus_on_enter')
+    else
+      @FocusOnEnter = false
+    end
+
+    kw['rw'] = renderWindow.GetAddressAsString("vtkRenderWindow")
+    kw['widgetname'] = 'vtkTkRenderWidget'
+    super(master, kw)
+    renderWindow.UnRegister(nil)
+
+    @CurrentRenderer = nil
+    @CurrentCamera = nil
+    @CurrentZoom = 1.0
+    @CurrentLight = nil
+
+    @ViewportCenterX = 0
+    @ViewportCenterY = 0
+
+    @Picker = Vtk::CellPicker.new
+    @PickedAssembly = nil
+    @PickedProperty = Vtk::Property.new
+    @PickedProperty.SetColor(1,0,0)
+    @PrePickedProperty = nil
+
+    @OldFocus = nil
+
+    # used by the LOD actors
+    @DesiredUpdateRate = 15
+    @StillUpdateRate = 0.0001
+
+    # these record the previous mouse position
+    @LastX = 0
+    @LastY = 0
+
+    # private attributes
+    @InExpose = false
+
+    # create the Tk bindings
+    self.BindTkRenderWidget
+  end
+
+  def BindTkRenderWidget
+=begin
+        Bind some default actions.
+=end
+    self.bind("ButtonPress"){|e,s| s||s=self; s.StartMotion(e.x,e.y) }
+    self.bind("ButtonRelease"){|e,s| s||s=self; s.EndMotion(e.x,e.y) }
+    self.bind("B1-Motion"){|e,s| s||s=self; s.Rotate(e.x,e.y) }
+    self.bind("B2-Motion"){|e,s| s||s=self; s.Pan(e.x,e.y) }
+    self.bind("B3-Motion"){|e,s| s||s=self; s.Zoom(e.x,e.y) }
+    self.bind("Shift-B1-Motion"){|e,s| s||s=self; s.Pan(e.x,e.y) }
+    self.bind("KeyPress-r"){|e,s| s||s=self; s.Reset(e.x,e.y) }
+    self.bind("KeyPress-u"){|e,s| s||s=self; s.deiconify }
+    self.bind("KeyPress-w"){|e,s| s||s=self; s.Wireframe }
+    self.bind("KeyPress-s"){|e,s| s||s=self; s.Surface }
+    self.bind("KeyPress-p"){|e,s| s||s=self; s.PickActor(e.x,e.y) }
+    if @FocusOnEnter
+      self.bind("Enter"){|e,s| s||s=self; s.Enter(e.x,e.y) }
+      self.bind("Leave"){|e,s| s||s=self; s.Leave(e.x,e.y) }
+    else
+      self.bind("ButtonPress"){|e,s| s||s=self; s.Enter(e.x,e.y) }
+      self.bind("Expose"){|e,s| s||s=self; s.Expose }
+    end
+  end
+
+  def GetZoomFactor
+    return @CurrentZoom
+  end
+
+  def SetDesiredUpdateRate(rate)
+=begin
+        Mirrors the method with the same name in
+        vtkRenderWindowInteractor.
+=end
+    @DesiredUpdateRate = rate
+  end
+
+  def GetDesiredUpdateRate
+=begin
+        Mirrors the method with the same name in
+        vtkRenderWindowInteractor.
+=end
+    return @DesiredUpdateRate 
+  end
+
+  def SetStillUpdateRate(rate)
+=begin
+        Mirrors the method with the same name in
+        vtkRenderWindowInteractor.
+=end
+    @StillUpdateRate = rate
+  end
+
+  def GetStillUpdateRate
+=begin
+       Mirrors the method with the same name in
+        vtkRenderWindowInteractor.
+=end
+    return @StillUpdateRate 
+  end
+
+  def GetRenderWindow
+    addr = Tk.tk_call(self, 'GetRenderWindow')[5..-1]
+    renderWindow = Vtk::RenderWindow.new('_%s_vtkRenderWindow_p' % addr)
+    renderWindow.UnRegister(nil)
+    return renderWindow
+  end
+
+  def GetPicker
+    return @Picker
+  end
+
+  def Expose
+    if ! @InExpose
+      @InExpose = true
+      self.update
+      self.GetRenderWindow.Render
+      @InExpose = false
+    end
+  end
+
+  def Render
+    if (@CurrentLight)
+      light = @CurrentLight
+      light.SetPosition(@CurrentCamera.GetPosition)
+      light.SetFocalPoint(@CurrentCamera.GetFocalPoint)
+    end
+
+    self.GetRenderWindow.Render
+  end
+
+  def UpdateRenderer(x,y)
+=begin
+        UpdateRenderer will identify the renderer under the mouse && set
+        up _CurrentRenderer, _CurrentCamera, && _CurrentLight.
+=end
+    windowX = self.winfo_width
+    windowY = self.winfo_height
+
+    renderers = self.GetRenderWindow.GetRenderers
+    numRenderers = renderers.GetNumberOfItems
+
+    @CurrentRenderer = nil
+    renderers.InitTraversal
+    for i in 0...numRenderers
+      renderer = renderers.GetNextItem
+      vx,vy = [0,0]
+      if (windowX > 1)
+        vx = x.to_f/(windowX-1)
+      end
+      if (windowY > 1)
+        vy = (windowY-y.to_f-1)/(windowY-1)
+      end
+      vpxmin,vpymin,vpxmax,vpymax = renderer.GetViewport
+
+      if (vx >= vpxmin && vx <= vpxmax && vy >= vpymin && vy <= vpymax)
+        @CurrentRenderer = renderer
+        @ViewportCenterX = windowX.to_f*(vpxmax-vpxmin)/2.0 +vpxmin
+        @ViewportCenterY = windowY.to_f*(vpymax-vpymin)/2.0 +vpymin
+        @CurrentCamera = @CurrentRenderer.GetActiveCamera
+        lights = @CurrentRenderer.GetLights
+        lights.InitTraversal
+        @CurrentLight = lights.GetNextItem
+        break
+      end
+    end
+
+    @LastX = x
+    @LastY = y
+  end
+
+  def GetCurrentRenderer
+    return @CurrentRenderer
+  end
+
+  def Enter(x,y)
+    @OldFocus = self.focus
+    self.focus
+    self.StartMotion(x, y)
+  end
+
+  def Leave(x,y)
+    if (@OldFocus != nil)
+      @OldFocus.focus
+    end
+  end
+
+  def StartMotion(x,y)
+    self.GetRenderWindow.SetDesiredUpdateRate(@DesiredUpdateRate)
+    self.UpdateRenderer(x,y)
+  end
+
+  def EndMotion(x,y)
+    self.GetRenderWindow.SetDesiredUpdateRate(@StillUpdateRate)
+    if @CurrentRenderer
+      self.Render
+    end
+  end
+
+  def Rotate(x,y)
+    if @CurrentRenderer
+
+      @CurrentCamera.Azimuth(@LastX - x)
+      @CurrentCamera.Elevation(y - @LastY)
+      @CurrentCamera.OrthogonalizeViewUp
+
+      @LastX = x
+      @LastY = y
+
+      @CurrentRenderer.ResetCameraClippingRange
+      self.Render
+    end
+  end
+
+  def Pan(x,y)
+    if @CurrentRenderer
+
+      renderer = @CurrentRenderer
+      camera = @CurrentCamera
+      pPoint0,pPoint1,pPoint2 = camera.GetPosition
+      fPoint0,fPoint1,fPoint2 = camera.GetFocalPoint
+
+      if (camera.GetParallelProjection)
+        renderer.SetWorldPoint(fPoint0,fPoint1,fPoint2,1.0)
+        renderer.WorldToDisplay
+        fx,fy,fz = renderer.GetDisplayPoint
+        renderer.SetDisplayPoint(fx-x+@LastX,
+                                 fy+y-@LastY,
+                                 fz)
+        renderer.DisplayToWorld
+        fx,fy,fz,fw = renderer.GetWorldPoint
+        camera.SetFocalPoint(fx,fy,fz)
+
+        renderer.SetWorldPoint(pPoint0,pPoint1,pPoint2,1.0)
+        renderer.WorldToDisplay
+        fx,fy,fz = renderer.GetDisplayPoint
+        renderer.SetDisplayPoint(fx-x+@LastX,
+                                 fy+y-@LastY,
+                                 fz)
+        renderer.DisplayToWorld
+        fx,fy,fz,fw = renderer.GetWorldPoint
+        camera.SetPosition(fx,fy,fz)
+
+      else
+        (fPoint0,fPoint1,fPoint2) = camera.GetFocalPoint
+        # Specify a point location in world coordinates
+        renderer.SetWorldPoint(fPoint0,fPoint1,fPoint2,1.0)
+        renderer.WorldToDisplay
+        # Convert world point coordinates to display coordinates
+        dPoint = renderer.GetDisplayPoint
+        focalDepth = dPoint[2]
+
+        aPoint0 = @ViewportCenterX + (x - @LastX)
+        aPoint1 = @ViewportCenterY - (y - @LastY)
+
+        renderer.SetDisplayPoint(aPoint0,aPoint1,focalDepth)
+        renderer.DisplayToWorld
+
+        (rPoint0,rPoint1,rPoint2,rPoint3) = renderer.GetWorldPoint
+        if (rPoint3 != 0.0)
+          rPoint0 = rPoint0/rPoint3
+          rPoint1 = rPoint1/rPoint3
+          rPoint2 = rPoint2/rPoint3
+        end
+
+        camera.SetFocalPoint((fPoint0 - rPoint0) + fPoint0, 
+                             (fPoint1 - rPoint1) + fPoint1,
+                             (fPoint2 - rPoint2) + fPoint2) 
+
+        camera.SetPosition((fPoint0 - rPoint0) + pPoint0, 
+                           (fPoint1 - rPoint1) + pPoint1,
+                           (fPoint2 - rPoint2) + pPoint2)
+      end
+
+      @LastX = x
+      @LastY = y
+
+      self.Render
+    end
+  end
+
+  def Zoom(x,y)
+    if @CurrentRenderer
+
+      renderer = @CurrentRenderer
+      camera = @CurrentCamera
+
+      zoomFactor = 1.02**(0.5*(@LastY - y))
+      @CurrentZoom = @CurrentZoom * zoomFactor
+
+      if camera.GetParallelProjection != 0
+        parallelScale = camera.GetParallelScale/zoomFactor
+        camera.SetParallelScale(parallelScale)
+      else
+        camera.Dolly(zoomFactor)
+        renderer.ResetCameraClippingRange
+      end
+
+      @LastX = x
+      @LastY = y
+
+      self.Render
+    end
+  end
+
+  def Reset(x,y)
+    if @CurrentRenderer
+      @CurrentRenderer.ResetCamera
+    end
+
+    self.Render
+  end
+
+  def Wireframe
+    actors = @CurrentRenderer.GetActors
+    numActors = actors.GetNumberOfItems
+    actors.InitTraversal
+    for i in 0...numActors
+      actor = actors.GetNextItem
+      actor.GetProperty.SetRepresentationToWireframe
+    end
+
+    self.Render
+  end
+
+  def Surface
+    actors = @CurrentRenderer.GetActors
+    numActors = actors.GetNumberOfItems
+    actors.InitTraversal
+    for i in 0...numActors
+      actor = actors.GetNextItem
+      actor.GetProperty.SetRepresentationToSurface
+    end
+
+    self.Render
+  end
+
+  def PickActor(x,y)
+    if @CurrentRenderer
+
+      renderer = @CurrentRenderer
+      picker = @Picker
+      windowY = self.winfo_height
+      picker.Pick(x,(windowY - y - 1),0.0,renderer)
+      assembly = picker.GetAssembly
+
+      if (@PickedAssembly != nil && @PrePickedProperty != nil)
+        @PickedAssembly.SetProperty(@PrePickedProperty)
+        # release hold of the property
+        @PrePickedProperty.UnRegister(@PrePickedProperty)
+        @PrePickedProperty = nil
+      end
+
+      if (assembly != nil)
+        @PickedAssembly = assembly
+        @PrePickedProperty = @PickedAssembly.GetProperty
+        # hold onto the property
+        @PrePickedProperty.Register(@PrePickedProperty)
+        @PickedAssembly.SetProperty(@PickedProperty)
+      end
+
+      self.Render
+    end
+  end
+
+end
+
+#----------------------------------------------------------------------------  
+def vtkRenderWidgetConeExample
+=begin
+    Like it says, just a simple example
+=end
+    # create root window
+    root = TkRoot.new
+
+    # create vtkTkRenderWidget
+    pane = Vtk::TkRenderWidget.new(root,'width'=>300,'height'=>300)
+
+    ren = Vtk::Renderer.new
+    pane.GetRenderWindow.AddRenderer(ren)
+
+    cone = Vtk::ConeSource.new
+    cone.SetResolution(8)
+
+    coneMapper = Vtk::PolyDataMapper.new
+    coneMapper.SetInput(cone.GetOutput)
+
+    coneActor = Vtk::Actor.new
+    coneActor.SetMapper(coneMapper)
+
+    ren.AddActor(coneActor)
+
+    # pack the pane into the tk root
+    pane.pack
+
+    # start the tk mainloop
+    Tk.mainloop
+end
+
+if $0 == __FILE__
+    vtkRenderWidgetConeExample
+end