コード例 #1
0
    def Start(self):
        ## create VTK interactor (this is the most important object)
        # this need a Tkinter GUI object (render_frame) and a VTK render window (renWindow) to work
        self.renWinInteractor = vtkTkRenderWindowInteractor(self.render_frame,
                                                            rw=self.renWindow,
                                                            width=600,
                                                            height=600)
        self.renWinInteractor.SetInteractorStyle(
            vtk.vtkInteractorStyleTrackballCamera(
            ))  # set the trackball behaviour
        # we can add additional configurations for this interactor here
        axes = vtk.vtkAxesActor()
        marker = vtk.vtkOrientationMarkerWidget()
        marker.SetOutlineColor(0.93, 0.57, 0.13)
        marker.SetOrientationMarker(axes)
        marker.SetInteractor(self.renWinInteractor)
        marker.SetViewport(0.0, 0.0, 0.4, 0.4)
        marker.SetEnabled(1)
        marker.InteractiveOff()

        ## initialize the interactor and align it to the frame
        self.renWinInteractor.Initialize()
        self.renWinInteractor.pack(side='top', fill='both', expand=1)
        self.renWindow.Render()
        self.renWinInteractor.Start()

        ## main loop
        self.root.mainloop()
コード例 #2
0
 def setenv(self, root):
     self.renderer = vtk.vtkOpenGLRenderer()
     #self.renderer.SetBackground(1,1,1)
     self.renwin = vtk.vtkXOpenGLRenderWindow()
     self.renwin.AddRenderer(self.renderer)
     #self.renwin.SetStereoTypeToRedBlue()
     #self.renwin.StereoCapableWindowOn()
     #self.renwin.SetStereoTypeToCrystalEyes()
     #self.renwin.StereoRenderOn() #activer la stereoscopie
     self.renwin.SetStereoTypeToAnaglyph()
     #self.renwin.SetAnaglyphColorMask(4,2) #gauche,droite | r=4, v=2 ,b=1
     self.iren = vtkTkRenderWindowInteractor(root,
                                             rw=self.renwin,
                                             width=1000,
                                             height=800)
     self.istyle = vtk.vtkInteractorStyleSwitch()
     self.iren.SetInteractorStyle(self.istyle)
     self.istyle.SetCurrentStyleToTrackballCamera()
     self.iren.Initialize()
     self.iren.pack(side='top', fill='both', expand=1)
     self.addobservers()
     self.setcam()
     self.setaxes()
     #self.make_fog() #charger le fog par defaut ? /!\ modifier la variable has_fog
     self.iren.Start()
     self.display_ascii_logo()
コード例 #3
0
ファイル: Nma.py プロジェクト: ggoret/VEDA
 def __init__(self, gfx, frame):
     self.renderer = vtk.vtkOpenGLRenderer()
     self.renwin = vtk.vtkXOpenGLRenderWindow()
     self.renwin.AddRenderer(self.renderer)
     self.renwin.SetStereoTypeToAnaglyph()
     self.iren = vtkTkRenderWindowInteractor(frame,
                                             rw=self.renwin,
                                             width=500,
                                             height=500)
     self.istyle = vtk.vtkInteractorStyleSwitch()
     self.iren.SetInteractorStyle(self.istyle)
     self.istyle.SetCurrentStyleToTrackballCamera()
     self.iren.Initialize()
     self.iren.pack(side='bottom', fill='both', expand=0)
     self.iren.Start()
     self.camera = vtk.vtkCamera()
     self.camera.SetFocalPoint(0, 0, 0)
     self.camera.SetPosition(0, 0, 250)
     self.camera.SetViewUp(0, 0, 0)
     self.camera.SetEyeAngle(5.0)
     self.tm = None
     self.renderer.SetActiveCamera(self.camera)
     self.renwin.Render()
     self.currentmod = None
     self.nbstep = None
     self.oldon = None
     self.tloop = None
     self.tloopobs = None
     self.gfx = gfx
コード例 #4
0
    def __init__(self, parent, model=MathModel1(), w=400, h=400):
        self.parent = parent
        self.model = model
        self.frame = Tkinter.Frame(parent, borderwidth=2, colormap='new')
        self.parent.bind('<q>', self.quit)

        self.__planet_source = self.__planet_mapper = None

        # create renderer and renderwindow
        self.renderer = vtkRenderer()
        from vtk.tk.vtkTkRenderWindowInteractor import \
             vtkTkRenderWindowInteractor
        self.window_w = vtkTkRenderWindowInteractor(master)
        self.window_w.pack(side='top', expand=1, fill='both')
        self.window = self.window_w.GetRenderWindow()
        self.window.AddRenderer(self.renderer)

        self.planets = {}  # sun and planets

        # create sun:
        self.create_sun()

        # create planet 1:
        self.create_planet('earth', 0.2, 0.3, 0)

        # gooey:
        self.delay = Tkinter.DoubleVar()
        self.delay.set(0.01)
        delay_scale = Tkinter.Scale(self.frame,
                                    orient='horizontal',
                                    from_=0.01,
                                    to=1,
                                    tickinterval=100,
                                    resolution=0.01,
                                    label='slow-down of motion',
                                    length=300,
                                    variable=self.delay)
        delay_scale.pack(side='top')

        button_row = Tkinter.Frame(self.frame, borderwidth=2, colormap='new')
        button_row.pack(side='top', fill='both', expand=True)
        b = Tkinter.Button(button_row,
                           text="start animatation",
                           command=self.animate)
        b.pack(side='left', fill='x', expand=True)
        b = Tkinter.Button(button_row,
                           text="stop animation",
                           command=self.stop)
        b.pack(side='right', fill='x', expand=True)

        self.frame.pack(fill='both', expand=True)
        self.window.Render()

        self.__animate_thread_active = 0
コード例 #5
0
class TestTkRenderWindowInteractor(Testing.vtkTest):

    # Stick your VTK pipeline here if you want to create the pipeline
    # only once.  If you put it in the constructor or in the function
    # the pipeline will be created afresh for each and every test.

    # create a dummy Tkinter root window.
    root = tkinter.Tk()

    # create a rendering window and renderer
    ren = vtk.vtkRenderer()
    tkrw = vtkTkRenderWindowInteractor(root, width=300, height=300)
    tkrw.Initialize()
    tkrw.pack()
    rw = tkrw.GetRenderWindow()
    rw.AddRenderer(ren)

    # create an actor and give it cone geometry
    cs = vtk.vtkConeSource()
    cs.SetResolution(8)
    map = vtk.vtkPolyDataMapper()
    map.SetInputConnection(cs.GetOutputPort())
    act = vtk.vtkActor()
    act.SetMapper(map)

    # assign our actor to the renderer
    ren.AddActor(act)

    def testvtkTkRenderWindowInteractor(self):
        "Test if vtkTkRenderWindowInteractor works."
        self.tkrw.Start()
        self.tkrw.Render()
        self.root.update()
        img_file = "TestTkRenderWindowInteractor.png"
        Testing.compareImage(self.rw, Testing.getAbsImagePath(img_file))
        Testing.interact()
        self.tkrw.destroy()

    # These are useful blackbox tests (not dummy ones!)
    def testParse(self):
        "Test if vtkTkRenderWindowInteractor is parseable"
        self._testParse(self.tkrw)

    def testGetSet(self):
        "Testing Get/Set methods of vtkTkRenderWindowInteractor"
        self._testGetSet(self.tkrw)

    def testBoolean(self):
        "Testing Boolean methods of vtkTkRenderWindowInteractor"
        self._testBoolean(self.tkrw)
コード例 #6
0
ファイル: cube.py プロジェクト: priya-gitTest/EasyMedics
def returnCubeObjects(root):
    
    cube = vtk.vtkCubeSource()
    cube.Modified()
    mapper = vtk.vtkPolyDataMapper()
    actor = vtk.vtkActor()

    mapper.SetInputConnection(cube.GetOutputPort())
    actor.SetMapper(mapper)
    render = vtk.vtkRenderer()
    render.AddActor(actor)

    renWindow = vtk.vtkRenderWindow()
    renWindow.AddRenderer(render)

    renWinInteract = vtkTkRenderWindowInteractor(root,rw=renWindow, width=800, height=800) 
    return actor,render,renWindow,renWinInteract
コード例 #7
0
ファイル: vtkplanet.py プロジェクト: HunterAllman/kod
    def __init__(self, parent, model=MathModel1(), w=400, h=400): 
        self.parent = parent 
        self.model = model 
        self.frame = Tkinter.Frame(parent, borderwidth=2, colormap='new') 
        self.parent.bind('<q>', self.quit) 
 
        self.__planet_source = self.__planet_mapper = None 
 
        # create renderer and renderwindow 
        self.renderer = vtkRenderer() 
        from vtk.tk.vtkTkRenderWindowInteractor import \
             vtkTkRenderWindowInteractor
        self.window_w = vtkTkRenderWindowInteractor(master)
        self.window_w.pack( side = 'top', expand = 1, fill = 'both' ) 
        self.window = self.window_w.GetRenderWindow() 
        self.window.AddRenderer( self.renderer ) 
 
        self.planets = {}  # sun and planets 
 
        # create sun: 
        self.create_sun() 
 
        # create planet 1: 
        self.create_planet('earth', 0.2, 0.3, 0) 
                 
        # gooey: 
        self.delay = Tkinter.DoubleVar(); self.delay.set(0.01); 
        delay_scale = Tkinter.Scale(self.frame, orient='horizontal', 
          from_=0.01, to=1, tickinterval=100, resolution=0.01,  
          label='slow-down of motion', length=300, 
          variable=self.delay) 
        delay_scale.pack(side='top') 
 
        button_row = Tkinter.Frame(self.frame, borderwidth=2, colormap='new') 
        button_row.pack(side='top', fill='both', expand=True) 
        b = Tkinter.Button(button_row, text="start animatation", 
                           command=self.animate) 
        b.pack(side='left',fill='x',expand=True) 
        b = Tkinter.Button(button_row, text="stop animation", 
                           command=self.stop) 
        b.pack(side='right',fill='x',expand=True) 
 
        self.frame.pack(fill='both', expand=True) 
        self.window.Render() 
 
        self.__animate_thread_active = 0 
コード例 #8
0
	def __init__(self,frame):
		self.renderer = vtk.vtkOpenGLRenderer()
		self.renwin = vtk.vtkXOpenGLRenderWindow()
		self.renwin.AddRenderer(self.renderer)
		self.renwin.SetStereoTypeToAnaglyph()
		#self.renwin.SetAnaglyphColorMask(4,2)
		self.iren = vtkTkRenderWindowInteractor(frame,rw=self.renwin, width=300, height=300 )
		self.istyle = vtk.vtkInteractorStyleSwitch()
		self.iren.SetInteractorStyle(self.istyle)
		self.istyle.SetCurrentStyleToTrackballCamera()
		self.iren.Initialize()
		self.iren.pack(side='bottom', fill='none', expand=0)
		self.iren.Start()
		self.camera=vtk.vtkCamera()
		self.camera.SetFocalPoint(0, 0, 0)
		self.camera.SetPosition(0, 0, 250)
		self.camera.SetViewUp(0, 0, 0)
		self.camera.SetEyeAngle(5.0)
		self.renderer.SetActiveCamera(self.camera)
		self.renwin.Render()
コード例 #9
0
    def _build(self):
        from tkinter import Tk
        from vtk.tk.vtkTkRenderWindowInteractor import vtkTkRenderWindowInteractor

        # Create Tk root
        tk = Tk()
        tk.title("lib3d-mec-ginac")

        # Create TK window render widget
        rw = vtkRenderWindow()
        iren = vtkTkRenderWindowInteractor(tk, rw=rw, width=600, height=600)
        iren.pack(fill='both')

        # Initialize the interactor
        iren.Initialize()

        # Save tk root, render window and interactor
        self._tk, self._iren, self._rw = tk, iren, rw

        # Return the interactor
        return iren
コード例 #10
0
ファイル: assignment1.py プロジェクト: kvkenyon/projects
	def volumeRender(self):
		#Create transfer mapping scalar value to opacity
		opacityTransferFunction = vtk.vtkPiecewiseFunction()
		opacityTransferFunction.AddPoint(1, 0.0)
		opacityTransferFunction.AddPoint(100, 0.1)
		opacityTransferFunction.AddPoint(255,1.0)

		colorTransferFunction = vtk.vtkColorTransferFunction()
		colorTransferFunction.AddRGBPoint(0.0,0.0,0.0,0.0)	
		colorTransferFunction.AddRGBPoint(64.0,1.0,0.0,0.0)	
		colorTransferFunction.AddRGBPoint(128.0,0.0,0.0,1.0)	
		colorTransferFunction.AddRGBPoint(192.0,0.0,1.0,0.0)	
		colorTransferFunction.AddRGBPoint(255.0,0.0,0.2,0.0)	

		volumeProperty = vtk.vtkVolumeProperty()
		volumeProperty.SetColor(colorTransferFunction)
		volumeProperty.SetScalarOpacity(opacityTransferFunction)
		volumeProperty.ShadeOn()
		volumeProperty.SetInterpolationTypeToLinear()

		compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
		volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper()
		volumeMapper.SetInputConnection(self.reader.GetOutputPort())

		volume = vtk.vtkVolume()
		volume.SetMapper(volumeMapper)
		volume.SetProperty(volumeProperty)

		ren = vtk.vtkRenderer()
		renWin = vtk.vtkRenderWindow()
		renWin.AddRenderer(ren)

		iren = vtkTkRenderWindowInteractor(self.root, rw=renWin, width=640, height=480)
		iren.Initialize()

		ren.AddVolume(volume)
		ren.SetBackground(1,1,1)

		renWin.Render()
コード例 #11
0
ファイル: viewer.py プロジェクト: htphuc/O2FEMpp
    def Start(self):
        ## create VTK interactor (this is the most important object)
        # this need a Tkinter GUI object (render_frame) and a VTK render window (renWindow) to work
        self.renWinInteractor = vtkTkRenderWindowInteractor(self.render_frame, rw=self.renWindow, width=600, height=600)
        self.renWinInteractor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) # set the trackball behaviour
        # we can add additional configurations for this interactor here
        axes = vtk.vtkAxesActor()
        marker = vtk.vtkOrientationMarkerWidget()
        marker.SetOutlineColor(0.93, 0.57, 0.13)
        marker.SetOrientationMarker(axes)
        marker.SetInteractor(self.renWinInteractor)
        marker.SetViewport(0.0, 0.0, 0.4, 0.4)
        marker.SetEnabled(1)
        marker.InteractiveOff()

        ## initialize the interactor and align it to the frame
        self.renWinInteractor.Initialize()
        self.renWinInteractor.pack(side='top', fill='both', expand=1)
        self.renWindow.Render()
        self.renWinInteractor.Start()

        ## main loop
        self.root.mainloop()
