示例#1
0
class DemoChooser:

    def __init__(self):

        # Create the Renderer, RenderWindow, etc. and set the Picker.
        self.ren = vtk.vtkRenderer()
        self.renwin = vtk.vtkRenderWindow()
        self.renwin.AddRenderer(self.ren)
        self.ren.SetViewport(0,0,1,1)
        self.iren = vtk.vtkRenderWindowInteractor()
        self.iren.SetRenderWindow(self.renwin)
        self.propPicker = vtk.vtkPropPicker()
        self.iren.SetPicker(self.propPicker)
        
        # blue sphere, will show four spheres when hovered on
        self.blueSphere = Sphere((0,0,0), 3.0, (0,0,1))
        self.blueSphere.sphereActor.VisibilityOn()
        self.greenSphere = Sphere((4,4,0), 1.0, (0,1,0))
        self.redSphere = Sphere((4,-4,0), 1.0, (1,0,0))
        self.yellowSphere = Sphere((-4,4,0), 1.0, (1,1,0))
        self.purpleSphere = Sphere((-4,-4,0), 1.0, (1,0,1))
        
        # Create text mappers and 2d actors to display finger position.
        self.fingerMarker1 = Marker("(1)")
        self.fingerMarker2 = Marker("(2)")
        self.fingerMarker3 = Marker("(3)")

        # Add the actors to the renderer, set the background and size
        self.ren.AddActor(self.blueSphere.sphereActor)
        self.ren.AddActor(self.greenSphere.sphereActor)
        self.ren.AddActor(self.redSphere.sphereActor)
        self.ren.AddActor(self.yellowSphere.sphereActor)
        self.ren.AddActor(self.purpleSphere.sphereActor)
        self.ren.AddActor2D(self.fingerMarker1.textActor)
        self.ren.AddActor2D(self.fingerMarker2.textActor)
        self.propPicker.AddObserver("EndPickEvent", self.Pick)
        self.ren.SetBackground(0, 0, 0)
        self.renwin.SetSize(680, 460)
        #self.renwin.FullScreenOn()
        
        '''
        TUIO STUFF
        '''
        self.tracking = tuio.Tracking('')
        self.tracker = CursorTracker(2)
        self.pickedDemo = 0
        
    def Start(self):
        self.renwin.Render()
        self.RunTUIO()
        
    def RunTUIO(self):
        while (self.pickedDemo == 0) :
            while self.tracking.update():
                # read the socket empty
                pass

            self.tracker.update(self.tracking.cursors())
            self.CheckGesture()

    def CheckGesture(self):
        self.NONE = 0 
        self.ROTATE = 1 
        self.PICK = 2
        
        if self.tracker.fingers_detected() == self.NONE:
            print "No Fingers Detected"
            self.fingerMarker1.textActor.VisibilityOff()
            self.fingerMarker2.textActor.VisibilityOff()
            self.renwin.Render()
        
        elif self.tracker.fingers_detected() == self.ROTATE:
            print "Rotating"
            fingerID1 = self.tracker._seen.keys()[0]
            fingerPrevCoords = self.tracker._prevCoords[fingerID1]
            fingerCurrCoords = self.tracker._coords[fingerID1]
            
            # show finger marker
            self.fingerMarker1.textActor.SetPosition(fingerCurrCoords[:2])
            self.fingerMarker1.textActor.VisibilityOn()
            
            # hide all other markers
            self.fingerMarker2.textActor.VisibilityOff()
            
            self.Rotate(self.ren, self.renwin, self.ren.GetActiveCamera(), fingerPrevCoords[0]/10, fingerPrevCoords[1]/10, fingerCurrCoords[0]/10, fingerCurrCoords[1]/10)

        elif self.tracker.fingers_detected() == self.PICK:
            print "Picking Mode"
            fingerID1 = self.tracker._seen.keys()[0]
            fingerID2 = self.tracker._seen.keys()[1]
                        
            # show finger markers
            self.fingerMarker1.textActor.SetPosition(self.tracker._coords[fingerID1][:2])
            self.fingerMarker2.textActor.SetPosition(self.tracker._coords[fingerID2][:2])
            self.fingerMarker2.textActor.VisibilityOn()  
            self.propPicker.PickProp(self.tracker._coords[fingerID2][0], self.tracker._coords[fingerID2][1], self.ren)
        
    def Rotate(self, ren, renwin, camera, startx, starty, curx, cury):  
        camera.Azimuth(startx-curx)
        camera.Elevation(starty-cury)
        camera.OrthogonalizeViewUp()
        renwin.Render()
        
    def Pick(self, object, event):        
        pickedSphere = self.propPicker.GetActor()
        if pickedSphere == None:            
            self.Wireframe(self.ren, self.renwin)
        elif pickedSphere.GetBounds() == self.blueSphere.sphereActor.GetBounds():
            print 'you picked blue'
            pickedSphere.GetProperty().SetRepresentationToSurface()
            self.blueSphere.sphereActor.VisibilityOn()
            self.greenSphere.sphereActor.VisibilityOn()
            self.redSphere.sphereActor.VisibilityOn()
            self.yellowSphere.sphereActor.VisibilityOn()
            self.purpleSphere.sphereActor.VisibilityOn()
        elif pickedSphere.GetBounds() == self.greenSphere.sphereActor.GetBounds():
            print 'you picked green'
            pickedSphere.GetProperty().SetRepresentationToSurface()
            self.pickedDemo = 1
        elif pickedSphere.GetBounds() == self.redSphere.sphereActor.GetBounds():
            print 'you picked red'
            pickedSphere.GetProperty().SetRepresentationToSurface()
            self.pickedDemo = 2
        elif pickedSphere.GetBounds() == self.yellowSphere.sphereActor.GetBounds():
            print 'you picked yellow'
            pickedSphere.GetProperty().SetRepresentationToSurface()
            self.pickedDemo = 3
        elif pickedSphere.GetBounds() == self.purpleSphere.sphereActor.GetBounds():
            print 'you picked purple'
            pickedSphere.GetProperty().SetRepresentationToSurface()
            self.pickedDemo = 4
        self.iren.Render()
        
    def Wireframe(self, ren, renwin):
        actors = ren.GetActors()
        actors.InitTraversal()
        actor = actors.GetNextItem()
        while actor:
            actor.GetProperty().SetRepresentationToWireframe()
            actor = actors.GetNextItem()
        renwin.Render()
        
    def GetPickedDemo(self):
        return self.pickedDemo
        
    def Kill(self):
        print "Stopping DemoChooser TUIO tracking"
        self.tracking.stop()
        print "DemoChooser.py Terminated"
        self.iren.GetRenderWindow().Finalize()