コード例 #12
0
ファイル: gfx.py プロジェクト: ggoret/VEDA
	def setenv(self,root):
		self.renderer = vtk.vtkOpenGLRenderer()
		#self.renderer.SetBackground(1,1,1)
		self.renwin = vtk.vtkXOpenGLRenderWindow()
		self.renwin.AddRenderer(self.renderer)
		#self.renwin.SetStereoTypeToRedBlue()
		#self.renwin.StereoCapableWindowOn()
		#self.renwin.SetStereoTypeToCrystalEyes()
		#self.renwin.StereoRenderOn() #activer la stereoscopie
		self.renwin.SetStereoTypeToAnaglyph()
		#self.renwin.SetAnaglyphColorMask(4,2) #gauche,droite | r=4, v=2 ,b=1
		self.iren = vtkTkRenderWindowInteractor(root,rw=self.renwin, width=1000, height=800)
		self.istyle = vtk.vtkInteractorStyleSwitch()
		self.iren.SetInteractorStyle(self.istyle)
		self.istyle.SetCurrentStyleToTrackballCamera()
		self.iren.Initialize()
		self.iren.pack(side='top', fill='both', expand=1)
		self.addobservers()
		self.setcam()
		self.setaxes()
		#self.make_fog() #charger le fog par defaut ? /!\ modifier la variable has_fog
		self.iren.Start()
		self.display_ascii_logo()
コード例 #13
0
    def _build(self):
        from vtk.tk.vtkTkRenderWindowInteractor import vtkTkRenderWindowInteractor
        from .idle.pyshell import build as build_idle, main as idle_mainloop

        # Build IDLE
        tk = build_idle(self)
        self._tk = tk
        top_level = tk.children['!listedtoplevel']
        menu_bar = tk.children['!menu']

        # Build extra widgets for IDLE
        self._load_fonts()
        self._build_menus(menu_bar)
        self._adjust_idle_widgets(top_level)

        # Add event handlers
        self._add_event_handlers()

        # Update GUI
        tk.update()

        # Create TK window render widget
        rw = vtkRenderWindow()
        iren = vtkTkRenderWindowInteractor(top_level,
                                           width=600,
                                           height=600,
                                           rw=rw)
        iren.pack(expand=True, side='right', fill='both')

        # Initialize the interactor
        iren.Initialize()

        # Save render window and interactor
        self._iren, self._rw = iren, rw

        # Return the interactor
        return iren
コード例 #14
0
ファイル: pyScout.py プロジェクト: ewong718/freesurfer
    def InitializeGUI(self,w,h):

        self.top = Tkinter.Toplevel(self.root)

        # make sure exit happens gracefully
        def quit(obj=self.root): obj.quit()
        self.top.protocol("WM_DELETE_WINDOW",quit)

        self.frmDisplay = Tkinter.Frame(self.top)
        self.frmRender = Tkinter.Frame(self.frmDisplay)

        for f in (self.frmDisplay,self.frmRender):
            f.pack(padx=3,pady=3,
                   side="top",
                   anchor="n",
                   fill="both",
                   expand="false")

        rwi = vtkTkRenderWindowInteractor(self.frmRender,
                                          rw=Globals.renWin,
                                          width=w,height=h)
        rwi.pack()
        rwi.Render()
        self.renderWidget = rwi
        self.root.update()

        frmModes = Tkinter.Frame(self.top)
        frmModes.pack()

        self.radioVar = Tkinter.IntVar()
        self.radioVar.set(0)

        self.dicGuiModes = { 0:"Navigation",
                             1:"Add Region",
                             2:"Laplace",
                             3:"Profile Inspector",
                             4:"Highlight",
                             5:"Delete Region"
                             }

        for k in self.dicGuiModes.keys():
            Tkinter.Radiobutton(frmModes,
                                text=self.dicGuiModes[k],
                                variable=self.radioVar,
                                value=k,
                                command=self.ChangeMode).pack(side="left")

        # Add a slice scale to browse the current slice stack
        sliceNumber = Tkinter.IntVar()
        smin,smax = Globals.imagePipeline.GetAxisExtent()
        sliceNumber.set( Globals.imagePipeline.GetSliceIndex() )

        self.scaleSlice = Tkinter.Scale(self.top,
                                        from_=smin, to=smax,
                                        orient="horizontal",
                                        command=self.SetSlice,
                                        variable=sliceNumber,
                                        label="Slice")
        self.scaleSlice.pack(fill="x",expand="false")

        self.SetupMenubar()
コード例 #15
0
ファイル: SpherePuzzle.py プロジェクト: RCBiczok/VTK

# Create the toplevel window
top = tkinter.Toplevel(root)
top.title("Sphere Puzzle")
top.protocol("WM_DELETE_WINDOW", quit)

# Create some frames
f1 = tkinter.Frame(top)
f2 = tkinter.Frame(top)

f1.pack(side="top", anchor="n", expand=1, fill="both")
f2.pack(side="bottom", anchor="s", expand="t", fill="x")

# Create the Tk render widget, and bind the events
rw = vtkTkRenderWindowInteractor(f1, width=400, height=400, rw=renWin)
rw.pack(expand="t", fill="both")


def reset(evt=None):
    puzzle.Reset()
    renWin.Render()


# Display some information
l1 = tkinter.Label(f2, text="Position cursor over the rotation plane.")
l2 = tkinter.Label(f2, text="Moving pieces will be highlighted.")
l3 = tkinter.Label(f2, text="Press 'm' to make a move.")
reset = tkinter.Button(f2, text="Reset", command=reset)

b1 = tkinter.Button(f2, text="Quit", command=quit)
コード例 #16
0

# Window
window = vtk.vtkRenderWindow()
window.AddRenderer(renderer)


# Set up Tk GUI
root = tk.Tk("Frog")
# Define a quit method that exits cleanly
def quit(obj=root):
    obj.quit()


root.protocol("WM_DELETE_WINDOW", quit)
vtkw = vtkTkRenderWindowInteractor(root, rw=window, width=300, height=300)
vtkw.pack(side="left", expand="true", fill="both")

menu = tk.Frame(root, height=300, width=150)
menu.pack(side="left", fill="y")


buttons = dict()
icons = dict()
functions = dict()
opacities = dict()

# def set_color(b):
#         new_color = tkColorChooser.askcolor()
#         icons[b].configure(background=new_color[1])
#         tissues[b-1].GetProperty().SetColor(float(new_color[0][0]) / 255, float(new_color[0][1]) / 255, float(new_color[0][2] / 255))
コード例 #17
0
ファイル: CubeSection.py プロジェクト: agamdua/mystic
    Q = (P[0], P[1], v)
    cp = CuttingPlane(*Q)
    pn = PlaneNormal(*Q)
    clipper.SetClipFunction(cp)
    clipper.SetValue(0)
    cutEdges.SetCutFunction(cp)
    cutEdges.SetValue(0, 0)
    cutStrips.Update()
    cutPoly.SetPoints(cutStrips.GetOutput().GetPoints())
    cutPoly.SetPolys(cutStrips.GetOutput().GetLines())
    cutMapper.Update()
    renWin.Render()


root = Tkinter.Tk()
vtkw = vtkTkRenderWindowInteractor(root, rw=renWin, width=800)


def set_cut(sz):
    sz = float(sz)
    # print ren.GetActiveCamera()
    Cut(sz)


# propagate this GUI setting to the corresponding VTK object.
size_slider = Tkinter.Scale(root,
                            from_=0.0,
                            to=2.0,
                            res=0.01,
                            orient='horizontal',
                            label="Clipping Center",
コード例 #18
0
ファイル: oldCode.py プロジェクト: kvkenyon/projects
mapper.Update()


actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(1,0.547237,0.319073)
actor.GetProperty().SetOpacity(.3)

#create render window and interactor 
ren = vtk.vtkRenderer()
ren.SetBackground(0.329412, 0.34902, 0.427451) #paraview blue from tutorial
ren.ResetCameraClippingRange()
ren.AddActor(actor)

renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.PolygonSmoothingOn()

#Setup interactor
iren = vtkTkRenderWindowInteractor(root,rw=renWin, width=400, height=400)
iren.Initialize()
iren.pack(side='top', fill='both', expand=1)
iren.Start()

#Init the interactor and render Start the interactor
renWin.Render()
root.mainloop()



コード例 #19
0
ファイル: main.py プロジェクト: orxshi/stencilwalkgui
ren.AddActor(actor)

button = Tkinter.Button(root, text="Quit", command=root.quit)
button.pack(fill='x', expand='t')

start = Tkinter.IntVar()
targetx = Tkinter.DoubleVar()
targety = Tkinter.DoubleVar()
target = [targetx, targety]

but_run = Tkinter.Button(root,
                         text="Run",
                         command=lambda: runfnc(start, target))
but_run.pack(fill='x', expand='t')

interactor = vtkTkRenderWindowInteractor(root, rw=renwin)
interactor.pack(side='top', fill='both', expand=1)
interactor.Initialize()
style = MouseInteractorStyle()
style.SetDefaultRenderer(ren)
style.user_data = ugrid
style.rw = renwin
style.ren = ren
style.startp = start
style.target = target
interactor.SetInteractorStyle(style)
interactor.Start()

root.mainloop()
コード例 #20
0
############################ Create outline ##################
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(reader1.GetOutputPort())

outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())

outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)

outlineActor.GetProperty().SetColor(1, 1, 1)

############################## Graphics stuff####################

ren1 = vtk.vtkRenderer()
iren = vtkTkRenderWindowInteractor(root, height=512, width=512)
renWin = iren.GetRenderWindow()
renWin.AddRenderer(ren1)
iren.SetInteractorStyle(style)

#ren1.AddActor(outlineActor)             not used in the original given file
ren1.AddVolume(volume)
ren1.SetBackground(0, 0, 0)


def TkCheckAbort(obj, event):  #check abortion
    foo = renWin.GetEventPending()
    if (foo != 0):
        renWin.SetAbortRender(1)
    return
コード例 #21
0
ファイル: vtkProbe.py プロジェクト: yidilozdemir/freesurfer
    def InitializeGUI(self,w,h):

        self.top = Tkinter.Toplevel(Globals.root)

        # handle graceful exit
        def quit(obj=Globals.root): obj.quit()
        self.top.protocol("WM_DELETE_WINDOW",quit)

        self.frmDisplay = Tkinter.Frame(self.top)
        self.frmRender = Tkinter.Frame(self.frmDisplay)

        for f in (self.frmDisplay,self.frmRender):
            f.pack(padx=3,pady=3,
                   side="top",
                   anchor="n",
                   fill="both",
                   expand="false")

        rwi = vtkTkRenderWindowInteractor(self.frmRender,
                                          rw=Globals.renWin,
                                          width=w,height=h)
        rwi.pack()
        rwi.Render()
        self.renderWidget = rwi
        Globals.root.update()

        #############################
        #
        # setup modes
        frmModes = Tkinter.Frame(self.top)
        frmModes.pack()

        self.dicGuiModes = { 0:"Navigation",
                             1:"Add Spline"
                             }

        self.radioVar = Tkinter.IntVar()
        self.radioVar.set(0)
        for k in self.dicGuiModes.keys():
            Tkinter.Radiobutton(frmModes,
                                text=self.dicGuiModes[k],
                                variable=self.radioVar,
                                value=k,
                                command=self.ChangeMode).pack(
                side="left")
            
        #############################
        #
        # setup labels
        frmLabels = Tkinter.Frame(self.top)
        frmLabels.pack()

        self.dicLabels = {}
        counter = 0
        for lbl in Globals.objectSet.labels:
            self.dicLabels[counter] = lbl
            counter += 1
        self.lblVar = Tkinter.IntVar()
        self.lblVar.set(0)
        Globals.objectSet.currentLabel = self.dicLabels[0]
        for k in self.dicLabels.keys():
            Tkinter.Radiobutton(frmLabels,
                                text=self.dicLabels[k],
                                variable=self.lblVar,
                                value=k,
                                command=self.ChangeCurrentLabel).pack(
                side="left")

        ####################################
        # Add a slice scale to browse the current slice stack
        sliceNumber = Tkinter.IntVar()
        smin,smax = Globals.imagePipeline.GetAxisExtent()
        sliceNumber.set( Globals.imagePipeline.GetSliceIndex() )

        self.scaleSlice = Tkinter.Scale(self.top,
                                        from_=smin, to=smax,
                                        orient="horizontal",
                                        command=self.SetSlice,
                                        variable=sliceNumber,
                                        label="Slice")
        self.scaleSlice.pack(fill="x", expand="false")

        self.SetupMenubar()