示例#2
0
class MultiTouchTest:

    def __init__(self):

        # Create the Renderer, RenderWindow, etc. and set the Picker.
        self.ren = vtk.vtkRenderer()
        self.renwin = vtk.vtkRenderWindow()
        self.renwin.AddRenderer(self.ren)
        self.ren.SetViewport(0,0,1,1)
        self.iren = vtk.vtkRenderWindowInteractor()
        self.iren.SetRenderWindow(self.renwin)
        
        # Create text mappers and 2d actors to display finger position.
        self.fingerMarker1 = Marker("(1)")
        self.fingerMarker2 = Marker("(2)")
        self.fingerMarker3 = Marker("(3)")
        self.fingerMarker4 = Marker("(4)")
        self.fingerMarker5 = Marker("(5)")

        # Add the actors to the renderer, set the background and size
        self.ren.AddActor2D(self.fingerMarker1.textActor)
        self.ren.AddActor2D(self.fingerMarker2.textActor)
        self.ren.AddActor2D(self.fingerMarker3.textActor)
        self.ren.AddActor2D(self.fingerMarker4.textActor)
        self.ren.AddActor2D(self.fingerMarker5.textActor)
        self.ren.SetBackground(0, 0, 0)
        self.renwin.SetSize(680, 460)
        #self.renwin.FullScreenOn()
        
        '''
        TUIO STUFF
        '''
        self.tracking = tuio.Tracking('')
        self.tracker = CursorTracker(8)
        self.terminate = False
        
    def Start(self):
        self.renwin.Render()
        self.RunTUIO()
        
    def RunTUIO(self):
        while not self.terminate :
            while self.tracking.update():
                # read the socket empty
                pass

            self.tracker.update(self.tracking.cursors())
            self.CheckGesture()

    def CheckGesture(self):
        
        if self.tracker.fingers_detected() == 0:
            print "No Fingers Detected"
            self.fingerMarker1.textActor.VisibilityOff()
            self.fingerMarker2.textActor.VisibilityOff()
            self.fingerMarker3.textActor.VisibilityOff()
            self.fingerMarker4.textActor.VisibilityOff()
            self.fingerMarker5.textActor.VisibilityOff()
            self.renwin.Render()
        
        elif self.tracker.fingers_detected() == 1:
            print "1 Finger Detected"
            fingerID1 = self.tracker._seen.keys()[0]
            finger1CurrCoords = self.tracker._coords[fingerID1]
            
            # show finger marker
            self.fingerMarker1.textActor.SetPosition(finger1CurrCoords[:2])
            self.fingerMarker1.textActor.VisibilityOn()
            
            # hide all other markers
            self.fingerMarker2.textActor.VisibilityOff()
            self.fingerMarker3.textActor.VisibilityOff()
            self.fingerMarker4.textActor.VisibilityOff()
            self.fingerMarker5.textActor.VisibilityOff()
            self.renwin.Render()
                    
        elif self.tracker.fingers_detected() == 2:
            print "2 Fingers Detected"
            fingerID1 = self.tracker._seen.keys()[0]
            fingerID2 = self.tracker._seen.keys()[1]
            finger1CurrCoords = self.tracker._coords[fingerID1]
            finger2CurrCoords = self.tracker._coords[fingerID2]
            
            # show finger marker
            self.fingerMarker1.textActor.SetPosition(finger1CurrCoords[:2])
            self.fingerMarker2.textActor.SetPosition(finger2CurrCoords[:2])
            self.fingerMarker1.textActor.VisibilityOn()
            self.fingerMarker2.textActor.VisibilityOn()
            
            # hide all other markers
            self.fingerMarker3.textActor.VisibilityOff()
            self.fingerMarker4.textActor.VisibilityOff()
            self.fingerMarker5.textActor.VisibilityOff()
            self.renwin.Render()
            
        elif self.tracker.fingers_detected() == 3:
            print "3 Fingers Detected"
            fingerID1 = self.tracker._seen.keys()[0]
            fingerID2 = self.tracker._seen.keys()[1]
            fingerID3 = self.tracker._seen.keys()[2]
            finger1CurrCoords = self.tracker._coords[fingerID1]
            finger2CurrCoords = self.tracker._coords[fingerID2]
            finger3CurrCoords = self.tracker._coords[fingerID3]
            
            # show finger marker
            self.fingerMarker1.textActor.SetPosition(finger1CurrCoords[:2])
            self.fingerMarker2.textActor.SetPosition(finger2CurrCoords[:2])
            self.fingerMarker3.textActor.SetPosition(finger3CurrCoords[:2])
            self.fingerMarker1.textActor.VisibilityOn()
            self.fingerMarker2.textActor.VisibilityOn()
            self.fingerMarker3.textActor.VisibilityOn()
            
            # hide all other markers
            self.fingerMarker4.textActor.VisibilityOff()
            self.fingerMarker5.textActor.VisibilityOff()
            self.renwin.Render()
            
        elif self.tracker.fingers_detected() == 4:
            print "4 Fingers Detected"
            fingerID1 = self.tracker._seen.keys()[0]
            fingerID2 = self.tracker._seen.keys()[1]
            fingerID3 = self.tracker._seen.keys()[2]
            fingerID4 = self.tracker._seen.keys()[3]
            finger1CurrCoords = self.tracker._coords[fingerID1]
            finger2CurrCoords = self.tracker._coords[fingerID2]
            finger3CurrCoords = self.tracker._coords[fingerID3]
            finger4CurrCoords = self.tracker._coords[fingerID4]
            
            # show finger marker
            self.fingerMarker1.textActor.SetPosition(finger1CurrCoords[:2])
            self.fingerMarker2.textActor.SetPosition(finger2CurrCoords[:2])
            self.fingerMarker3.textActor.SetPosition(finger3CurrCoords[:2])
            self.fingerMarker4.textActor.SetPosition(finger4CurrCoords[:2])
            self.fingerMarker1.textActor.VisibilityOn()
            self.fingerMarker2.textActor.VisibilityOn()
            self.fingerMarker3.textActor.VisibilityOn()
            self.fingerMarker4.textActor.VisibilityOn()
            
            # hide all other markers
            self.fingerMarker5.textActor.VisibilityOff()
            self.renwin.Render()
            
        elif self.tracker.fingers_detected() == 5:
            print "5 Fingers Detected"
            fingerID1 = self.tracker._seen.keys()[0]
            fingerID2 = self.tracker._seen.keys()[1]
            fingerID3 = self.tracker._seen.keys()[2]
            fingerID4 = self.tracker._seen.keys()[3]
            fingerID5 = self.tracker._seen.keys()[4]
            finger1CurrCoords = self.tracker._coords[fingerID1]
            finger2CurrCoords = self.tracker._coords[fingerID2]
            finger3CurrCoords = self.tracker._coords[fingerID3]
            finger4CurrCoords = self.tracker._coords[fingerID4]
            finger5CurrCoords = self.tracker._coords[fingerID5]
            
            # show finger marker
            self.fingerMarker1.textActor.SetPosition(finger1CurrCoords[:2])
            self.fingerMarker2.textActor.SetPosition(finger2CurrCoords[:2])
            self.fingerMarker3.textActor.SetPosition(finger3CurrCoords[:2])
            self.fingerMarker4.textActor.SetPosition(finger4CurrCoords[:2])
            self.fingerMarker5.textActor.SetPosition(finger5CurrCoords[:2])
            self.fingerMarker1.textActor.VisibilityOn()
            self.fingerMarker2.textActor.VisibilityOn()
            self.fingerMarker3.textActor.VisibilityOn()
            self.fingerMarker4.textActor.VisibilityOn()
            self.fingerMarker5.textActor.VisibilityOn()
            self.renwin.Render()
            
        elif self.tracker.fingers_detected() == 8:
            self.terminate = True
        
    def Kill(self):
        print "Stopping TestDemo TUIO tracking"
        self.tracking.stop()
        print "TestDemo.py Terminated"
        self.iren.GetRenderWindow().Finalize()