コード例 #22
0
ファイル: vtkview.py プロジェクト: badbytes/pymeg
def vtkrender(d1=None, d2=None):
    
    x = (arange(50.0)-25)/2.0
    y = (arange(50.0)-25)/2.0
    r = sqrt(x[:]**2+y**2)
    z = 5.0*signal.special.j0(r)  # Bessel function of order 0
    z1 = reshape(transpose(z), (-1,))
    point_data = vtk.vtkPointData(vtk.vtkScalars(z1))
    grid = vtk.vtkStructuredPoints((50,50, 1), (-12.5, -12.5, 0), (0.5, 0.5, 1))
    data = vtk.VtkData(grid, point_data)
    data.tofile('/tmp/test.vtk')
    d1 = d2 = '/tmp/test.vtk'
    
    #v2,v1,data1,data2 = inputs()
    if d1 == None:
        d1 = "/home/danc/E0058brain.vtk"
        #d1 = "/home/danc/vtk/data1.vtk"
    if d2 == None:
        d2 = "/home/danc/E0058MEG.vtk"
        #d2='/home/danc/vtk/data2.vtk'
        #d2 = "/home/danc/mrvtk_0003overlay.vtk"


    v1 = vtk.vtkStructuredPointsReader()

    #v1.SetFileName("/home/danc/mrvtk.vtk")
    v1.SetFileName(d1)
    v2 = vtk.vtkStructuredPointsReader()
    #v2.SetFileName("/home/danc/mrvtk_overlay.vtk")
    v2.SetFileName(d2)
    v1.SetLookupTableName('/home/danc/colortable.lut')
    v1.SetReadAllColorScalars
    v1.Update()
    v2.Update()


    global xMax, xMin, yMin, yMax, zMin, zMax, current_widget, slice_number
    xMin, xMax, yMin, yMax, zMin, zMax = v1.GetOutput().GetWholeExtent()

    spacing = v1.GetOutput().GetSpacing()
    sx, sy, sz = spacing

    origin = v1.GetOutput().GetOrigin()
    ox, oy, oz = origin

    # An outline is shown for context.
    outline = vtk.vtkOutlineFilter()
    outline.SetInput(v1.GetOutput())

    outlineMapper = vtk.vtkPolyDataMapper()
    outlineMapper.SetInput(outline.GetOutput())

    outlineActor = vtk.vtkActor()
    outlineActor.SetMapper(outlineMapper)
    outlineActor.GetProperty().SetColor(1,1,1)

    # The shared picker enables us to use 3 planes at one time
    # and gets the picking order right
    picker = vtk.vtkCellPicker()
    picker.SetTolerance(0.005)

    # The 3 image plane widgets are used to probe the dataset.
    planeWidgetX = vtk.vtkImagePlaneWidget()
    planeWidgetX.DisplayTextOn()
    planeWidgetX.SetInput(v1.GetOutput())
    planeWidgetX.SetPlaneOrientationToXAxes()
    planeWidgetX.SetSliceIndex(int(round(xMax/2)))
    planeWidgetX.SetPicker(picker)
    planeWidgetX.SetKeyPressActivationValue("x")
    planeWidgetX.GetPlaneProperty().SetDiffuseColor((0,1,1))
    #planeWidgetX.GetPlaneProperty().SetColor(0,1,1)
    #planeWidgetX.GetPlaneProperty().SetSpecularColor(0,1,1)
    #planeWidgetX.GetPlaneProperty().SetAmbientColor(0,1,1)
    planeWidgetX.GetPlaneProperty().SetFrontfaceCulling(10)
    planeWidgetX.GetPlaneProperty().SetRepresentationToWireframe
    #planeWidgetX.GetColorMap()
    #print planeWidgetX.GetColorMap()
    #planeWidgetX.SetHueRange(0.667,0.0)
    #planeWidgetX.SetLookupTable('/home/danc/colortable.lut')

    prop1 = planeWidgetX.GetPlaneProperty()
    prop1.SetDiffuseColor(1, 0, 0)
    prop1.SetColor(1,0,0)
    prop1.SetSpecularColor(0, 1, 1)
    #print planeWidgetX.GetLookupTable()
    g = planeWidgetX.GetLookupTable()
    #print g



##    arrow = vtk.vtkArrowSource()
####    arrow.SetShaftRadius(100)
####    arrow.SetShaftResolution(80)
####    arrow.SetTipRadius(100)
####    arrow.SetTipLength(1000)
####    #arrow.SetTipResolution(80)
##    arrowMapper = vtk.vtkPolyDataMapper()
##    arrowMapper.SetInput(arrow.GetOutput())
##    arrowActor = vtk.vtkActor()
##    arrowActor.SetMapper(arrowMapper)
##    arrowActor.SetPosition(0, 0, 0)
##    arrowActor.GetProperty().SetColor(0, 1, 0)


    planeWidgetY = vtk.vtkImagePlaneWidget()
    planeWidgetY.DisplayTextOn()
    planeWidgetY.SetInput(v1.GetOutput())
    planeWidgetY.SetPlaneOrientationToYAxes()
    planeWidgetY.SetSliceIndex(int(round(yMax/2)))
    planeWidgetY.SetPicker(picker)
    planeWidgetY.SetKeyPressActivationValue("y")
    prop2 = planeWidgetY.GetPlaneProperty()
    prop2.SetColor(1, 1, 0)
    planeWidgetY.SetLookupTable(planeWidgetX.GetLookupTable())
    planeWidgetY.GetPlaneProperty().SetDiffuseColor(0,1,1)


    # for the z-slice, turn off texture interpolation:
    # interpolation is now nearest neighbour, to demonstrate
    # cross-hair cursor snapping to pixel centers
    planeWidgetZ = vtk.vtkImagePlaneWidget()

    planeWidgetZ.SetSliceIndex(100)
    planeWidgetZ.SetSlicePosition(100)
    planeWidgetZ.DisplayTextOn()
    planeWidgetZ.SetInput(v1.GetOutput())
    planeWidgetZ.SetPlaneOrientationToZAxes()
    planeWidgetZ.SetSliceIndex(int(round(yMax/2)))
    planeWidgetZ.SetPicker(picker)
    planeWidgetZ.SetKeyPressActivationValue("z")
    prop3 = planeWidgetZ.GetPlaneProperty()
    prop3.SetColor(0, 0, 1)
    planeWidgetZ.SetLookupTable(planeWidgetX.GetLookupTable())
    planeWidgetZ.GetPlaneProperty().SetDiffuseColor(0,1,1)

    filelist = [v2,v1];
    for i in filelist:


        coloroniso = vtk.vtkStructuredPointsReader()
        coloroniso.SetFileName(i.GetFileName())
        coloroniso.SetScalarsName("colors")
        coloroniso.Update()

        isosurface = vtk.vtkStructuredPointsReader()
        isosurface.SetFileName(i.GetFileName())
        isosurface.SetScalarsName("scalars")
        isosurface.Update()

        iso = vtk.vtkContourFilter()
        iso.SetInput(i.GetOutput())
        #iso.SetInput(isosurface.GetOutput())
        if i == v1:
            iso.SetValue(0, 20)
        else:
            iso.SetValue(0,10)
        #iso.SetNumberOfContours(10)

        probe = vtk.vtkProbeFilter()
        probe.SetInput(iso.GetOutput())
        probe.SetSource(coloroniso.GetOutput())

        cast = vtk.vtkCastToConcrete()
        cast.SetInput(probe.GetOutput())

        normals = vtk.vtkPolyDataNormals()
        #normals.SetMaxRecursionDepth(100)
        normals.SetInput(cast.GetPolyDataOutput())
        normals.SetFeatureAngle(45)

    ##    clut = vtk.vtkLookupTable()
    ##    clut.SetHueRange(0, .67)
    ##    clut.Build()
    ##    clut.SetValueRange(coloroniso.GetOutput().GetScalarRange())


    ##    normals = vtk.vtkPolyDataNormals()
    ##    normals.SetInput(iso.GetOutput())
    ##    normals.SetFeatureAngle(45)
        isoMapper = vtk.vtkPolyDataMapper()
        isoMapper.SetInput(normals.GetOutput())
        isoMapper.ScalarVisibilityOn()
        #isoMapper.SetColorModeToMapScalars()
        isoMapper.ColorByArrayComponent(0, 100)#("VelocityMagnitude", 0)

        isoMapper.SetScalarRange([1, 200])
    ##    isoMapper.SetLookupTable(clut)

        isoActor = vtk.vtkActor()
        isoActor.SetMapper(isoMapper)

    ##    isoActor.GetProperty().SetDiffuseColor([.5,.5,.5])
    ##    isoActor.GetProperty().SetSpecularColor([1,1,1])
    ##    isoActor.GetProperty().SetDiffuse(.5)
    ##    isoActor.GetProperty().SetSpecular(.5)
    ##    isoActor.GetProperty().SetSpecularPower(15)
    ##    isoActor.GetProperty().SetOpacity(.6)

        isoActor.GetProperty().SetDiffuseColor(1, .2, .2)
        isoActor.GetProperty().SetSpecular(.7)
        isoActor.GetProperty().SetSpecularPower(20)
        isoActor.GetProperty().SetOpacity(0.5)


        if i == v1:
            print 'under'
            isoActorUnderlay = isoActor
        else:
            print 'over'
            isoActorOverlay = isoActor




    # Create the RenderWindow and Renderer
    ren = vtk.vtkRenderer()
    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(ren)

    # Add the outline actor to the renderer, set the background color and size
    ren.AddActor(outlineActor)
    #ren.AddActor(sphereActor)


    renWin.SetSize(700, 700)
    ren.SetBackground(0, 0, 0)

    current_widget = planeWidgetZ
    mode_widget = planeWidgetZ

    # Create the GUI
    # We first create the supporting functions (callbacks) for the GUI
    #
    # Align the camera so that it faces the desired widget
    def AlignCamera():
        #global ox, oy, oz, sx, sy, sz, xMax, xMin, yMax, yMin, zMax, \
        #      zMin, slice_number
        #global current_widget
        cx = ox+(0.5*(xMax-xMin))*sx
        cy = oy+(0.5*(yMax-yMin))*sy
        cz = oy+(0.5*(zMax-zMin))*sz
        vx, vy, vz = 0, 0, 0
        nx, ny, nz = 0, 0, 0
        iaxis = current_widget.GetPlaneOrientation()
        if iaxis == 0:
            vz = -1
            nx = ox + xMax*sx
            cx = ox + slice_number*sx
        elif iaxis == 1:
            vz = -1
            ny = oy+yMax*sy
            cy = oy+slice_number*sy
        else:
            vy = 1
            nz = oz+zMax*sz
            cz = oz+slice_number*sz

        px = cx+nx*2
        py = cy+ny*2
        pz = cz+nz*3

        camera = ren.GetActiveCamera()
        camera.SetViewUp(vx, vy, vz)
        camera.SetFocalPoint(cx, cy, cz)
        camera.SetPosition(px, py, pz)
        camera.OrthogonalizeViewUp()
        ren.ResetCameraClippingRange()
        renWin.Render()

    # Capture the display and place in a tiff
    def CaptureImage():
        w2i = vtk.vtkWindowToImageFilter()
        writer = vtk.vtkTIFFWriter()
        w2i.SetInput(renWin)
        w2i.Update()
        writer.SetInput(w2i.GetOutput())
        writer.SetFileName("/home/danc/image.tif")
        renWin.Render()
        writer.Write()


    # Align the widget back into orthonormal position,
    # set the slider to reflect the widget's position,
    # call AlignCamera to set the camera facing the widget
    def AlignXaxis():
        global xMax, xMin, current_widget, slice_number
        po = planeWidgetX.GetPlaneOrientation()
        if po == 3:
            planeWidgetX.SetPlaneOrientationToXAxes()
            slice_number = (xMax-xMin)/2
            planeWidgetX.SetSliceIndex(slice_number)
        else:
            slice_number = planeWidgetX.GetSliceIndex()

        current_widget = planeWidgetX

        slice.config(from_=xMin, to=xMax)
        slice.set(slice_number)
        AlignCamera()


    def AlignYaxis():
        global yMin, yMax, current_widget, slice_number
        po = planeWidgetY.GetPlaneOrientation()
        if po == 3:
            planeWidgetY.SetPlaneOrientationToYAxes()
            slice_number = (yMax-yMin)/2
            planeWidgetY.SetSliceIndex(slice_number)
        else:
            slice_number = planeWidgetY.GetSliceIndex()

        current_widget = planeWidgetY

        slice.config(from_=yMin, to=yMax)
        slice.set(slice_number)
        AlignCamera()

    def AlignZaxis():
        global yMin, yMax, current_widget, slice_number
        po = planeWidgetZ.GetPlaneOrientation()
        if po == 3:
            planeWidgetZ.SetPlaneOrientationToZAxes()
            slice_number = (zMax-zMin)/2
            planeWidgetZ.SetSliceIndex(slice_number)
        else:
            slice_number = planeWidgetZ.GetSliceIndex()

        current_widget = planeWidgetZ

        slice.config(from_=zMin, to=zMax)
        slice.set(slice_number)
        AlignCamera()

    ##################def flag(sw):


    def underlay():
        print 'under'
        global overunderstatus
        overunderstatus = 'under'
        isoActor = isoActorUnderlay
        u_button.config(relief='sunken')
        o_button.config(relief='raised')
        six=planeWidgetX.GetSliceIndex()
        siy=planeWidgetY.GetSliceIndex()
        siz=planeWidgetZ.GetSliceIndex()
        data = v1
        planeWidgetX.SetInput(data.GetOutput())
        planeWidgetY.SetInput(data.GetOutput())
        planeWidgetZ.SetInput(data.GetOutput())
        planeWidgetX.SetSliceIndex(six)
        planeWidgetY.SetSliceIndex(siy)
        planeWidgetZ.SetSliceIndex(siz)
        renWin.Render()


    def overlay():
        print 'over'
        global overunderstatus
        overunderstatus = 'over'
        isoActor = isoActorOverlay
        o_button.config(relief='sunken')
        u_button.config(relief='raised')
        six=planeWidgetX.GetSliceIndex()
        siy=planeWidgetY.GetSliceIndex()
        siz=planeWidgetZ.GetSliceIndex()
        data = v2
        planeWidgetX.SetInput(data.GetOutput())
        planeWidgetY.SetInput(data.GetOutput())
        planeWidgetZ.SetInput(data.GetOutput())
        planeWidgetX.SetSliceIndex(six)
        planeWidgetY.SetSliceIndex(siy)
        planeWidgetZ.SetSliceIndex(siz)
        renWin.Render()


    def render3d():
        print '3d rend'
        global buttonpos
        try:
            if overunderstatus == 'under':
                isoActor = isoActorUnderlay
            else:
                isoActor = isoActorOverlay
        except NameError:
            isoActor = isoActorUnderlay
        try:
            buttonpos
            print buttonpos
        except NameError:
            buttonpos = 0
            print buttonpos
            r_button.config(relief='sunken')
            ren.AddActor(isoActor)

            renWin.Render()
        else:
            if buttonpos == 0:
                buttonpos = 1
                r_button.config(relief='raised')
                ren.RemoveActor(isoActor)
                ren.RemoveActor(isoActorUnderlay)
                ren.RemoveActor(isoActorOverlay)
                renWin.Render()
            else:
                buttonpos = 0
                r_button.config(relief='sunken')
                print o_button
                ren.AddActor(isoActor)
                renWin.Render()
        return buttonpos

    # Set the widget's reslice interpolation mode
    # to the corresponding popup menu choice
    def SetInterpolation():
        global mode_widget, mode
        if mode.get() == 0:
            mode_widget.TextureInterpolateOff()
        else:
            mode_widget.TextureInterpolateOn()

        mode_widget.SetResliceInterpolate(mode.get())
        renWin.Render()

    # Share the popup menu among buttons, keeping track of associated
    # widget's interpolation mode
    def buttonEvent(event, arg=None):
        global mode, mode_widget, popm
        if arg == 0:
            mode_widget = planeWidgetX
        elif arg == 1:
            mode_widget = planeWidgetY
        elif arg == 2:
            mode_widget = planeWidgetZ
        else:
            return
        mode.set(mode_widget.GetResliceInterpolate())
        popm.entryconfigure(arg, variable=mode)
        popm.post(event.x + event.x_root, event.y + event.y_root)

    def SetSlice(sl):
        global current_widget
        current_widget.SetSliceIndex(int(sl))
        ren.ResetCameraClippingRange()
        renWin.Render()


    ###
    # Now actually create the GUI
    root = Tkinter.Tk()
    root.withdraw()
    top = Tkinter.Toplevel(root)

    # Define a quit method that exits cleanly.
    def quit(obj=root):
        print obj
        obj.quit()
        obj.destroy()
        #vtkrender.destroy()


    # Popup menu
    popm = Tkinter.Menu(top, tearoff=0)
    mode = Tkinter.IntVar()
    mode.set(1)
    popm.add_radiobutton(label="nearest", variable=mode, value=0,
                         command=SetInterpolation)
    popm.add_radiobutton(label="linear", variable=mode, value=1,
                         command=SetInterpolation)
    popm.add_radiobutton(label="cubic", variable=mode, value=2,
                         command=SetInterpolation)

    display_frame = Tkinter.Frame(top)
    display_frame.pack(side="top", anchor="n", fill="both", expand="false")

    # Buttons
    ctrl_buttons = Tkinter.Frame(top)
    ctrl_buttons.pack(side="top", anchor="n", fill="both", expand="false")

    quit_button = Tkinter.Button(ctrl_buttons, text="Quit", command=quit)
    capture_button = Tkinter.Button(ctrl_buttons, text="Tif",
                                    command=CaptureImage)
    quit_button.config(background='#C0C0C0')

    x_button = Tkinter.Button(ctrl_buttons, text="x", command=AlignXaxis)
    y_button = Tkinter.Button(ctrl_buttons, text="y", command=AlignYaxis)
    z_button = Tkinter.Button(ctrl_buttons, text="z", command=AlignZaxis)
    u_button = Tkinter.Button(ctrl_buttons, text="underlay", command=underlay)
    o_button = Tkinter.Button(ctrl_buttons, text="overlay", command=overlay)
    r_button = Tkinter.Button(ctrl_buttons, text="3d render", command=render3d)
    o_button.config(background='#FFFFFF')
    u_button.config(relief='sunken')



    x_button.bind("<Button-3>", lambda e: buttonEvent(e, 0))
    y_button.bind("<Button-3>", lambda e: buttonEvent(e, 1))
    z_button.bind("<Button-3>", lambda e: buttonEvent(e, 2))
    u_button.bind("<Button-3>", lambda e: buttonEvent(e, 3))
    o_button.bind("<Button-3>", lambda e: buttonEvent(e, 4))
    r_button.bind("<Button-3>", lambda e: buttonEvent(e, 5))

    for i in (quit_button, capture_button, x_button, y_button, z_button, u_button, o_button, r_button):
        i.pack(side="left", expand="true", fill="both")


    # Create the render widget
    renderer_frame = Tkinter.Frame(display_frame)
    renderer_frame.pack(padx=3, pady=3,side="left", anchor="n",
                        fill="both", expand="false")

    render_widget = vtkTkRenderWindowInteractor(renderer_frame,
                                                rw=renWin, width=600,
                                                height=600)
    for i in (render_widget, display_frame):
        i.pack(side="top", anchor="n",fill="both", expand="false")

    # Add a slice scale to browse the current slice stack
    slice_number = Tkinter.IntVar()
    slice_number.set(current_widget.GetSliceIndex())
    slice = Tkinter.Scale(top, from_=zMin, to=zMax, orient="horizontal",
                          command=SetSlice,variable=slice_number,
                          label="Slice")
    slice.pack(fill="x", expand="false")

    # Done with the GUI.
    ###

    # Set the interactor for the widgets
    iact = render_widget.GetRenderWindow().GetInteractor()
    planeWidgetX.SetInteractor(iact)
    planeWidgetX.On()
    planeWidgetY.SetInteractor(iact)
    planeWidgetY.On()
    planeWidgetZ.SetInteractor(iact)
    planeWidgetZ.On()

    # Create an initial interesting view
    cam1 = ren.GetActiveCamera()
    cam1.Elevation(210)
    cam1.SetViewUp(1, -1, 1)
    cam1.Azimuth(-145)
    ren.ResetCameraClippingRange()

    # Render it
    render_widget.Render()

    iact.Initialize()
    renWin.Render()
    iact.Start()

    # Start Tkinter event loop
    root.mainloop()