示例#3
0
class SingleSlice:
    def __init__(self):

        # Create the renderer, the render window, and the interactor. The
        # renderer draws into the render window, the interactor enables mouse-
        # and keyboard-based interaction with the scene.
        self.ren = vtk.vtkRenderer()
        self.renwin = vtk.vtkRenderWindow()
        self.renwin.AddRenderer(self.ren)
        self.iren = vtk.vtkRenderWindowInteractor()
        self.iren.SetRenderWindow(self.renwin)
        
        # Create text mappers and 2d actors to display finger position.
        self.fingerMarker1 = Marker("(1)")
        self.fingerMarker2 = Marker("(2)")
        self.fingerMarker3 = Marker("(3)")

        # The following reader is used to read a series of 2D slices (images)
        # that compose the volume. The slice dimensions are set, and the
        # pixel spacing. The data Endianness must also be specified. The reader
        # usese the FilePrefix in combination with the slice number to construct
        # filenames using the format FilePrefix.%d. (In this case the FilePrefix
        # is the root name of the file: quarter.)
        self.v16 = vtk.vtkVolume16Reader()
        self.v16.SetDataDimensions(64, 64)
        self.v16.SetDataByteOrderToLittleEndian()
        self.v16.SetFilePrefix("/Users/eddie/Programming/Python/python-vtk-tuio/headsq/Data_headsq_quarter")
        self.v16.SetImageRange(1, 93)
        self.v16.SetDataSpacing(3.2, 3.2, 1.5)

        # An isosurface, or contour value of 500 is known to correspond to the
        # skin of the patient. Once generated, a vtkPolyDataNormals filter is
        # is used to create normals for smooth surface shading during rendering.
        # The triangle stripper is used to create triangle strips from the
        # isosurface these render much faster on may systems.
        self.skinExtractor = vtk.vtkContourFilter()
        self.skinExtractor.SetInputConnection(self.v16.GetOutputPort())
        self.skinExtractor.SetValue(0, 500)
        self.skinNormals = vtk.vtkPolyDataNormals()
        self.skinNormals.SetInputConnection(self.skinExtractor.GetOutputPort())
        self.skinNormals.SetFeatureAngle(60.0)
        self.skinStripper = vtk.vtkStripper()
        self.skinStripper.SetInputConnection(self.skinNormals.GetOutputPort())
        self.skinMapper = vtk.vtkPolyDataMapper()
        self.skinMapper.SetInputConnection(self.skinStripper.GetOutputPort())
        self.skinMapper.ScalarVisibilityOff()
        self.skin = vtk.vtkActor()
        self.skin.SetMapper(self.skinMapper)
        self.skin.GetProperty().SetDiffuseColor(1, .49, .25)
        self.skin.GetProperty().SetSpecular(.3)
        self.skin.GetProperty().SetSpecularPower(20)

        # An isosurface, or contour value of 1150 is known to correspond to the
        # skin of the patient. Once generated, a vtkPolyDataNormals filter is
        # is used to create normals for smooth surface shading during rendering.
        # The triangle stripper is used to create triangle strips from the
        # isosurface these render much faster on may systems.
        self.boneExtractor = vtk.vtkContourFilter()
        self.boneExtractor.SetInputConnection(self.v16.GetOutputPort())
        self.boneExtractor.SetValue(0, 1150)
        self.boneNormals = vtk.vtkPolyDataNormals()
        self.boneNormals.SetInputConnection(self.boneExtractor.GetOutputPort())
        self.boneNormals.SetFeatureAngle(60.0)
        self.boneStripper = vtk.vtkStripper()
        self.boneStripper.SetInputConnection(self.boneNormals.GetOutputPort())
        self.boneMapper = vtk.vtkPolyDataMapper()
        self.boneMapper.SetInputConnection(self.boneStripper.GetOutputPort())
        self.boneMapper.ScalarVisibilityOff()
        self.bone = vtk.vtkActor()
        self.bone.SetMapper(self.boneMapper)
        self.bone.GetProperty().SetDiffuseColor(1, 1, .9412)

        # An outline provides context around the data.
        self.outlineData = vtk.vtkOutlineFilter()
        self.outlineData.SetInputConnection(self.v16.GetOutputPort())
        self.mapOutline = vtk.vtkPolyDataMapper()
        self.mapOutline.SetInputConnection(self.outlineData.GetOutputPort())
        self.outline = vtk.vtkActor()
        self.outline.SetMapper(self.mapOutline)
        self.outline.GetProperty().SetColor(0, 0, 0)

        # Now we are creating three orthogonal planes passing through the
        # volume. Each plane uses a different texture map and therefore has
        # diferent coloration.

        # Start by creatin a black/white lookup table.
        self.bwLut = vtk.vtkLookupTable()
        self.bwLut.SetTableRange(0, 2000)
        self.bwLut.SetSaturationRange(0, 0)
        self.bwLut.SetHueRange(0, 0)
        self.bwLut.SetValueRange(0, 1)
        self.bwLut.Build()

        # Now create a lookup table that consists of the full hue circle (from
        # HSV).
        self.hueLut = vtk.vtkLookupTable()
        self.hueLut.SetTableRange(0, 2000)
        self.hueLut.SetHueRange(0, 1)
        self.hueLut.SetSaturationRange(1, 1)
        self.hueLut.SetValueRange(1, 1)
        self.hueLut.Build()

        # Finally, create a lookup table with a single hue but having a range
        # in the saturation of the hue.
        self.satLut = vtk.vtkLookupTable()
        self.satLut.SetTableRange(0, 2000)
        self.satLut.SetHueRange(.6, .6)
        self.satLut.SetSaturationRange(0, 1)
        self.satLut.SetValueRange(1, 1)
        self.satLut.Build()

        # Create the first of the three planes. The filter vtkImageMapToColors
        # maps the data through the corresponding lookup table created above.
        # The vtkImageActor is a type of vtkProp and conveniently displays an
        # image on a single quadrilateral plane. It does this using texture
        # mapping and as a result is quite fast. (Note: the input image has to
        # be unsigned char values, which the vtkImageMapToColors produces.)
        # Note also that by specifying the DisplayExtent, the pipeline
        # requests data of this extent and the vtkImageMapToColors only
        # processes a slice of data.
        self.sagittalColors = vtk.vtkImageMapToColors()
        self.sagittalColors.SetInputConnection(self.v16.GetOutputPort())
        self.sagittalColors.SetLookupTable(self.bwLut)
        self.sagittal = vtk.vtkImageActor()
        self.sagittal.GetMapper().SetInputConnection(self.sagittalColors.GetOutputPort())
        self.sagittal.SetDisplayExtent(32, 32, 0, 63, 0, 92)

        # Create the second (axial) plane of the three planes. We use the same
        # approach as before except that the extent differs.
        self.axialColors = vtk.vtkImageMapToColors()
        self.axialColors.SetInputConnection(self.v16.GetOutputPort())
        self.axialColors.SetLookupTable(self.hueLut)
        self.axial = vtk.vtkImageActor()
        self.axial.GetMapper().SetInputConnection(self.axialColors.GetOutputPort())
        self.axial.SetDisplayExtent(0, 63, 0, 63, 46, 46)

        # Create the third (coronal) plane of the three planes. We use the same
        # approach as before except that the extent differs.
        self.coronalColors = vtk.vtkImageMapToColors()
        self.coronalColors.SetInputConnection(self.v16.GetOutputPort())
        self.coronalColors.SetLookupTable(self.satLut)
        self.coronal = vtk.vtkImageActor()
        self.coronal.GetMapper().SetInputConnection(self.coronalColors.GetOutputPort())
        self.coronal.SetDisplayExtent(0, 63, 32, 32, 0, 92)

        # move camera to view sagital slice 
        self.aCamera = vtk.vtkCamera()
        self.aCamera.SetPosition(1,0,0) # view from positive x axis
        self.aCamera.SetViewUp(0,0,1) # z axis
        self.aCamera.Roll(180) # rotate 180 degrees

        # Actors are added to the renderer.
        #self.ren.AddActor(self.outline)
        self.ren.AddActor(self.sagittal)
        #self.ren.AddActor(self.axial)
        #self.ren.AddActor(self.coronal)
        #self.ren.AddActor(self.skin)
        #self.ren.AddActor(self.bone)
        self.ren.AddActor2D(self.fingerMarker1.textActor)
        self.ren.AddActor2D(self.fingerMarker2.textActor)
        self.ren.AddActor2D(self.fingerMarker3.textActor)

        # Turn off bone for this example.
        self.bone.VisibilityOff()

        # Set skin to semi-transparent.
        self.skin.GetProperty().SetOpacity(0.5)

        # An initial camera view is created.  The Dolly() method moves
        # the camera towards the FocalPoint, thereby enlarging the image.
        self.ren.SetActiveCamera(self.aCamera)
        self.ren.ResetCamera()
        self.aCamera.Dolly(1.5)

        # Set a background color for the renderer and set the size of the
        # render window (expressed in pixels).
        self.ren.SetBackground(1, 1, 1)
        self.renwin.SetSize(640, 480)
        #self.renwin.FullScreenOn()

        # Note that when camera movement occurs (as it does in the Dolly()
        # method), the clipping planes often need adjusting. Clipping planes
        # consist of two planes: near and far along the view direction. The
        # near plane clips out objects in front of the plane the far plane
        # clips out objects behind the plane. This way only what is drawn
        # between the planes is actually rendered.
        self.ren.ResetCameraClippingRange()
                
        '''
        TUIO STUFF
        '''
        self.tracking = tuio.Tracking('')
        self.tracker = CursorTracker(4)
        self.terminate = False

    def Start(self):
        self.renwin.Render()
        self.RunTUIO()
        
    def RunTUIO(self):
        while not self.terminate :
            while self.tracking.update():
                # read the socket empty
                pass

            self.tracker.update(self.tracking.cursors())
            self.CheckGesture()
            
    def CheckGesture(self):
        self.NONE = 0 
        self.ROTATE = 1 
        self.ZOOM = 2
        self.PAN = 3
        self.TERMINATE = 4
        
        if self.tracker.fingers_detected() == self.NONE:
            print "No Fingers Detected"
            self.fingerMarker1.textActor.VisibilityOff()
            self.fingerMarker2.textActor.VisibilityOff()
            self.fingerMarker3.textActor.VisibilityOff()
            self.renwin.Render()
        
        elif self.tracker.fingers_detected() == self.ROTATE:
            print "Rotating"
            fingerID1 = self.tracker._seen.keys()[0]
            fingerPrevCoords = self.tracker._prevCoords[fingerID1]
            fingerCurrCoords = self.tracker._coords[fingerID1]
            
            # show finger marker
            self.fingerMarker1.textActor.SetPosition(fingerCurrCoords[:2])
            self.fingerMarker1.textActor.VisibilityOn()
            
            # hide all other markers
            self.fingerMarker2.textActor.VisibilityOff()
            self.fingerMarker3.textActor.VisibilityOff()
            
            self.Rotate(self.ren, self.renwin, self.ren.GetActiveCamera(), fingerPrevCoords[0]/10, fingerPrevCoords[1]/10, fingerCurrCoords[0]/10, fingerCurrCoords[1]/10)

        elif self.tracker.fingers_detected() == self.ZOOM:
            '''
            BUG DESCRIPTION: zooming in/out depends on dollyFactor >/< 1 respectively. 
                             if user zooms out and dollyFactor reaches some value n, where n<1,
                             and then begins to zoom in, the camera will continue to zoom out even 
                             though n is increasing. Only after n>=1 will the camera begin to zoom in.
                             The same effect occurs for the inverse.
            
            BUG STATUS: not fixed, in progress
            '''
            
            #print "Zooming"
            fingerID1 = self.tracker._seen.keys()[0]
            fingerID2 = self.tracker._seen.keys()[1]
            
            finger1StartCoords = self.tracker._startCoords[fingerID1]
            finger1PrevCoords = self.tracker._prevCoords[fingerID1]
            finger1CurrCoords = self.tracker._coords[fingerID1]
            
            finger2StartCoords = self.tracker._startCoords[fingerID2]
            finger2PrevCoords = self.tracker._prevCoords[fingerID2]
            finger2CurrCoords = self.tracker._coords[fingerID2]

            # calculate distance between the finger1's current position and finger2's starting position
            startDist = math.sqrt( (finger1CurrCoords[0] - finger2StartCoords[0])**2 + (finger1CurrCoords[1] - finger2StartCoords[1])**2 )

            # calculate distance between the finger1's current position and finger2's current position
            currentDist = math.sqrt( (finger1CurrCoords[0] - finger2CurrCoords[0])**2 + (finger1CurrCoords[1] - finger2CurrCoords[1])**2 )

            # show finger markers
            self.fingerMarker1.textActor.SetPosition(finger1CurrCoords[:2])
            self.fingerMarker2.textActor.SetPosition(finger2CurrCoords[:2])
            self.fingerMarker2.textActor.VisibilityOn()  
            
            # hide all other markers
            self.fingerMarker3.textActor.VisibilityOff() 

            if finger1CurrCoords != finger1PrevCoords or finger2CurrCoords != finger2PrevCoords:
                self.Zoom(self.ren, self.renwin, self.ren.GetActiveCamera(), startDist, currentDist)
            else:
                #print 'WILL NOT ZOOM. No change in finger position.'
                pass
            
        elif self.tracker.fingers_detected() == self.PAN:
            print "Panning"
            fingerID1 = self.tracker._seen.keys()[0]
            fingerID2 = self.tracker._seen.keys()[1]
            fingerID3 = self.tracker._seen.keys()[2]
            
            finger1PrevCoords = self.tracker._prevCoords[fingerID1]
            finger1CurrCoords = self.tracker._coords[fingerID1]
            
            finger2PrevCoords = self.tracker._prevCoords[fingerID2]
            finger2CurrCoords = self.tracker._coords[fingerID2]

            finger3PrevCoords = self.tracker._prevCoords[fingerID3]
            finger3CurrCoords = self.tracker._coords[fingerID3]

            # show finger markers
            self.fingerMarker1.textActor.SetPosition(finger1CurrCoords[0], finger1CurrCoords[1])
            self.fingerMarker2.textActor.SetPosition(finger2CurrCoords[0], finger2CurrCoords[1])
            self.fingerMarker3.textActor.SetPosition(finger3CurrCoords[0], finger3CurrCoords[1])
            self.fingerMarker3.textActor.VisibilityOn() 

            self.Pan(self.ren, self.renwin, self.ren.GetActiveCamera(), finger3PrevCoords[0], finger3PrevCoords[1], finger3CurrCoords[0], finger3CurrCoords[1], self.renwin.GetSize()[0]/2.0, self.renwin.GetSize()[1]/2.0)

        elif self.tracker.fingers_detected() == self.TERMINATE:
            self.terminate = True
        
    def Rotate(self, ren, renwin, camera, prevx, prevy, curx, cury):  
        camera.Azimuth(prevx-curx)
        ''' comment out to fix rotation to x axis only '''
        #camera.Elevation(prevy-cury)
        camera.OrthogonalizeViewUp()
        renwin.Render()
        
    def Zoom(self, ren, renwin, camera, startDist, currentDist):
        dollyFactor = pow(1.03,(0.05*(currentDist-startDist)))
        print 'dollyFactor=' + `dollyFactor`
        if camera.GetParallelProjection():
            parallelScale = camera.GetParallelScale()*dollyFactor
            camera.SetParallelScale(parallelScale)
        else:
            camera.Dolly(dollyFactor)
            ren.ResetCameraClippingRange()
        renwin.Render()
        
    def Pan(self, ren, renwin, camera, prevx, prevy, curx, cury, centerX, centerY):
        FPoint = camera.GetFocalPoint()
        FPoint0 = FPoint[0]
        FPoint1 = FPoint[1]
        FPoint2 = FPoint[2]

        PPoint = camera.GetPosition()
        PPoint0 = PPoint[0]
        PPoint1 = PPoint[1]
        PPoint2 = PPoint[2]

        ren.SetWorldPoint(FPoint0, FPoint1, FPoint2, 1.0)
        ren.WorldToDisplay()
        DPoint = ren.GetDisplayPoint()
        focalDepth = DPoint[2]

        APoint0 = centerX+(curx-prevx)
        APoint1 = centerY+(cury-prevy)

        ren.SetDisplayPoint(APoint0, APoint1, focalDepth)
        ren.DisplayToWorld()
        RPoint = ren.GetWorldPoint()
        RPoint0 = RPoint[0]
        RPoint1 = RPoint[1]
        RPoint2 = RPoint[2]
        RPoint3 = RPoint[3]

        if RPoint3 != 0.0:
            RPoint0 = RPoint0/RPoint3
            RPoint1 = RPoint1/RPoint3
            RPoint2 = RPoint2/RPoint3

        camera.SetFocalPoint( (FPoint0-RPoint0)/2.0 + FPoint0, (FPoint1-RPoint1)/2.0 + FPoint1, (FPoint2-RPoint2)/2.0 + FPoint2)
        camera.SetPosition( (FPoint0-RPoint0)/2.0 + PPoint0, (FPoint1-RPoint1)/2.0 + PPoint1, (FPoint2-RPoint2)/2.0 + PPoint2)
        renwin.Render()

    def Kill(self):
        print "Stopping MedicalDemo TUIO tracking"
        self.tracking.stop()
        print "MedicalDemo.py Terminated"
        self.iren.GetRenderWindow().Finalize()