コード例 #23
0
def returnHeartObjects(root, file):
    dataset_directory = file
    # Read data
    reader = vtk.vtkDICOMImageReader()
    reader.SetDirectoryName(dataset_directory)
    reader.Update()

    volume = vtk.vtkVolume()
    render = vtk.vtkRenderer()
    renWindow = vtk.vtkRenderWindow()
    renWindow.AddRenderer(render)
    renWinInteract = vtkTkRenderWindowInteractor(root,
                                                 rw=renWindow,
                                                 width=800,
                                                 height=800)

    # Define volume mapper
    #volumeMapper = vtk.vtkSmartVolumeMapper()
    volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
    volumeMapper.SetInputConnection(reader.GetOutputPort())

    # Create colour transfer function
    colorFunc = vtk.vtkColorTransferFunction()
    '''
    colorFunc.AddRGBPoint(1, 0.0, 0.0, 0.0)
    colorFunc.AddRGBPoint(2, 0.54902, 0.25098, 0.14902)
    colorFunc.AddRGBPoint(3, 0.882353, 0.603922, 0.290196)
    colorFunc.AddRGBPoint(4, 1, 0.937033, 0.954531)
    colorFunc.AddRGBPoint(5, 0.615686, 0, 0)
    colorFunc.AddRGBPoint(6, 0.827451, 0.658824, 1)
    '''

    alphaChannelFunc = vtk.vtkPiecewiseFunction()
    '''
    alphaChannelFunc.AddPoint(1, 0.0)
    alphaChannelFunc.AddPoint(2, 0.0)
    alphaChannelFunc.AddPoint(3, 0.29)
    alphaChannelFunc.AddPoint(4, 0.55)
    alphaChannelFunc.AddPoint(5, 0.84)
    alphaChannelFunc.AddPoint(6, 0.875)
    '''

    # Define volume properties
    volumeProperty = vtk.vtkVolumeProperty()
    '''
    volumeProperty.SetScalarOpacity(alphaChannelFunc)
    volumeProperty.SetColor(colorFunc)
    volumeProperty.ShadeOn()
    '''

    # Set the mapper and volume properties
    '''
    volume.SetMapper(volumeMapper)
    volume.SetProperty(volumeProperty)
    '''

    # Add the volume to the renderer
    '''
    render.AddVolume(volume)
    '''

    return volumeMapper, volume, render, renWindow, renWinInteract, colorFunc, alphaChannelFunc, volumeProperty
コード例 #24
0
ファイル: main.py プロジェクト: beauof/FSIViewer
def main():
    print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" \
          ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n\n" \
          "FSIViewer - simple visualizer for FSI data\n\n" \
          ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" \
          ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n\n" \
          "Copyright (C) 2015 Andreas Hessenthaler\n" \
          "                   University of Stuttgart\n" \
          "                   [email protected]\n\n" \
          ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" \
          ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n\n" \
          "This program is free software: you can redistribute it and/" \
          "or modify it under the terms of the\n" \
          "GNU Lesser General Public License as published by the Free " \
          "Software Foundation, either version 3\n" \
          "of the License, or (at your option) any later version.\n\n" \
          "This program is distributed in the hope that it will be use" \
          "ful, but WITHOUT ANY WARRANTY; without\n" \
          "even the implied warranty of MERCHANTABILITY or FITNESS FOR" \
          " A PARTICULAR PURPOSE.  See the GNU\n" \
          "Lesser General Public License for more details.\n\n" \
          "You should have received a copy of the GNU Lesser General " \
          "Public License along with this program.\n" \
          "If not, see <http://www.gnu.org/licenses/>.\n\n" \
          "Please state the original author.\n\n" \
          ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" \
          ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n\n" \
          "File I/O:\n" \
          " Numpy: http://www.numpy.org/\n" \
          " Cython: http://cython.org/\n" \
          "GUI:\n" \
          " Tkinter: http://www.tkdocs.com/tutorial/index.html\n" \
          " Silk icon set 1.3 by Mark James: http://www.famfamfam.com/lab/icons/silk/\n" \
          " VTK: http://www.vtk.org/\n\n" \
          "Make sure that the following packages are installed:\n" \
          "gcc\n" \
          "python2.x\n" \
          "python-tk\n" \
          "python-imaging-tk\n" \
          "python-dev\n" \
          "python-numpy\n" \
          "cython\n" \
          "vtk\n\n" \
          "Note: This software has been developed with VTK 5.8.0\n" \
          "You are using VTK", vtk.vtkVersion().GetVTKVersion(), \
          "\n\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" \
          ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n" \
    
    # create window
    window = gui()
    window.root = Tkinter.Tk()
    
    # initialise visualization
    visualization = fsi()
    # set username and read configuration
    visualization.username = getpass.getuser()
    if (os.path.exists("config/"+visualization.username+".config")):
        print "User-specific configuration file found:\n", \
            " config/"+visualization.username+".config", \
            "\n\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" \
            ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"
        visualization.readConfiguration( \
            "config/"+visualization.username+".config")
    elif (os.path.exists("config/default.config")):
        print "Default configuration file found:\n", \
            ". /config/default.config", \
            "\n\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" \
            ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"
        visualization.readConfiguration( \
            "config/default.config")
    else:
        print "No configuration file found. Please create one."
    
    # get vtk version
    visualization.vtkVersionMajor = vtk.vtkVersion().GetVTKMajorVersion()
    visualization.vtkVersionMinor = vtk.vtkVersion().GetVTKMinorVersion()
    visualization.vtkVersionBuild = vtk.vtkVersion().GetVTKBuildVersion()
    
    # set debug level
    if visualization.DEBUG: logging.basicConfig(level=logging.DEBUG)
    else: logging.basicConfig(level=logging.INFO)
    
    
    window.configureRoot()
    window.configureGUI()
    window.mainframe = ttk.Frame(window.root, borderwidth=5, style='My.TFrame')
    window.configureMainframe()
    window.toolbar = ttk.Frame(window.mainframe, borderwidth=5, style='My.TFrame')
    window.configureToolbar(visualization.installDirectory)
    window.loadBtn = ttk.Button(window.toolbar, image=window.useLoadIcon, \
        command=lambda:visualization.defineSequence(window), style='My.TButton')
    window.loadBtn.pack(side=Tkinter.LEFT, fill=Tkinter.X, padx=1)
    window.refreshConfigBtn = ttk.Button(window.toolbar, \
        image=window.useRefreshConfigIcon, \
        command=visualization.refreshConfiguration, \
        style='My.TButton')
    window.refreshConfigBtn.pack(side=Tkinter.LEFT, fill=Tkinter.X, padx=1)
    window.quitBtn = ttk.Button(window.toolbar, image=window.useQuitIcon, \
        command=quit, style='My.TButton')
    window.quitBtn.pack(side=Tkinter.LEFT, fill=Tkinter.X, padx=1)
    
    ## tabs
    window.notebook = ttk.Notebook(window.mainframe, style='My.TNotebook')
    window.configureNotebook()
    # fluid tab
    window.subframeF = ttk.Frame(window.notebook, style='My.TNotebook.Tab')
    window.subframeF.pack()
    window.notebook.add(window.subframeF, text="F", state="disabled")
    visualization.showF = Tkinter.StringVar()
    visualization.showF.set("vel")
    ttk.Radiobutton(window.subframeF, text="pressure", \
        command=visualization.updateFluid, \
        variable=visualization.showF, value="presF", \
        style='My.TRadiobutton').grid(column=0, row = 0, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text="velocity", \
        command=visualization.updateFluid, \
        variable=visualization.showF, value="vel", \
        style='My.TRadiobutton').grid(column=0, row = 1, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text="domain velocity", \
        command=visualization.updateFluid, \
        variable=visualization.showF, value="wel", \
        style='My.TRadiobutton').grid(column=0, row = 2, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text="vorticity", \
        command=visualization.updateFluid, \
        variable=visualization.showF, value="vort", \
        style='My.TRadiobutton').grid(column=0, row = 3, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text="tet quality", \
        command=visualization.updateFluid, \
        variable=visualization.showF, value="quality", \
        style='My.TRadiobutton').grid(column=0, row = 4, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text="directional scalar", \
        command=visualization.updateFluid, \
        variable=visualization.showF, value="phi", \
        style='My.TRadiobutton').grid(column=0, row = 5, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text="none", \
        command=visualization.updateFluid, \
        variable=visualization.showF, value="none", \
        style='My.TRadiobutton').grid(column=0, row = 6, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    
    ttk.Separator(window.subframeF, orient=Tkinter.HORIZONTAL).grid(column=0, \
        row = 7, sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    
    visualization.clipFnormal = Tkinter.StringVar()
    visualization.clipFnormal.set('-1')
    ttk.Radiobutton(window.subframeF, text='full', \
        command=visualization.updateFluid, \
        variable=visualization.clipFnormal, value="-1", \
        style='My.TRadiobutton').grid(column=0, row = 8, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text='clip w/ normal x (elem)', \
        command=visualization.updateFluid, \
        variable=visualization.clipFnormal, value="xe", \
        style='My.TRadiobutton').grid(column=0, row = 9, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text='clip w/ normal y (elem)', \
        command=visualization.updateFluid, \
        variable=visualization.clipFnormal, value="ye", \
        style='My.TRadiobutton').grid(column=0, row = 10, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text="clip w/ normal z (elem)", \
        command=visualization.updateFluid, \
        variable=visualization.clipFnormal, value='ze', \
        style='My.TRadiobutton').grid(column=0, row = 11, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text='clip w/ normal x', \
        command=visualization.updateFluid, \
        variable=visualization.clipFnormal, value='x', \
        style='My.TRadiobutton').grid(column=0, row = 17, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text='clip w/ normal y', \
        command=visualization.updateFluid, \
        variable=visualization.clipFnormal, value='y', \
        style='My.TRadiobutton').grid(column=0, row = 18, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text='clip w/ normal z', \
        command=visualization.updateFluid, \
        variable=visualization.clipFnormal, value='z', \
        style='My.TRadiobutton').grid(column=0, row = 19, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text='plane w/ normal x', \
        command=visualization.updateFluid, \
        variable=visualization.clipFnormal, value='a', \
        style='My.TRadiobutton').grid(column=0, row = 20, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text='plane w/ normal y', \
        command=visualization.updateFluid, \
        variable=visualization.clipFnormal, value='b', \
        style='My.TRadiobutton').grid(column=0, row = 21, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text='plane w/ normal z', \
        command=visualization.updateFluid, \
        variable=visualization.clipFnormal, value='c', \
        style='My.TRadiobutton').grid(column=0, row = 22, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    
    ttk.Radiobutton(window.subframeF, text='vortex structure', \
        command=visualization.updateFluid, \
        variable=visualization.clipFnormal, value='vortex-structure', \
        style='My.TRadiobutton').grid(column=0, row = 23, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
#    ttk.Separator(window.subframeF, orient=Tkinter.HORIZONTAL).grid(column=0, \
#        row = 23, sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    
    visualization.boolEdgesF = Tkinter.BooleanVar()
    visualization.boolEdgesF.set(False)
    ttk.Checkbutton(window.subframeF, \
        variable=visualization.boolEdgesF, text='Show tri/tet edges', \
        command=visualization.edgesOnOffF, \
        style='My.TCheckbutton').grid(column=0, row = 24, \
        sticky=(Tkinter.W, Tkinter.E))
    
    ttk.Separator(window.subframeF, orient=Tkinter.HORIZONTAL).grid(column=0, \
        row = 25, sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    visualization.boolShowScalarBarF = Tkinter.BooleanVar()
    visualization.boolShowScalarBarF.set(False)
    ttk.Checkbutton(window.subframeF, \
        variable=visualization.boolShowScalarBarF, text='Show scalarbar', \
        command=visualization.scalarBarOnOffF, \
        style='My.TCheckbutton').grid(column=0, row = 26, \
        sticky=(Tkinter.W, Tkinter.E))
    
    window.componentFrameF = ttk.Frame(window.subframeF, style='My.TFrame')
    window.componentFrameF.grid(column=0, row=27, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E))
    ttk.Label(window.componentFrameF, width=15, text="Use component:", \
        style='My.TLabel').grid(column=0, row=0, sticky=Tkinter.S)
    
    visualization.componentDropDownF = ttk.Combobox(window.componentFrameF, \
        justify=Tkinter.LEFT, width=10)
    visualization.componentDropDownF.grid(column=1, row = 0, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    visualization.componentDropDownF.bind('<<ComboboxSelected>>', \
        visualization.componentUpdateF)
    visualization.componentDropDownF['values'] = \
        ("magnitude", "x", "y", "z")
    visualization.componentDropDownF.set("magnitude")
    
    ttk.Checkbutton(window.componentFrameF, \
        variable=visualization.boolAutoRangeF, text='Auto-range', \
        command=lambda:visualization.enableUserRangeF(window), \
        style='My.TCheckbutton').grid(column=0, row=1, \
        sticky=(Tkinter.W, Tkinter.E))
    window.entryMinF = ttk.Entry(window.componentFrameF, width=5, \
        textvariable=visualization.userMinF, \
        justify=Tkinter.RIGHT, state=["disabled"])
    window.entryMinF.grid(column=0, row=2, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E))
    window.entryMaxF = ttk.Entry(window.componentFrameF, width=5, \
        textvariable=visualization.userMaxF, \
        justify=Tkinter.RIGHT, state=["disabled"])
    window.entryMaxF.grid(column=1, row=2, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E))
    
    
    visualization.boolShowOutlineF = Tkinter.BooleanVar()
    visualization.boolShowOutlineF.set(False)
    ttk.Checkbutton(window.subframeF, \
        variable=visualization.boolShowOutlineF, text='Show outline', \
        command=visualization.outlineOnOffF, \
        style='My.TCheckbutton').grid(column=0, row = 28, \
        sticky=(Tkinter.W, Tkinter.E))
    
    ttk.Separator(window.subframeF, orient=Tkinter.HORIZONTAL).grid(column=0, \
        row = 29, sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    
    labelsDropDown = ttk.Combobox(window.subframeF, \
        textvariable=visualization.labelVar)
    labelsDropDown.grid(column=0, row = 30, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
#    labelsDropDown.bind('<<ComboboxSelected>>', modifyLabelF)
    labelsDropDown['values'] = ('No label', 'Node ID', 'Node coordinates', 'Cell ID', 'Pressure', 'Velocity')
    labelsDropDown.set('no label')
    
    ttk.Radiobutton(window.subframeF, text='plane w/ normal x (resample)', \
        command=visualization.updateFluid, \
        variable=visualization.clipFnormal, value='i', \
        style='My.TRadiobutton').grid(column=0, row = 31, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text='plane w/ normal y (resample)', \
        command=visualization.updateFluid, \
        variable=visualization.clipFnormal, value='j', \
        style='My.TRadiobutton').grid(column=0, row = 32, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeF, text='plane w/ normal z (resample)', \
        command=visualization.updateFluid, \
        variable=visualization.clipFnormal, value='k', \
        style='My.TRadiobutton').grid(column=0, row = 33, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    
    # solid tab
    window.subframeS = ttk.Frame(window.notebook, style='My.TNotebook.Tab')
    window.subframeS.pack()
    window.notebook.add(window.subframeS, text="S", state="disabled")
    visualization.showS = Tkinter.StringVar()
    visualization.showS.set("disp")
    ttk.Radiobutton(window.subframeS, text="pressure", \
        command=visualization.updateSolid, \
        variable=visualization.showS, value="presS", \
        style='My.TRadiobutton').grid(column=0, row = 0, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeS, text="displacement", \
        command=visualization.updateSolid, \
        variable=visualization.showS, value="disp", \
        style='My.TRadiobutton').grid(column=0, row = 1, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeS, text="velocity", \
        command=visualization.updateSolid, \
        variable=visualization.showS, value="vel", \
        style='My.TRadiobutton').grid(column=0, row = 2, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeS, text="Cauchy stress", \
        command=visualization.updateSolid, \
        variable=visualization.showS, value="cauchy", \
        style='My.TRadiobutton').grid(column=0, row = 3, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeS, text="tet quality", \
        command=visualization.updateSolid, \
        variable=visualization.showS, value="quality", \
        style='My.TRadiobutton').grid(column=0, row = 4, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeS, text="none", \
        command=visualization.updateSolid, \
        variable=visualization.showS, value="none", \
        style='My.TRadiobutton').grid(column=0, row = 5, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Separator(window.subframeS, \
        orient=Tkinter.HORIZONTAL).grid(column=0, row = 6, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    visualization.boolEdgesS = Tkinter.BooleanVar()
    visualization.boolEdgesS.set(False)
    ttk.Checkbutton(window.subframeS, \
        variable=visualization.boolEdgesS, text='Show tri/tet edges', \
        command=visualization.meshTubesOnOffS, \
        style='My.TCheckbutton').grid(column=0, row = 7, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    visualization.boolShowScalarBarS = Tkinter.BooleanVar()
    visualization.boolShowScalarBarS.set(False)
    ttk.Checkbutton(window.subframeS, \
        variable=visualization.boolShowScalarBarS, text='Show scalarbar', \
        command=visualization.scalarBarOnOffS, \
        style='My.TCheckbutton').grid(column=0, row = 8, \
        sticky=(Tkinter.W, Tkinter.E))
    
    window.componentFrameS = ttk.Frame(window.subframeS, style='My.TFrame')
    window.componentFrameS.grid(column=0, row=9, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E))
    ttk.Label(window.componentFrameS, width=15, text="Use component:", \
        style='My.TLabel').grid(column=0, row=0, sticky=Tkinter.S)
    visualization.componentDropDownS = ttk.Combobox(window.componentFrameS, \
        justify=Tkinter.LEFT, width=10)
    visualization.componentDropDownS.grid(column=1, row = 0, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    visualization.componentDropDownS.bind('<<ComboboxSelected>>', \
        visualization.componentUpdateS)
    visualization.componentDropDownS['values'] = \
        ("magnitude", "x", "y", "z")
    visualization.componentDropDownS.set("magnitude")
    
    ttk.Checkbutton(window.componentFrameS, \
        variable=visualization.boolAutoRangeS, text='Auto-range', \
        command=lambda:visualization.enableUserRangeS(window), \
        style='My.TCheckbutton').grid(column=0, row=1, \
        sticky=(Tkinter.W, Tkinter.E))
    window.entryMinS = ttk.Entry(window.componentFrameS, width=5, \
        textvariable=visualization.userMinS, \
        justify=Tkinter.RIGHT, state=["disabled"])
    window.entryMinS.grid(column=0, row=2, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E))
    window.entryMaxS = ttk.Entry(window.componentFrameS, width=5, \
        textvariable=visualization.userMaxS, \
        justify=Tkinter.RIGHT, state=["disabled"])
    window.entryMaxS.grid(column=1, row=2, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E))
    
    visualization.boolShowOutlineS = Tkinter.BooleanVar()
    visualization.boolShowOutlineS.set(False)
    ttk.Checkbutton(window.subframeS, \
        variable=visualization.boolShowOutlineS, text='Show outline', \
        command=visualization.outlineOnOffS, \
        style='My.TCheckbutton').grid(column=0, row = 16, \
        sticky=(Tkinter.W, Tkinter.E))
    visualization.boolShowOnReferenceS = Tkinter.BooleanVar()
    visualization.boolShowOnReferenceS.set(False)
    ttk.Checkbutton(window.subframeS, \
        variable=visualization.boolShowOnReferenceS, text='Use reference configuration', \
        command=visualization.referenceOnOffS, \
        style='My.TCheckbutton').grid(column=0, row = 17, \
        sticky=(Tkinter.W, Tkinter.E))
    
    ttk.Separator(window.subframeS, orient=Tkinter.HORIZONTAL).grid(column=0, \
        row = 18, sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    
    window.nodeFrameS = ttk.Frame(window.subframeS, style='My.TFrame')
    window.nodeFrameS.grid(column=0, row=19, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E))
    nodeButtonS = ttk.Button(window.nodeFrameS, \
        command=visualization.updateNodeS, \
        text="Track node:", style='My.TButton')
    nodeButtonS.grid(column=0, row = 0, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    window.entryNodeS = ttk.Entry(window.nodeFrameS, width=6, \
        textvariable=visualization.nodeS, \
        justify=Tkinter.RIGHT)
    window.entryNodeS.grid(column=1, row=0, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E, Tkinter.N))
    ttk.Entry(window.nodeFrameS, width=8, \
        textvariable=visualization.nodeSrefX, \
        justify=Tkinter.RIGHT).grid( \
        column=0, row=1, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E, Tkinter.N))
    ttk.Entry(window.nodeFrameS, width=8, \
        textvariable=visualization.nodeSrefY, \
        justify=Tkinter.RIGHT).grid( \
        column=0, row=2, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E, Tkinter.N))
    ttk.Entry(window.nodeFrameS, width=8, \
        textvariable=visualization.nodeSrefZ, \
        justify=Tkinter.RIGHT).grid( \
        column=0, row=3, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E, Tkinter.N))
    ttk.Entry(window.nodeFrameS, width=8, \
        textvariable=visualization.nodeSx, \
        justify=Tkinter.RIGHT).grid( \
        column=1, row=1, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E, Tkinter.N))
    ttk.Entry(window.nodeFrameS, width=8, \
        textvariable=visualization.nodeSy, \
        justify=Tkinter.RIGHT).grid( \
        column=1, row=2, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E, Tkinter.N))
    ttk.Entry(window.nodeFrameS, width=8, \
        textvariable=visualization.nodeSz, \
        justify=Tkinter.RIGHT).grid( \
        column=1, row=3, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E, Tkinter.N))
    
    
    # interface tab
    window.subframeI = ttk.Frame(window.notebook, style='My.TNotebook.Tab')
    window.subframeI.pack()
    window.notebook.add(window.subframeI, text="I", state="disabled")
    visualization.showI = Tkinter.StringVar()
    visualization.showI.set("lm")
    
    ttk.Radiobutton(window.subframeI, text='Lagrange multiplier', \
        command=visualization.updateInterface, \
        variable=visualization.showI, value='lm', \
        style='My.TRadiobutton').grid(column=0, row = 0, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Radiobutton(window.subframeI, text='none', \
        command=visualization.updateInterface, \
        variable=visualization.showI, value='none', \
        style='My.TRadiobutton').grid(column=0, row = 3, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Separator(window.subframeI, \
        orient=Tkinter.HORIZONTAL).grid(column=0, row = 4, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    
    visualization.boolEdgesI = Tkinter.BooleanVar()
    visualization.boolEdgesI.set(False)
    ttk.Checkbutton(window.subframeI, \
        variable=visualization.boolEdgesI, text='Show tri/tet edges', \
        command=visualization.edgesOnOffI, \
        style='My.TCheckbutton').grid(column=0, row = 5, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    
    visualization.boolShowScalarBarI = Tkinter.BooleanVar()
    visualization.boolShowScalarBarI.set(False)
    ttk.Checkbutton(window.subframeI, \
        variable=visualization.boolShowScalarBarI, text='Show scalarbar', \
        command=visualization.scalarBarOnOffI, \
        style='My.TCheckbutton').grid(column=0, row = 6, \
        sticky=(Tkinter.W, Tkinter.E))
    
    window.componentFrameI = ttk.Frame(window.subframeI, style='My.TFrame')
    window.componentFrameI.grid(column=0, row=7, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E))
    ttk.Label(window.componentFrameI, width=15, text="Use component:", \
        style='My.TLabel').grid(column=0, row=0, sticky=Tkinter.S)
    visualization.componentDropDownI = ttk.Combobox(window.componentFrameI, \
        justify=Tkinter.LEFT, width=10)
    visualization.componentDropDownI.grid(column=1, row = 0, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    visualization.componentDropDownI.bind('<<ComboboxSelected>>', \
        visualization.componentUpdateI)
    visualization.componentDropDownI['values'] = \
        ("magnitude", "x", "y", "z")
    visualization.componentDropDownI.set("magnitude")
    
    ttk.Checkbutton(window.componentFrameI, \
        variable=visualization.boolAutoRangeI, text='Auto-range', \
        command=lambda:visualization.enableUserRangeI(window), \
        style='My.TCheckbutton').grid(column=0, row=1, \
        sticky=(Tkinter.W, Tkinter.E))
    window.entryMinI = ttk.Entry(window.componentFrameI, width=5, \
        textvariable=visualization.userMinI, \
        justify=Tkinter.RIGHT, state=["disabled"])
    window.entryMinI.grid(column=0, row=2, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E))
    window.entryMaxI = ttk.Entry(window.componentFrameI, width=5, \
        textvariable=visualization.userMaxI, \
        justify=Tkinter.RIGHT, state=["disabled"])
    window.entryMaxI.grid(column=1, row=2, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E))
    
    visualization.boolShowOutlineI = Tkinter.BooleanVar()
    visualization.boolShowOutlineI.set(False)
    ttk.Checkbutton(window.subframeI, \
        variable=visualization.boolShowOutlineI, text='Show outline', \
        command=visualization.outlineOnOffI, \
        style='My.TCheckbutton').grid(column=0, row = 16, \
        sticky=(Tkinter.W, Tkinter.E))
    
    # viewer tab
    window.subframeV = ttk.Frame(window.notebook, style='My.TNotebook.Tab')
    window.subframeV.pack()
    window.notebook.add(window.subframeV, text="Viewer      ", state="normal")
    
    visualization.backgroundDropDown = ttk.Combobox(window.subframeV)
    visualization.backgroundDropDown.grid(column=0, row = 0, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    visualization.backgroundDropDown.bind('<<ComboboxSelected>>', \
        visualization.modifyBackground)
    visualization.backgroundDropDown['values'] = \
        ('black background', 'black-white background', \
         'white background', 'white-black background', \
         'custom background', 'custom-white background')
    visualization.backgroundDropDown.set('white background')
    ttk.Button(window.subframeV, \
        command=lambda:visualization.modifyCamera(window), \
        text="Modify camera view", style='My.TButton').grid(column=0, row = 2, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    ttk.Button(window.subframeV, \
        command=visualization.screenshot, \
        text="Screenshot", style='My.TButton').grid(column=0, row = 4, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    #ttk.Separator(window.subframeV, orient=Tkinter.HORIZONTAL).grid(column=0, \
    #    row = 5, sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    fromFrame = ttk.Frame(window.subframeV, style='My.TFrame')
    fromFrame.grid(column=0, row=7, sticky=(Tkinter.W, Tkinter.S, Tkinter.E))
    toFrame   = ttk.Frame(window.subframeV, style='My.TFrame')
    toFrame.grid(column=0, row=8, sticky=(Tkinter.W, Tkinter.N, Tkinter.E))
    visualization.animateFromStr = Tkinter.StringVar()
    visualization.animateToStr   = Tkinter.StringVar()
    visualization.animateFromStr.set(str(visualization.animateFromT))
    visualization.animateToStr.set(str(visualization.animateToT))
    ttk.Label(fromFrame, width=7, text="from:", \
        style='My.TLabel').grid(column=0, row=0, sticky=Tkinter.S)
    ttk.Entry(fromFrame, width=10, textvariable=visualization.animateFromStr, \
        justify=Tkinter.RIGHT).grid(column=1, row=0, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E))
    ttk.Label(toFrame, width=7, text="to:  ", \
        style='My.TLabel').grid(column=0, row=0, sticky=Tkinter.S)
    ttk.Entry(toFrame, width=10, textvariable=visualization.animateToStr, \
        justify=Tkinter.RIGHT).grid(column=1, row=0, \
        sticky=(Tkinter.W, Tkinter.N, Tkinter.E))
    screenshotFrame = ttk.Frame(window.subframeV, style='My.TFrame')
    screenshotFrame.grid(column=0, row=9, sticky=(Tkinter.W, Tkinter.E))
    visualization.screenshotFolderStr = Tkinter.StringVar()
    visualization.screenshotFolderStr.set("png/")
    ttk.Label(screenshotFrame, width=7, text="folder:", \
        style='My.TLabel').grid(column=0, row=0, sticky=Tkinter.S)
    ttk.Entry(screenshotFrame, width=10, \
        textvariable=visualization.screenshotFolderStr, \
        justify=Tkinter.RIGHT).grid(column=1, row=0, \
        sticky=(Tkinter.W, Tkinter.S, Tkinter.E))
    animateSaveFrame = ttk.Frame(window.subframeV)
    animateSaveFrame.grid(column=0, row=10, sticky=(Tkinter.W, Tkinter.E))
    animateButton = ttk.Button(animateSaveFrame, \
        command=visualization.animate, \
        text="Animate", style='My.TButton')
    animateButton.grid(column=0, row = 0, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    saveButton = ttk.Button(animateSaveFrame, \
        command=visualization.animateNsave, \
        text="Animate & save", style='My.TButton')
    saveButton.grid(column=1, row = 0, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    phasesFrame = ttk.Frame(window.subframeV, style='My.TFrame')
    phasesFrame.grid(column=0, row=15, sticky=(Tkinter.W, Tkinter.E))
    probeButtonI = ttk.Button(phasesFrame, \
        command=lambda:visualization.phaseIorII(window, 1), \
        text="Phase I", style='My.TButton').grid(column=0, row = 0, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    probeButtonII = ttk.Button(phasesFrame, \
        command=lambda:visualization.phaseIorII(window, 2), \
        text="Phase II", style='My.TButton').grid(column=1, row = 0, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    
    
    ttk.Button(window.subframeV, \
        command=lambda:visualization.displayPoints(window), \
        text="Display points", style='My.TButton').grid(column=0, row = 20, \
        sticky=(Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    
    visualization.boolShowPoints = Tkinter.BooleanVar()
    visualization.boolShowPoints.set(False)
    visualization.showPointsCheckbutton = ttk.Checkbutton(window.subframeV, \
        variable=visualization.boolShowPoints, text='Show points', \
        command=visualization.pointsOnOff, \
        style='My.TCheckbutton').grid(column=0, row = 21, \
        sticky=(Tkinter.W, Tkinter.E))
    
    visualization.configureCamera()
    visualization.renderer = vtk.vtkRenderer()
    visualization.configureRenderer()
    visualization.addSphere()
    
    visualization.renderWindow = vtk.vtkRenderWindow()
    visualization.renderWindow.AddRenderer(visualization.renderer)
    
    visualization.renderWidget = vtkTkRenderWindowInteractor(window.mainframe, \
        rw=visualization.renderWindow)
    visualization.renderWidget.grid(column=2, row=0, rowspan=window.gridy-2, \
        columnspan=window.gridx-2, \
        sticky = (Tkinter.N, Tkinter.W, Tkinter.E, Tkinter.S))
    visualization.renderWidget.focus()
    
    # create slider for modifying current time
    visualization.timeSlider = Tkinter.Scale(window.mainframe, \
        from_=visualization.fromT, to=visualization.toT, \
        resolution=visualization.increment, \
        orient=Tkinter.HORIZONTAL, \
        showvalue=0, state=Tkinter.DISABLED, \
        background=window.linuxMintHEX, foreground='black', \
        relief='flat', borderwidth=0)
    visualization.timeSlider.set(visualization.currentT)
    visualization.timeSlider.grid(padx=0, pady=5, column=2, row=window.gridy-1, \
        columnspan=window.gridx-3, sticky = (Tkinter.W, Tkinter.E))
    visualization.timeLabelText = Tkinter.StringVar()
    visualization.timeLabelText.set(str(visualization.currentT))
    # toolbar for +/- increments
    toolbarPM = ttk.Frame(window.mainframe, style='My.TFrame', \
        height=5, width=45)
    toolbarPM.grid(row=window.gridy-1, column=window.gridx-1, \
        sticky=(Tkinter.W, Tkinter.E))
    toolbarPMlabel = ttk.Label(toolbarPM, \
        textvariable=visualization.timeLabelText, width=6, style='My.TLabel')
    toolbarPMlabel.grid(row=0, column=0, padx=5)
    buttonMinus = ttk.Button(toolbarPM, text='-', \
        command=visualization.previousT, \
        style='My.TButton')
    buttonMinus.grid(row=0, column=1)
    buttonPlus = ttk.Button(toolbarPM, text='+', \
        command=visualization.nextT, \
        style='My.TButton')
    buttonPlus.grid(row=0, column=2)
    # progress bar
    visualization.progress = ttk.Progressbar(window.mainframe, \
        orient=Tkinter.HORIZONTAL, mode='determinate')
    visualization.progress.grid(column=0, row=window.gridy-1, \
        sticky = (Tkinter.W, Tkinter.E))
    visualization.progress.grid_remove()
    # renderWindowInteractor
    visualization.interactor = \
        visualization.renderWidget.GetRenderWindow().GetInteractor()
    visualization.interactorStyle = vtk.vtkInteractorStyleTrackballCamera()
    visualization.interactor.SetInteractorStyle(visualization.interactorStyle)
    visualization.interactor.AddObserver("KeyPressEvent", visualization.keypress)
    
    
    # create a popup menu to choose colorbar map
    menu = Tkinter.Menu(window.root, tearoff=0)
    visualization.scalarBarCacheF = Tkinter.IntVar()
    visualization.scalarBarCacheF.set(visualization.ctfNumberF)
    visualization.scalarBarCacheS = Tkinter.IntVar()
    visualization.scalarBarCacheS.set(visualization.ctfNumberS)
    visualization.scalarBarCacheI = Tkinter.IntVar()
    visualization.scalarBarCacheI.set(visualization.ctfNumberI)
    menu.add_radiobutton(label="Rainbow", \
        command=lambda:visualization.nextCTF("fluid"), \
        variable=visualization.scalarBarCacheF, value=0)
    menu.add_radiobutton(label="Blue-red", \
        command=lambda:visualization.nextCTF("fluid"), \
        variable=visualization.scalarBarCacheF, value=1)
    menu.add_radiobutton(label="Blue-white-red", \
        command=lambda:visualization.nextCTF("fluid"), \
        variable=visualization.scalarBarCacheF, value=2)
    menu.add_radiobutton(label="Black-white", \
        command=lambda:visualization.nextCTF("fluid"), \
        variable=visualization.scalarBarCacheF, value=3)
    menu.add_separator()
    menu.add_radiobutton(label="Rainbow", \
        command=lambda:visualization.nextCTF("solid"), \
        variable=visualization.scalarBarCacheS, value=0)
    menu.add_radiobutton(label="Blue-red", \
        command=lambda:visualization.nextCTF("solid"), \
        variable=visualization.scalarBarCacheS, value=1)
    menu.add_radiobutton(label="Blue-white-red", \
        command=lambda:visualization.nextCTF("solid"), \
        variable=visualization.scalarBarCacheS, value=2)
    menu.add_radiobutton(label="Black-white", \
        command=lambda:visualization.nextCTF("solid"), \
        variable=visualization.scalarBarCacheS, value=3)
    menu.add_separator()
    menu.add_radiobutton(label="Rainbow", \
        command=lambda:visualization.nextCTF("interface"), \
        variable=visualization.scalarBarCacheI, value=0)
    menu.add_radiobutton(label="Blue-red", \
        command=lambda:visualization.nextCTF("interface"), \
        variable=visualization.scalarBarCacheI, value=1)
    menu.add_radiobutton(label="Blue-white-red", \
        command=lambda:visualization.nextCTF("interface"), \
        variable=visualization.scalarBarCacheI, value=2)
    menu.add_radiobutton(label="Black-white", \
        command=lambda:visualization.nextCTF("interface"), \
        variable=visualization.scalarBarCacheI, value=3)
    def popup(event):
        menu.post(event.x_root, event.y_root)
    window.root.bind("<Button-3>", popup)
    
    # render scene
    visualization.renderWidget.Render()
    visualization.cameraUpdate()
    
    # start main loop
    window.root.mainloop()
コード例 #25
0
ファイル: ImagePlaneWidget.py プロジェクト: 0004c/VTK
z_button = Tkinter.Button(ctrl_buttons, text="z", command=AlignZaxis)
x_button.bind("<Button-3>", lambda e: buttonEvent(e, 0))
y_button.bind("<Button-3>", lambda e: buttonEvent(e, 1))
z_button.bind("<Button-3>", lambda e: buttonEvent(e, 2))

for i in (quit_button, capture_button, x_button, y_button, z_button):
    i.pack(side="left", expand="true", fill="both")


# Create the render widget
renderer_frame = Tkinter.Frame(display_frame)
renderer_frame.pack(padx=3, pady=3,side="left", anchor="n",
                    fill="both", expand="false")

render_widget = vtkTkRenderWindowInteractor(renderer_frame,
                                            rw=renWin, width=600,
                                            height=600)
for i in (render_widget, display_frame):
    i.pack(side="top", anchor="n",fill="both", expand="false")

# Add a slice scale to browse the current slice stack
slice_number = Tkinter.IntVar()
slice_number.set(current_widget.GetSliceIndex())
slice = Tkinter.Scale(top, from_=zMin, to=zMax, orient="horizontal",
                      command=SetSlice,variable=slice_number,
                      label="Slice")
slice.pack(fill="x", expand="false")

# Done with the GUI.
###
コード例 #26
0

# Create the toplevel window
top = tkinter.Toplevel(root)
top.title("Sphere Puzzle")
top.protocol("WM_DELETE_WINDOW", quit)

# Create some frames
f1 = tkinter.Frame(top)
f2 = tkinter.Frame(top)

f1.pack(side="top", anchor="n", expand=1, fill="both")
f2.pack(side="bottom", anchor="s", expand="t", fill="x")

# Create the Tk render widget, and bind the events
rw = vtkTkRenderWindowInteractor(f1, width=400, height=400, rw=renWin)
rw.pack(expand="t", fill="both")


def reset(evt=None):
    puzzle.Reset()
    renWin.Render()


# Display some information
l1 = tkinter.Label(f2, text="Position cursor over the rotation plane.")
l2 = tkinter.Label(f2, text="Moving pieces will be highlighted.")
l3 = tkinter.Label(f2, text="Press 'm' to make a move.")
reset = tkinter.Button(f2, text="Reset", command=reset)

b1 = tkinter.Button(f2, text="Quit", command=quit)
コード例 #27
0
    def __init__(self, parent, config):
        self.config = config
        tk.Frame.__init__(self, parent)
        self.parent = parent
        parent.wm_title('radcal-gui')
        self.pack(fill='both', expand=1)

        # left section
        self.frame_dir = tk.Frame(self)
        self.frame_dir.pack(side='left', fill='y', expand=0)

        tk.Button(self.frame_dir, text='Open...',
                  command=self.open_dir).pack(side='top')

        tk.Label(self.frame_dir,
                 text='current directory:',
                 anchor='w',
                 width=30).pack(side='top')
        self.var_dirname = tk.StringVar()
        tk.Label(self.frame_dir,
                 textvariable=self.var_dirname,
                 anchor='w',
                 width=30).pack(side='top')

        self.list_file = tk.Listbox(self.frame_dir, selectmode='browse')
        self.list_file.bind('<<ListboxSelect>>', self.file_modified)
        self.list_file.pack(fill='x')

        # main section
        self.frame_main = tk.Frame(self)
        self.frame_main.pack(fill='both', expand=1)

        # top section
        self.frame_file = tk.Frame(self.frame_main, bd=1, relief='sunken')
        self.frame_file.pack(fill='x', expand=0)

        tk.Button(self.frame_file, text='Open file',
                  command=self.open_file).pack(side='left')

        self.var_filename = tk.StringVar()
        tk.Label(self.frame_file,
                 textvariable=self.var_filename).pack(side='left')

        # middle section
        frame_main = tk.Frame(self.frame_main)
        frame_main.pack(fill='both', expand=1)

        ren_win = vtk.vtkRenderWindow()
        iren = vtkTkRenderWindowInteractor(frame_main,
                                           rw=ren_win,
                                           width=600,
                                           height=600)
        self.vtk = vtkgui.VtkGui(iren)
        iren.pack(side='left', fill='both', expand=1)

        frame_control = tk.Frame(frame_main)
        frame_control.pack(side='left')

        frame_dim = tk.Frame(frame_control)
        frame_dim.pack(fill='x', expand=0)
        self.var_dim = tk.IntVar()
        self.var_dim.set(3)
        tk.Radiobutton(frame_dim,
                       text='2D',
                       variable=self.var_dim,
                       value=2,
                       command=self.dim_modified).pack(side='left',
                                                       fill='x',
                                                       expand=1)
        tk.Radiobutton(frame_dim,
                       text='3D',
                       variable=self.var_dim,
                       value=3,
                       command=self.dim_modified).pack(side='right',
                                                       fill='x',
                                                       expand=1)

        self.button_render = tk.Button(frame_control,
                                       text='Render',
                                       command=self.render,
                                       state='disabled')
        self.button_render.pack(fill='x', expand=0)

        self.button_clear = tk.Button(frame_control,
                                      text='Clear',
                                      command=self.clear)
        self.button_clear.pack(fill='x', expand=0)

        self.var_scalarbar = tk.IntVar()
        self.check_scalarbar = tk.Checkbutton(frame_control,
                                              text='Scalar Bar',
                                              variable=self.var_scalarbar,
                                              command=self.scalarbar_modified)
        self.check_scalarbar.pack(fill='x')

        self.var_contour = tk.IntVar()
        self.check_contour = tk.Checkbutton(frame_control,
                                            text='Contour',
                                            variable=self.var_contour,
                                            command=self.contour_modified)
        self.check_contour.pack(fill='x')

        tk.Label(frame_control, text='Variables:').pack()
        self.list_var = tk.Listbox(frame_control, selectmode='browse')
        self.list_var.bind('<<ListboxSelect>>', self.var_modified)
        self.list_var.pack(fill='x')

        tk.Label(frame_control, text='Probing line:').pack()
        self.frame_probe = tk.Frame(frame_control)
        self.frame_probe.pack(fill='x', expand=1)

        command_val_float = (self.parent.register(validate_float), '%d', '%i',
                             '%P', '%s', '%S', '%v', '%V', '%W')

        self.var_coord = tk.StringVar()
        # self.var_coord.set('x')

        coord_tab = ['x', 'y', 'z']

        counter = 0
        self.entry_coord = {}
        self.radio_coord = {}
        self.label_coord = {}
        for c in coord_tab:
            self.radio_coord[c] = tk.Radiobutton(self.frame_probe,
                                                 text=c,
                                                 variable=self.var_coord,
                                                 value=c,
                                                 command=self.coord_modified)
            self.radio_coord[c].grid(row=counter, column=0)
            self.entry_coord[c] = tk.Entry(self.frame_probe,
                                           validate='key',
                                           validatecommand=command_val_float)
            self.entry_coord[c].grid(row=counter, column=1)
            self.label_coord[c] = tk.StringVar()
            tk.Label(self.frame_probe,
                     textvariable=self.label_coord[c]).grid(row=counter,
                                                            column=2)
            counter += 1

        self.var_timeplot = tk.IntVar()
        self.check_timeplot = tk.Checkbutton(self.frame_probe,
                                             text='time plot',
                                             variable=self.var_timeplot,
                                             command=self.timeplot_modified,
                                             state='disabled')
        self.check_timeplot.grid(row=3, column=0, columnspan=2)

        # bottom section
        self.frame_control = tk.Frame(self.frame_main, bd=1, relief='sunken')
        self.frame_control.pack(fill='x', expand=0)
        tk.Button(self.frame_control,
                  text='Quit',
                  command=self.parent.quit,
                  padx=5,
                  pady=5).pack(side='right')
        tk.Button(self.frame_control,
                  text='Save',
                  command=self.write,
                  padx=5,
                  pady=5).pack(side='right')
        tk.Button(self.frame_control,
                  text='Print',
                  command=self.screenshot,
                  padx=5,
                  pady=5).pack(side='right')
        frame_time = tk.Frame(self.frame_control)
        frame_time.pack(side='left')

        button_cfg = {'side': 'left'}
        self.button_first = tk.Button(frame_time,
                                      text='|<',
                                      command=lambda: self.set_timestep(0),
                                      width=3)
        self.button_first.pack(**button_cfg)
        self.button_prev = tk.Button(
            frame_time,
            text='<',
            command=lambda: self.set_timestep(self.var_curtimestep.get() - 1),
            width=3)
        self.button_prev.pack(**button_cfg)
        self.button_play = tk.Button(frame_time,
                                     text='|>',
                                     command=self.play,
                                     width=3)
        self.button_play.pack(**button_cfg)
        self.button_next = tk.Button(
            frame_time,
            text='>',
            command=lambda: self.set_timestep(self.var_curtimestep.get() + 1),
            width=3)
        self.button_next.pack(**button_cfg)
        self.button_last = tk.Button(
            frame_time,
            text='>|',
            command=lambda: self.set_timestep(self.vtk.data.num_times - 1),
            width=3)
        self.button_last.pack(**button_cfg)

        tk.Label(frame_time, text='time:').pack(side='left', padx=10)
        self.var_curtime = tk.DoubleVar()
        self.var_curtime.set(0.0)
        tk.Label(frame_time,
                 textvariable=self.var_curtime,
                 relief='sunken',
                 width=10).pack(side='left')

        tk.Label(frame_time, text='timestep:').pack(side='left', padx=10)
        self.var_curtimestep = tk.IntVar()
        self.var_curtimestep.set('0')
        command_val_int = (self.parent.register(validate_int), '%d', '%i',
                           '%P', '%s', '%S', '%v', '%V', '%W')
        self.entry_timestep = tk.Entry(frame_time,
                                       text=self.var_curtimestep,
                                       validate='key',
                                       validatecommand=command_val_int,
                                       relief='sunken',
                                       width=10,
                                       justify='right')
        self.entry_timestep.pack(side='left')
        self.string_timestep = tk.StringVar()
        self.label_timestep = tk.Label(frame_time,
                                       textvariable=self.string_timestep)
        self.label_timestep.pack(side='left')
        self.button_go = tk.Button(frame_time,
                                   text='go',
                                   command=self.timestep_modified)
        self.button_go.pack(side='left')

        self.clear()
        self.init_kshortcuts()
コード例 #28
0
z_button.bind("<Button-3>", lambda e: buttonEvent(e, 2))

for i in (quit_button, capture_button, x_button, y_button, z_button):
    i.pack(side="left", expand="true", fill="both")

# Create the render widget
renderer_frame = Tkinter.Frame(display_frame)
renderer_frame.pack(padx=3,
                    pady=3,
                    side="left",
                    anchor="n",
                    fill="both",
                    expand="false")

render_widget = vtkTkRenderWindowInteractor(renderer_frame,
                                            rw=renWin,
                                            width=600,
                                            height=600)
for i in (render_widget, display_frame):
    i.pack(side="top", anchor="n", fill="both", expand="false")

# Add a slice scale to browse the current slice stack
slice_number = Tkinter.IntVar()
slice_number.set(current_widget.GetSliceIndex())
slice = Tkinter.Scale(top,
                      from_=zMin,
                      to=zMax,
                      orient="horizontal",
                      command=SetSlice,
                      variable=slice_number,
                      label="Slice")
slice.pack(fill="x", expand="false")
コード例 #29
0
ファイル: DisplayBlockMesh.py プロジェクト: minhbau/PyFoam
    def run(self):
        doImports()

        self.renWin = vtk.vtkRenderWindow()
        self.ren = vtk.vtkRenderer()
        self.renWin.AddRenderer(self.ren)
        self.renWin.SetSize(600, 600)
        self.ren.SetBackground(0.7, 0.7, 0.7)
        self.ren.ResetCamera()
        self.cam = self.ren.GetActiveCamera()

        self.axes = vtk.vtkCubeAxesActor2D()
        self.axes.SetCamera(self.ren.GetActiveCamera())

        self.undefinedActor=vtk.vtkTextActor()
        self.undefinedActor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay()
        self.undefinedActor.GetPositionCoordinate().SetValue(0.05,0.2)
        self.undefinedActor.GetTextProperty().SetColor(1.,0.,0.)
        self.undefinedActor.SetInput("")

        try:
            self.readFile()
        except Exception:
            e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e'
            warning("While reading",self.parser.getArgs()[0],"this happened:",e)
            raise e

        self.ren.ResetCamera()

        self.root = tkinter.Tk()
        self.root.withdraw()

        # Create the toplevel window
        self.top = tkinter.Toplevel(self.root)
        self.top.title("blockMesh-Viewer")
        self.top.protocol("WM_DELETE_WINDOW", self.quit)

        # Create some frames
        self.f1 = tkinter.Frame(self.top)
        self.f2 = tkinter.Frame(self.top)

        self.f1.pack(side="top", anchor="n", expand=1, fill="both")
        self.f2.pack(side="bottom", anchor="s", expand="f", fill="x")

        # Create the Tk render widget, and bind the events
        self.rw = vtkTkRenderWindowInteractor(self.f1, width=400, height=400, rw=self.renWin)
        self.rw.pack(expand="t", fill="both")

        self.blockHigh=tkinter.IntVar()
        self.blockHigh.set(-1)

        self.oldBlock=-1
        self.blockActor=None
        self.blockTextActor=None

        self.patchHigh=tkinter.IntVar()
        self.patchHigh.set(-1)

        self.oldPatch=-1
        self.patchActor=None
        self.patchTextActor=vtk.vtkTextActor()
        self.patchTextActor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay()
        self.patchTextActor.GetPositionCoordinate().SetValue(0.05,0.1)
        self.patchTextActor.GetTextProperty().SetColor(0.,0.,0.)
        self.patchTextActor.SetInput("Patch: <none>")

        self.scroll=tkinter.Scale(self.f2,orient='horizontal',
                                  from_=-1,to=len(self.blocks)-1,resolution=1,tickinterval=1,
                                  label="Block (-1 is none)",
                                  variable=self.blockHigh,command=self.colorBlock)

        self.scroll.pack(side="top", expand="t", fill="x")

        self.scroll2=tkinter.Scale(self.f2,orient='horizontal',
                                   from_=-1,to=len(list(self.patches.keys()))-1,resolution=1,tickinterval=1,
                                   label="Patch (-1 is none)",
                                   variable=self.patchHigh,command=self.colorPatch)

        self.scroll2.pack(side="top", expand="t", fill="x")

        self.f3 = tkinter.Frame(self.f2)
        self.f3.pack(side="bottom", anchor="s", expand="f", fill="x")

        self.b1 = tkinter.Button(self.f3, text="Quit", command=self.quit)
        self.b1.pack(side="left", expand="t", fill="x")
        self.b2 = tkinter.Button(self.f3, text="Reread blockMeshDict", command=self.reread)
        self.b2.pack(side="left", expand="t", fill="x")

        self.root.update()

        self.iren = self.renWin.GetInteractor()
        self.istyle = vtk.vtkInteractorStyleSwitch()

        self.iren.SetInteractorStyle(self.istyle)
        self.istyle.SetCurrentStyleToTrackballCamera()

        self.addProps()

        self.iren.Initialize()
        self.renWin.Render()
        self.iren.Start()

        self.root.mainloop()
コード例 #30
0
ファイル: pyScout.py プロジェクト: yidilozdemir/freesurfer
    def InitializeGUI(self, w, h):

        self.top = Tkinter.Toplevel(self.root)

        # make sure exit happens gracefully
        def quit(obj=self.root):
            obj.quit()

        self.top.protocol("WM_DELETE_WINDOW", quit)

        self.frmDisplay = Tkinter.Frame(self.top)
        self.frmRender = Tkinter.Frame(self.frmDisplay)

        for f in (self.frmDisplay, self.frmRender):
            f.pack(padx=3,
                   pady=3,
                   side="top",
                   anchor="n",
                   fill="both",
                   expand="false")

        rwi = vtkTkRenderWindowInteractor(self.frmRender,
                                          rw=Globals.renWin,
                                          width=w,
                                          height=h)
        rwi.pack()
        rwi.Render()
        self.renderWidget = rwi
        self.root.update()

        frmModes = Tkinter.Frame(self.top)
        frmModes.pack()

        self.radioVar = Tkinter.IntVar()
        self.radioVar.set(0)

        self.dicGuiModes = {
            0: "Navigation",
            1: "Add Region",
            2: "Laplace",
            3: "Profile Inspector",
            4: "Highlight",
            5: "Delete Region"
        }

        for k in self.dicGuiModes.keys():
            Tkinter.Radiobutton(frmModes,
                                text=self.dicGuiModes[k],
                                variable=self.radioVar,
                                value=k,
                                command=self.ChangeMode).pack(side="left")

        # Add a slice scale to browse the current slice stack
        sliceNumber = Tkinter.IntVar()
        smin, smax = Globals.imagePipeline.GetAxisExtent()
        sliceNumber.set(Globals.imagePipeline.GetSliceIndex())

        self.scaleSlice = Tkinter.Scale(self.top,
                                        from_=smin,
                                        to=smax,
                                        orient="horizontal",
                                        command=self.SetSlice,
                                        variable=sliceNumber,
                                        label="Slice")
        self.scaleSlice.pack(fill="x", expand="false")

        self.SetupMenubar()
コード例 #31
0
ファイル: main.py プロジェクト: capitalaslash/radcal-gui
    def __init__(self, parent, config):
        self.config = config
        tk.Frame.__init__(self, parent)
        self.parent = parent
        parent.wm_title('radcal-gui')
        self.pack(fill='both', expand=1)

        # left section
        self.frame_dir = tk.Frame(self)
        self.frame_dir.pack(side='left', fill='y', expand=0)

        tk.Button(self.frame_dir, text='Open...',
          command=self.open_dir).pack(side='top')

        tk.Label(self.frame_dir, text='current directory:', anchor='w', width=30).pack(side='top')
        self.var_dirname = tk.StringVar()
        tk.Label(self.frame_dir, textvariable=self.var_dirname, anchor='w', width=30).pack(side='top')

        self.list_file = tk.Listbox(self.frame_dir, selectmode='browse')
        self.list_file.bind('<<ListboxSelect>>', self.file_modified)
        self.list_file.pack(fill='x')

        # main section
        self.frame_main = tk.Frame(self)
        self.frame_main.pack(fill='both', expand=1)

        # top section
        self.frame_file = tk.Frame(self.frame_main, bd=1, relief='sunken')
        self.frame_file.pack(fill='x', expand=0)

        tk.Button(self.frame_file, text='Open file',
          command=self.open_file).pack(side='left')

        self.var_filename = tk.StringVar()
        tk.Label(self.frame_file, textvariable=self.var_filename).pack(side='left')

        # middle section
        frame_main = tk.Frame(self.frame_main)
        frame_main.pack(fill='both', expand=1)

        ren_win = vtk.vtkRenderWindow()
        iren = vtkTkRenderWindowInteractor(frame_main, rw=ren_win,
            width=600, height=600)
        self.vtk = vtkgui.VtkGui(iren)
        iren.pack(side='left', fill='both', expand=1)

        frame_control = tk.Frame(frame_main)
        frame_control.pack(side='left')

        frame_dim = tk.Frame(frame_control)
        frame_dim.pack(fill='x', expand=0)
        self.var_dim = tk.IntVar()
        self.var_dim.set(3)
        tk.Radiobutton(frame_dim, text='2D', variable=self.var_dim,
          value=2, command=self.dim_modified).pack(side='left', fill='x', expand=1)
        tk.Radiobutton(frame_dim, text='3D', variable=self.var_dim,
          value=3, command=self.dim_modified).pack(side='right', fill='x', expand=1)

        self.button_render = tk.Button(frame_control, text='Render',
            command=self.render, state='disabled')
        self.button_render.pack(fill='x', expand=0)

        self.button_clear = tk.Button(frame_control, text='Clear',
            command=self.clear)
        self.button_clear.pack(fill='x', expand=0)

        self.var_scalarbar = tk.IntVar()
        self.check_scalarbar = tk.Checkbutton(frame_control, text='Scalar Bar',
            variable=self.var_scalarbar, command=self.scalarbar_modified)
        self.check_scalarbar.pack(fill='x')

        self.var_contour = tk.IntVar()
        self.check_contour = tk.Checkbutton(frame_control, text='Contour',
            variable=self.var_contour, command=self.contour_modified)
        self.check_contour.pack(fill='x')

        tk.Label(frame_control, text='Variables:').pack()
        self.list_var = tk.Listbox(frame_control, selectmode='browse')
        self.list_var.bind('<<ListboxSelect>>', self.var_modified)
        self.list_var.pack(fill='x')

        tk.Label(frame_control, text='Probing line:').pack()
        self.frame_probe = tk.Frame(frame_control)
        self.frame_probe.pack(fill='x',expand=1)

        command_val_float = (self.parent.register(validate_float),
            '%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W')

        self.var_coord = tk.StringVar()
        # self.var_coord.set('x')

        coord_tab = [ 'x', 'y', 'z' ]

        counter=0
        self.entry_coord = {}
        self.radio_coord = {}
        self.label_coord = {}
        for c in coord_tab:
            self.radio_coord[c] = tk.Radiobutton(self.frame_probe, text=c,
                variable=self.var_coord, value=c, command=self.coord_modified)
            self.radio_coord[c].grid(row=counter, column=0)
            self.entry_coord[c] = tk.Entry(self.frame_probe,
                validate='key', validatecommand=command_val_float)
            self.entry_coord[c].grid(row=counter, column=1)
            self.label_coord[c] = tk.StringVar()
            tk.Label(self.frame_probe, textvariable=self.label_coord[c]).grid(row=counter, column=2)
            counter += 1

        self.var_timeplot = tk.IntVar()
        self.check_timeplot = tk.Checkbutton(self.frame_probe, text='time plot',
            variable=self.var_timeplot, command=self.timeplot_modified,
            state='disabled')
        self.check_timeplot.grid(row=3, column=0, columnspan=2)

        # bottom section
        self.frame_control = tk.Frame(self.frame_main, bd=1, relief='sunken')
        self.frame_control.pack(fill='x', expand=0)
        tk.Button(self.frame_control, text='Quit', command=self.parent.quit, padx=5, pady=5).pack(side='right')
        tk.Button(self.frame_control, text='Save', command=self.write, padx=5, pady=5).pack(side='right')
        tk.Button(self.frame_control, text='Print', command=self.screenshot, padx=5, pady=5).pack(side='right')
        frame_time = tk.Frame(self.frame_control)
        frame_time.pack(side='left')

        button_cfg = {
            'side': 'left'
        }
        self.button_first = tk.Button(frame_time, text='|<',
            command=lambda: self.set_timestep(0), width=3)
        self.button_first.pack(**button_cfg)
        self.button_prev = tk.Button(frame_time, text='<',
            command=lambda: self.set_timestep(self.var_curtimestep.get()-1), width=3)
        self.button_prev.pack(**button_cfg)
        self.button_play = tk.Button(frame_time, text='|>',
            command=self.play, width=3)
        self.button_play.pack(**button_cfg)
        self.button_next = tk.Button(frame_time, text='>',
            command=lambda: self.set_timestep(self.var_curtimestep.get()+1), width=3)
        self.button_next.pack(**button_cfg)
        self.button_last = tk.Button(frame_time, text='>|',
            command=lambda: self.set_timestep(self.vtk.data.num_times-1), width=3)
        self.button_last.pack(**button_cfg)

        tk.Label(frame_time, text='time:').pack(side='left', padx=10)
        self.var_curtime = tk.DoubleVar()
        self.var_curtime.set(0.0)
        tk.Label(frame_time, textvariable=self.var_curtime, relief='sunken', width=10).pack(side='left')

        tk.Label(frame_time, text='timestep:').pack(side='left', padx=10)
        self.var_curtimestep = tk.IntVar()
        self.var_curtimestep.set('0')
        command_val_int = (self.parent.register(validate_int),
            '%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W')
        self.entry_timestep = tk.Entry(frame_time, text=self.var_curtimestep,
            validate='key', validatecommand=command_val_int, relief='sunken',
            width=10, justify='right')
        self.entry_timestep.pack(side='left')
        self.string_timestep = tk.StringVar()
        self.label_timestep = tk.Label(frame_time,
            textvariable=self.string_timestep)
        self.label_timestep.pack(side='left')
        self.button_go = tk.Button(frame_time, text='go',
            command=self.timestep_modified)
        self.button_go.pack(side='left')

        self.clear()
        self.init_kshortcuts()
コード例 #32
0
tk.Grid.columnconfigure(frame_sbu,0,weight=1)
tk.Grid.columnconfigure(frame_sbu,1,weight=1)
tk.Grid.rowconfigure(frame_sbu,0,weight=1)
tk.Grid.columnconfigure(frame_disp,0,weight=1)
tk.Grid.rowconfigure(frame_disp,0,weight=1)
tk.Grid.columnconfigure(frame_link,0,weight=1)
tk.Grid.rowconfigure(frame_link,0,weight=1)
tk.Grid.columnconfigure(frame_cent,0,weight=1)
tk.Grid.rowconfigure(frame_cent,0,weight=1)
tk.Grid.columnconfigure(root,0,weight=1)

#creation of renderers for 3D visualization
ren_disp = vtkRenderer()                                #for the created mofs
renWin_disp = vtkRenderWindow()       
renWin_disp.AddRenderer(ren_disp)
disp_widget = vtkTkRenderWindowInteractor(frame_disp,rw=renWin_disp)
disp_widget.grid(row=0,column=0, sticky='n'+'s'+'e'+'w')
disp_widget.Initialize()
disp_widget.AddObserver("StartPickEvent", functionalize)
disp_widget.Start()

ren_cent = vtkRenderer()                                #for the selected center
renWin_cent = vtkRenderWindow()
renWin_cent.AddRenderer(ren_cent)
center_widget = vtkTkRenderWindowInteractor(frame_cent,rw=renWin_cent)
center_widget.grid(row=0,column=0, sticky='n'+'s'+'e'+'w')
center_widget.Initialize()
center_widget.Start()

ren_link = vtkRenderer()                                 #for the selected linker
renWin_link = vtkRenderWindow()
コード例 #33
0
mapper = vtk.vtkPolyDataMapper()
actor = vtk.vtkActor()


mapper.SetInputConnection(cube.GetOutputPort())
actor.SetMapper(mapper)
#
render = vtk.vtkRenderer()
#render.SetBackground(val,val,val)
render.AddActor(actor)


renWindow = vtk.vtkRenderWindow()
renWindow.AddRenderer(render)

renWinInteract = vtkTkRenderWindowInteractor(root,rw=renWindow, width=400, height=400)                   
renWinInteract.Initialize()
renWinInteract.pack(side='top', fill='both', expand=1)


def change_background(num):
    val = float("{0:.2f}".format(slider.get()/255))
    label.config(text=str(val))
    #render.SetBackground(val,val,val)
    actor.GetProperty().SetColor(val,0,val)
    renWindow.Render()

#Slider to change the background colour of the renderer
slider = Scale(root,from_=0, to_=255, orient = HORIZONTAL,command=change_background,label="BG_COL")
#slider = Scale(root,from_=0, to_=255, orient = HORIZONTAL)
slider.set(0)
コード例 #34
0
ファイル: CubeSection.py プロジェクト: Magellen/mystic
def Cut(v):
    Q = (P[0], P[1], v)
    cp = CuttingPlane(*Q)
    pn = PlaneNormal(*Q)
    clipper.SetClipFunction(cp)
    clipper.SetValue(0)
    cutEdges.SetCutFunction(cp)
    cutEdges.SetValue(0, 0)
    cutStrips.Update()
    cutPoly.SetPoints(cutStrips.GetOutput().GetPoints())
    cutPoly.SetPolys(cutStrips.GetOutput().GetLines())
    cutMapper.Update()
    renWin.Render()
 
root = tkinter.Tk()
vtkw = vtkTkRenderWindowInteractor(root, rw=renWin, width=800)

def set_cut(sz):
    sz = float(sz)
    # print(ren.GetActiveCamera())
    Cut(sz)

# propagate this GUI setting to the corresponding VTK object.
size_slider = tkinter.Scale(root, from_=0.0,
                            to=2.0, res=0.01,
                            orient='horizontal', label="Clipping Center", 
                            command=set_cut)

size_slider.set(P[2])
vtkw.Initialize()
size_slider.pack(side="top", fill="both")
コード例 #35
0
def Main():
    global datamin, datamax, lut, renWin

    # Load bathymetry dataset
    bathymetryReader = vtk.vtkStructuredPointsReader()
    bathymetryReader.SetFileName(sys.argv[1])
    bathymetryReader.Update()
    r = bathymetryReader.GetOutput().GetPointData().GetScalars().GetRange()
    datamin = r[0]
    datamax = r[1]

    loadContinuousFile(sys.argv[2])
    loadDiscreteFile(sys.argv[3])

    # Setup color mapping
    lut = vtk.vtkColorTransferFunction()
    lut.SetColorSpaceToHSV()

    # Load bathymetry data into Geometry Filter
    geometry = vtk.vtkImageDataGeometryFilter()
    geometry.SetInputConnection(bathymetryReader.GetOutputPort())

    mapper = vtk.vtkDataSetMapper()
    mapper.SetInputConnection(geometry.GetOutputPort())
    mapper.SetLookupTable(lut)
    mapper.ImmediateModeRenderingOff()

    # Setup color mapping bar
    colorBar = vtkScalarBarActor()
    colorBar.SetLookupTable(mapper.GetLookupTable())
    colorBar.SetTitle("color map")
    colorBar.SetNumberOfLabels(6)
    colorBar.SetLabelFormat("%4.0f")
    colorBar.SetPosition(0.9, 0.1)
    colorBar.SetWidth(0.07)
    colorBar.SetHeight(0.8)

    actor = vtk.vtkActor()
    actor.SetMapper(mapper)

    # Create renderer stuff
    ren = vtk.vtkRenderer()
    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(ren)
    renWin.SetSize(1280, 800)

    # Add the actors to the renderer, set the background and size
    ren.AddActor(actor)
    ren.AddActor(colorBar)
    ren.ResetCamera()
    ren.SetBackground(0, 0, 0)
    ren.ResetCameraClippingRange()

    root = Tkinter.Tk()
    root.title('Task 2. MRI Data')
    frame = Tkinter.Frame(root)
    frame.pack(fill=Tkinter.BOTH, expand="false", side=Tkinter.TOP)

    mode = Tkinter.IntVar()
    mode.set(1)
    Tkinter.Radiobutton(frame,
                        text="Continuous color map",
                        padx=20,
                        variable=mode,
                        value=1,
                        command=showContinuous).pack(anchor=Tkinter.W)
    Tkinter.Radiobutton(frame,
                        text="Discrete color map",
                        padx=20,
                        variable=mode,
                        value=2,
                        command=showDiscrete).pack(anchor=Tkinter.W)

    # Setup for rendering window interactor
    renWinInteract = vtkTkRenderWindowInteractor(frame,
                                                 rw=renWin,
                                                 width=1280,
                                                 height=800)

    # Specify interaction with 2D image
    style = vtk.vtkInteractorStyleImage()
    style.SetInteractionModeToImage2D()
    renWinInteract.SetInteractorStyle(style)

    renWinInteract.Initialize()
    renWinInteract.pack(side='top', fill='both', expand="false")
    renWinInteract.Start()

    updateUI(0)
    renWin.Render()

    root.mainloop()