#!/usr/bin/env python
#
# $Id: ConfigVtkObj.py,v 1.30 2005/08/02 18:30:14 prabhu_r Exp $
#
# This python program/module takes a VTK object and provides a GUI
# configuration for it.
#
# This code is distributed under the conditions of the BSD license.
# See LICENSE.txt for details.
#
# Copyright (c) 2000-2002, Prabhu Ramachandran.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
# PURPOSE. See the above copyright notice for more information.
#
# Author contact information:
# Prabhu Ramachandran <prabhu_r@users.sf.net>
# http://www.aero.iitm.ernet.in/~prabhu/
""" This program/module takes a VTK object and provides a GUI
configuration for it. Right now Tkinter is used for the GUI.
"""
import vtkMethodParser
import types, string, re
try:
import Tkinter
except ImportError:
print "Cannot import the Tkinter module. Install it and try again."
sys.exit (1)
try:
import tkMessageBox
import tkColorChooser
except ImportError:
print "Cannot import the tkMessageBox or tkColorChooser module."
print "Install the modules and try again."
sys.exit (1)
print_info = tkMessageBox.showinfo
def print_err (msg):
tkMessageBox.showerror ("ERROR", msg)
# use this to print stuff for the user command run from the GUI
def prn (x):
print x
def tk_2_vtk_color (tk_col):
"Converts a Tk RGB color to a VTK RGB color."
ONE_255 = 1.0/255.0
return (tk_col[0]*ONE_255, tk_col[1]*ONE_255, tk_col[2]*ONE_255)
class VtkShowDoc:
""" This class displays the documentation included in the __doc__
attribute of the VTK object and its methods."""
def __init__ (self, master=None):
self.master = master
def check_obj (self):
try:
self.obj.GetClassName ()
except AttributeError:
msg = "Sorry! The object passed does not seem to be a "\
"VTK object!!"
print_err (msg)
return 0
try:
doc_ = self.obj.__doc__
except AttributeError:
msg = "Sorry! This particular version of the VTK-Python "\
"bindings does not feature embedded documentation "\
"of the class and its methods. Please use a more "\
"up to date version of VTK."
print_err (msg)
return 0
else:
return 1
def show_doc (self, vtk_obj):
self.obj = vtk_obj
if self.check_obj ():
self.setup ()
self.add_doc ()
def setup (self):
self.root = Tkinter.Toplevel (self.master)
self.root.title ("Class Documentation for %s"%
self.obj.GetClassName ())
self.root.protocol ("WM_DELETE_WINDOW", self.quit)
f = Tkinter.Frame (self.root)
f.pack (side='top', fill='both', expand=1)
f.rowconfigure (0, weight=1)
f.columnconfigure (0, weight=1)
scr1 = Tkinter.Scrollbar (f, orient='vertical')
scr2 = Tkinter.Scrollbar (f, orient='horizontal')
self.txt = Tkinter.Text (f, yscrollcommand=scr1.set,
xscrollcommand=scr2.set,state='normal')
scr1.config (command=self.txt.yview)
scr2.config (command=self.txt.xview)
self.txt.grid (row=0, column=0, sticky='ewns')
scr1.grid (row=0, column=1, sticky='ns')
scr2.grid (row=1, column=0, columnspan=2, sticky='ew')
self.close_but = Tkinter.Button (self.root, text="Close", fg="red",
underline=0, command=self.quit)
self.close_but.pack (side='bottom')
self.root.bind ("<Alt-c>", self.quit)
self.txt.tag_config ("heading", foreground="blue",
underline=1, justify='center')
self.txt.tag_config ("subheading", foreground="blue",
underline=1, justify='left')
self.txt.tag_config ("item", underline=1, justify='left')
self.txt.tag_config ("data", wrap='word')
def add_doc (self):
data_ = self.obj.GetClassName ()
self.txt.insert ('end', "Class Documentation for %s\n\n"%data_,
"heading")
data_ = self.obj.__doc__ + "\n\n"
self.txt.insert ('end', data_, "data")
data_ = "Please note that all the documented methods are not "\
"configurable using the GUI provided.\n\n\n"
self.txt.insert ('end', data_, "data")
data_ = "Class method documentation:\n\n"
self.txt.insert ('end', data_, "subheading")
for i in dir (self.obj):
if i == '__class__':
continue
try:
data_ = eval ("self.obj.%s.__doc__"%i)
except AttributeError:
pass
else:
self.txt.insert ('end', i + ":\n", "item")
self.txt.insert ('end', data_ +"\n\n", "data")
def quit (self, event=None):
self.root.destroy ()
class ConfigVtkObjFrame(Tkinter.Frame):
""" This class finds the methods for a given vtkObject and creates
a GUI to configure the object. It uses the output from the
VtkMethodParser class. It is subclassed from Tkinter.Frame so that
it can be embedded inside another widget."""
def __init__(self, master, renwin=None):
Tkinter.Frame.__init__(self, master)
self.renwin = renwin
self.parser = vtkMethodParser.VtkMethodParser ()
self.state_patn = re.compile ("To[A-Z0-9]")
self.update_meth = None
self.vtk_obj = None
def _parse_methods (self, vtk_obj):
self.parser.parse_methods (vtk_obj)
self.toggle_meths = self.parser.toggle_methods ()
self.state_meths = self.parser.state_methods ()
self.get_set_meths = self.parser.get_set_methods ()
self.get_meths = self.parser.get_methods ()
def _get_state (self, meths):
end = self.state_patn.search (meths[0]).start ()
get_m = 'G'+meths[0][1:end]
orig = eval ("self.vtk_obj.%s()"%get_m)
for i in range (len(meths)):
m = meths[i]
eval ("self.vtk_obj.%s()"%m)
val = eval ("self.vtk_obj.%s()"%get_m)
if val == orig:
break
return i
def _select_methods(self, get, toggle, state, get_set):
""" Selects or eliminates certain methods from being
configured. get, toggle, state and get_set are lists
containing strings that are methods that one wants in the GUI
or if the name is preprended with a '^' or '!' then those
methods are removed from the default list. You obviously
cannot mix the negative and the positive selection (and
neither does it make sense)! So ['!AAA', 'BBB'] will simply
unselect AAA and enable *everything* else. """
def _choose_meths(from_arr, in_arr):
# remove methods if needed.
removed = 0
for i in in_arr:
if i[0] in ['!', '^']:
removed = 1
if i[1:] in from_arr:
from_arr.remove(i[1:])
if removed:
return
tmp = from_arr[:]
from_arr[:] = []
for i in in_arr:
if i in tmp:
from_arr.append(i)
if get == []:
self.get_meths = []
elif get:
_choose_meths(self.get_meths, get)
if toggle == []:
self.toggle_meths = []
elif toggle:
_choose_meths(self.toggle_meths, toggle)
if state == [] or state:
self.state_meths = state
# Remove Get/SetProgress since its completely useless
if 'Progress' in self.get_set_meths:
self.get_set_meths.remove('Progress')
if get_set == []:
self.get_set_meths = []
elif get_set:
_choose_meths(self.get_set_meths, get_set)
def _make_gui (self, one_frame=0):
"Makes the configuration GUI."
frame = Tkinter.Frame (self)
frame.pack (side='top', expand=1, fill='both')
if one_frame:
left = frame
right = frame
else:
left = Tkinter.Frame (frame)
left.grid (row=0, column=0, sticky='nw')
right = Tkinter.Frame (frame)
right.grid (row=0, column=1, sticky='nw')
self._make_gui_vars ()
self._make_toggle_gui (left)
self._make_state_gui (left)
self._make_get_gui (right)
self._make_get_set_gui (right)
def _make_gui_vars (self):
"Create the various variables used for the GUI."
self.toggle_var = []
for i in range (0, len (self.toggle_meths)):
self.toggle_var.append (Tkinter.IntVar ())
self.toggle_var[i].set (-1)
self.state_var = []
for i in range (0, len (self.state_meths)):
self.state_var.append (Tkinter.IntVar ())
self.state_var[i].set (-1)
self.get_set_var = []
for i in range (0, len (self.get_set_meths)):
self.get_set_var.append (Tkinter.StringVar ())
self.get_set_var[i].set ("")
self.get_lab = []
for i in range (0, len (self.get_meths)):
self.get_lab.append (None)
def _make_toggle_gui (self, master):
"Create the toggle methods. (On/Off methods)"
n_meth = len (self.toggle_meths)
if not n_meth:
return
frame = Tkinter.Frame (master, relief='ridge', bd=2)
frame.pack (side='top', expand=1, fill='both')
for i in range (0, n_meth):
m = "Get"+self.toggle_meths[i][:-2]
self.toggle_var[i].set (eval ("self.vtk_obj.%s ()"%m))
b = Tkinter.Checkbutton (frame, text=self.toggle_meths[i],
variable=self.toggle_var[i],
onvalue=1, offvalue=0,
command=lambda s=self, index=i:
s._toggle_changed(index))
b.grid (row=i, column=0, sticky='w')
def _make_state_gui (self, master):
"Create the state methods. (SetAToB methods)"
n_meth = len (self.state_meths)
if not n_meth:
return
frame = Tkinter.Frame (master, relief='ridge', bd=2)
frame.pack (side='top', expand=1, fill='both')
rw = 0
for i in range (0, n_meth):
meths = self.state_meths[i]
self.state_var[i].set (self._get_state (meths))
for j in range (0, len (meths)):
b = Tkinter.Radiobutton (frame, text=meths[j],
variable=self.state_var[i],
value=j,
command=lambda s=self, index=i:
s._state_changed(index))
b.grid (row=rw, column=0, sticky='w')
rw = rw + 1
def _make_get_set_gui (self, master):
"Create the Get/Set methods"
n_meth = len (self.get_set_meths)
if not n_meth:
return
frame = Tkinter.Frame (master, relief='ridge', bd=2)
frame.pack (side='top', expand=1, fill='both')
for i in range (0, n_meth):
m = "Get"+self.get_set_meths[i]
self.get_set_var[i].set (str (eval ("self.vtk_obj.%s ()"%m)))
# if the method requires a color make a button so the user
# can choose the color!
if string.find (m[-5:], "Color") > -1:
but = Tkinter.Button (frame, text="Set"+m[3:],
textvariable=i,
command=lambda e: None, padx=1)
but.grid (row=i, column=0, sticky='w')
but.bind ("<1>", self._set_color)
else:
lab = Tkinter.Label (frame, text="Set"+m[3:])
lab.grid (row=i, column=0, sticky='w')
entr = Tkinter.Entry (frame, width=20, relief='sunken',
textvariable=self.get_set_var[i])
entr.grid (row=i, column=1, sticky='ew')
entr.bind ("<Return>", lambda e=None, s=self, index=i:
s._get_set_changed(index))
def _make_get_gui (self, master):
"Create the Get methods that have no Set equivalent."
n_meth = len (self.get_meths)
if not n_meth:
return
frame = Tkinter.Frame (master, relief='ridge', bd=2)
frame.pack (side='top', expand=1, fill='both')
for i in range (0, n_meth):
res = str (eval ("self.vtk_obj.%s ()"% self.get_meths[i]))
lab = Tkinter.Label (frame, text=self.get_meths[i]+": ")
lab.grid (row=i, column=0, sticky='w')
self.get_lab[i] = Tkinter.Label (frame, text=res)
self.get_lab[i].grid (row=i, column=1, sticky='w')
def _set_color (self, event=None):
"Choose and set a color from a GUI color chooser."
if event is None:
return "break"
# index of the relevant method is stored in the textvariable.
index = int (str(event.widget['textvariable']))
m = "Get"+self.get_set_meths[index]
col = eval ("self.vtk_obj.%s ()"%m)
cur_col = "#%02x%02x%02x"% (col[0]*255, col[1]*255, col[2]*255)
new_color = tkColorChooser.askcolor (title="Set"+m[3:],
initialcolor=cur_col)
if new_color[1] != None:
col = tk_2_vtk_color (new_color[0])
self.get_set_var[index].set (str (col))
m = "Set"+self.get_set_meths[index]
getattr(self.vtk_obj, m)(*col)
self.update_gui ()
return "break"
def _toggle_changed(self, index):
"""One of the toggle buttons was clicked."""
if not self.auto_update:
return
val = self.toggle_var[index].get()
m = self.toggle_meths[index][:-2]
if val == 1:
getattr(self.vtk_obj, '%sOn'%m)()
else:
getattr(self.vtk_obj, '%sOff'%m)()
self.render ()
def _state_changed(self, index):
"""One of the state buttons was clicked."""
if not self.auto_update:
return
val = self.state_var[index].get()
m = self.state_meths[index][val]
if val != -1:
getattr(self.vtk_obj, "%s"%m)()
self.render ()
def _get_set_changed(self, index):
"""One of the get_set entries were changed."""
if not self.auto_update:
return
var = self.get_set_var[index]
val = var.get()
m = self.get_set_meths[index]
if string.find (val, "(") == 0:
val = val[1:-1]
st = 0
val_tst = eval ("self.vtk_obj.Get%s ()"%m)
if type (val_tst) is types.StringType:
st = 1
m = "Set" + m
if st is 0:
eval ("self.vtk_obj.%s (%s)"%(m, val))
else:
eval ("self.vtk_obj.%s (\"%s\")"%(m, val))
self.render ()
def configure(self, vtk_obj, get=None, toggle=None, state=None,
get_set=None, one_frame=0, auto_update=0):
"""Configure the vtk_object passed and create the
configuration widgets in self. This class is a subclass of
Tkinter.Frame.
Input Arguments:
vtk_obj -- VTK object to configure.
get -- The Get* methods to display. Defaults to None where
all the options are displayed. Provide an empty list if you
do not want these to be displayed at all. If the method
name is preprended with a '^' or '!' then those methods are
removed from the default list. You obviously cannot mix the
negative and the positive selection (and neither does it
make sense)! So ['!AAA', 'BBB'] will simply unselect AAA
and enable *everything* else. To specify a VTK method
'GetGoo' you must specify 'GetGoo' or '!GetGoo' or
'^GetGoo'.
toggle -- The SetValueOn/Off type methods to configure.
Defaults to None where all the methods are displayed. To
specify a VTK method 'GooOn' or 'GooOff' you must specify
'GooOn' or '!GooOn' or '^GooOn'.
state -- The SetValueToState type methods to configure
Defaults to None where all the methods are displayed. To
specify a set of VTK method states [['SetGooToMoo',
'SetGooToBoo']] you must pass them as specified. You cannot
specify the methods in the negative i.e. you can only pick
the states you want.
get_set -- The Get/SetValue methods to configure. Defaults
to None where all the methods are displayed. To specify a
VTK method 'Get/SetGoo' you must specify 'Goo' or '!Goo'
or '^Goo'.
one_frame -- If True, put all the GUI elements in one frame
instead of a left and right one. Defaults to 0.
auto_update -- If True, updates the object as soon as the
option is changed. Defaults to 0 when the objects are
updated using the apply_changes method.
"""
self.vtk_obj = vtk_obj
self.auto_update = auto_update
self.vtk_warn = -1
try:
self.vtk_warn = vtk_obj.GetGlobalWarningDisplay ()
except AttributeError:
pass
else:
vtk_obj.GlobalWarningDisplayOff ()
self._parse_methods (vtk_obj)
self._select_methods(get, toggle, state, get_set)
self._make_gui (one_frame)
if self.vtk_warn > -1:
self.vtk_obj.SetGlobalWarningDisplay (self.vtk_warn)
def set_render_window (self, renwin):
self.renwin = renwin
def set_update_method (self, method):
""" This sets a method that the instance will call when any
changes are made."""
self.update_meth = method
def apply_changes (self, event=None):
"Apply the changes made to configuration."
if self.vtk_warn > -1:
self.vtk_obj.GlobalWarningDisplayOff ()
n_meth = len (self.toggle_meths)
for i in range (0, n_meth):
val = self.toggle_var[i].get ()
m = self.toggle_meths[i][:-2]
if val == 1:
eval ("self.vtk_obj.%sOn ()"%m)
else:
eval ("self.vtk_obj.%sOff ()"%m)
n_meth = len (self.state_meths)
for i in range (0, n_meth):
val = self.state_var[i].get ()
m = self.state_meths[i][val]
if val != -1:
eval ("self.vtk_obj.%s ()"%m)
n_meth = len (self.get_set_meths)
for i in range (0, n_meth):
val = self.get_set_var[i].get ()
if string.find (val, "(") == 0:
val = val[1:-1]
st = 0
val_tst = eval ("self.vtk_obj.Get%s ()"% self.get_set_meths[i])
if type (val_tst) is types.StringType:
st = 1
m = "Set"+self.get_set_meths[i]
if st is 0:
eval ("self.vtk_obj.%s (%s)"%(m, val))
else:
eval ("self.vtk_obj.%s (\"%s\")"%(m, val))
n_meth = len (self.get_meths)
for i in range (0, n_meth):
res = str (eval ("self.vtk_obj.%s ()"% self.get_meths[i]))
self.get_lab[i].config (text=res)
self.render ()
if self.vtk_warn > -1:
self.vtk_obj.SetGlobalWarningDisplay (self.vtk_warn)
def render (self):
"Render scene and update anything that needs updating."
if self.update_meth and callable (self.update_meth):
self.update_meth ()
if self.renwin:
try:
self.renwin.Render ()
except:
pass
def update_gui (self, event=None):
"Update the values if anything has changed outside."
if self.vtk_warn > -1:
self.vtk_obj.GlobalWarningDisplayOff ()
n_meth = len (self.toggle_meths)
for i in range (0, n_meth):
m = "Get"+self.toggle_meths[i][:-2]
self.toggle_var[i].set (eval ("self.vtk_obj.%s ()"%m))
for i in range (len (self.state_meths)):
m = self.state_meths[i]
self.state_var[i].set (self._get_state (m))
n_meth = len (self.get_set_meths)
for i in range (0, n_meth):
m = "Get"+self.get_set_meths[i]
self.get_set_var[i].set (str (eval ("self.vtk_obj.%s ()"%m)))
n_meth = len (self.get_meths)
for i in range (0, n_meth):
res = str (eval ("self.vtk_obj.%s ()"% self.get_meths[i]))
self.get_lab[i].config (text=res)
if self.vtk_warn > -1:
self.vtk_obj.GlobalWarningDisplayOn ()
def destroy(self):
Tkinter.Frame.destroy(self)
self.vtk_obj = None
self.renwin = None
self.update_meth = None
class ConfigVtkObj:
""" This class finds the methods for a given vtkObject and creates
a GUI to configure the object. It uses the output from the
VtkMethodParser class and uses the configuration widget from
ConfigVtkObjFrame. """
def __init__ (self, renwin=None):
# This vairable is used to do a redraw on changing the objects
# properties.
self.renwin = renwin
self.config_frame = None
self.vtk_obj = None
def set_render_window (self, renwin):
self.renwin = renwin
if self.config_frame:
self.config_frame.set_render_window(renwin)
def set_update_method (self, method):
""" This sets a method that the instance will call when any
changes are made."""
if self.config_frame:
self.config_frame.set_update_method(method)
def configure (self, master, vtk_obj, get=None, toggle=None, state=None,
get_set=None, one_frame=0, auto_update=0, run_command=1,
class_doc=1):
"""Configure the vtk_object passed using a Toplevel widget.
Input Arguments:
master -- master widget for this toplevel widget.
vtk_obj -- VTK object to configure.
get -- The Get* methods to display. Defaults to None where
all the options are displayed. Provide an empty list if you
do not want these to be displayed at all. If the method
name is preprended with a '^' or '!' then those methods are
removed from the default list. You obviously cannot mix the
negative and the positive selection (and neither does it
make sense)! So ['!AAA', 'BBB'] will simply unselect AAA
and enable *everything* else. To specify a VTK method
'GetGoo' you must specify 'GetGoo' or '!GetGoo' or
'^GetGoo'.
toggle -- The SetValueOn/Off type methods to configure.
Defaults to None where all the methods are displayed. To
specify a VTK method 'GooOn' or 'GooOff' you must specify
'GooOn' or '!GooOn' or '^GooOn'.
state -- The SetValueToState type methods to configure
Defaults to None where all the methods are displayed. To
specify a set of VTK method states [['SetGooToMoo',
'SetGooToBoo']] you must pass them as specified. You cannot
specify the methods in the negative i.e. you can only pick
the states you want.
get_set -- The Get/SetValue methods to configure. Defaults
to None where all the methods are displayed. To specify a
VTK method 'Get/SetGoo' you must specify 'Goo' or '!Goo'
or '^Goo'.
one_frame -- If True, put all the GUI elements in one frame
instead of a left and right one. Defaults to 0.
auto_update -- If True, updates the object as soon as the
option is changed. Defaults to 0 when the objects are
updated only when the OK or Apply buttons are pressed. If
True the OK/Apply/Cancel buttons are replaced with a close
button.
run_command -- If True (default), also generates a Entry to
run arbitrary commands on the object.
class_doc -- If True (default), presents a button that shows
VTK class documentation when clicked.
"""
self.vtk_obj = vtk_obj
self.root = Tkinter.Toplevel (master)
self.root.title ("Configure %s"%self.vtk_obj.GetClassName ())
self.root.protocol ("WM_DELETE_WINDOW", self.cancel)
self.config_frame = ConfigVtkObjFrame(self.root, self.renwin)
self.config_frame.configure(vtk_obj, get, toggle, state, get_set,
one_frame, auto_update)
self.config_frame.pack (side='top', expand=1, fill='both')
self.make_control_gui (self.root, run_command, auto_update,
class_doc)
def make_control_gui (self, master, run_command, auto_update,
class_doc):
"Make the main controls and the user command entry."
frame = Tkinter.Frame (master)
frame.pack (side='bottom', expand=1, fill='both')
rw = 0
self.user_command = Tkinter.StringVar ()
self.user_command.set("")
if run_command:
lab = Tkinter.Label (frame, text="Click on the \"Command\" "\
"button for help on it.")
lab.grid (row=0, column=0, columnspan=4, sticky='ew')
rw += 1
help = Tkinter.Button (frame, text="Command:",
command=self.help_user)
help.grid (row=1, column=0, sticky='ew')
entr = Tkinter.Entry (frame, width=20, relief='sunken',
textvariable=self.user_command)
entr.grid (row=1, column=1, columnspan=3, sticky='ew')
entr.bind ("<Return>", self.run_command)
rw += 1
column = 0
if class_doc:
help_b = Tkinter.Button (frame, text="Class Documentation",
underline=6, command=self.show_doc)
help_b.grid (column=column, row=rw, padx=2, pady=2, sticky='ew')
column += 1
if auto_update:
b2 = Tkinter.Button (frame, text="Close", underline=0,
command=self.cancel)
b2.grid (column=column, row=rw, padx=2, pady=2, sticky='ew')
column += 1
else:
b0 = Tkinter.Button (frame, text="Update", underline=0,
command=self.config_frame.update_gui)
b0.grid (column=column, row=rw, padx=2, pady=2, sticky='ew')
column += 1
b = Tkinter.Button (frame, text="Apply", underline=0,
command=self.config_frame.apply_changes)
b.grid (column=column, row=rw, padx=2, pady=2, sticky='ew')
column += 1
b1 = Tkinter.Button (frame, text="Ok", underline=0,
command=self.ok_done)
b1.grid (column=column, row=rw, padx=2, pady=2, sticky='ew')
column += 1
b2 = Tkinter.Button (frame, text="Cancel", underline=0,
command=self.cancel)
b2.grid (column=column, row=rw, padx=2, pady=2, sticky='ew')
column += 1
rw +=1
# keyboard accelerators
self.root.bind ("<Alt-d>", self.show_doc)
self.root.bind ("<Alt-u>", self.config_frame.update_gui)
self.root.bind ("<Alt-a>", self.config_frame.apply_changes)
self.root.bind ("<Alt-o>", self.ok_done)
self.root.bind ("<Alt-c>", self.cancel)
def run_command (self, event=None):
"""Run the command entered by the user."""
st = self.user_command.get ()
if len (st) == 0:
return self.help_user ()
obj = self.vtk_obj
try:
eval (st)
except AttributeError, msg:
print_err ("AttributeError: %s"%msg)
except SyntaxError, msg:
print_err ("SyntaxError: %s"%msg)
except NameError, msg:
print_err ("NameError: %s"%msg)
except TypeError, msg:
print_err ("TypeError: %s"%msg)
except ValueError, msg:
print_err ("ValueError: %s"%msg)
except:
print_err ("Unhandled exception. Wrong input.")
else:
self.config_frame.render ()
def help_user (self, event=None):
"""Provide help when user clicks the command button."""
msg = "Enter a valid python command. Please note the "\
"following: The name \'obj\' refers to the vtkObject "\
"being configured. Use the function prn(arguments) "\
"to print anything. Use the enter key to run the "\
"command. Example: obj.SetColor(0.1,0.2,0.3)"
print_info ("Help", msg)
def show_doc (self, event=None):
"Show the class documentation."
d = VtkShowDoc (self.root)
d.show_doc (self.vtk_obj)
def ok_done (self, event=None):
"Ok button clicked."
self.config_frame.apply_changes ()
self.root.destroy ()
self.renwin = None
self.vtk_obj = None
self.config_frame = None
def cancel (self, event=None):
"Cancel button clicked."
self.root.destroy ()
self.renwin = None
self.vtk_obj = None
self.config_frame = None
def show (self):
"Print the various methods of the vtkobject."
print "Toggle Methods\n", self.config_frame.toggle_meths
print "State Methods\n", self.config_frame.state_meths
print "Get/Set methods\n", self.config_frame.get_set_meths
print "Get methods\n", self.config_frame.get_meths
if __name__ == "__main__":
import vtk
from vtk.tk import vtkTkRenderWidget
cone = vtk.vtkConeSource()
cone.SetResolution(8)
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInput(cone.GetOutput())
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
axes = vtk.vtkCubeAxesActor2D ()
def quit (event=None):
root.destroy ()
root = Tkinter.Tk ()
wid = vtkTkRenderWidget.vtkTkRenderWidget (root, width=500, height=500)
wid.pack (expand=1, fill='both')
wid.bind ("<KeyPress-q>", quit)
ren = vtk.vtkRenderer()
renWin = wid.GetRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(500,500)
ren.AddActor (coneActor)
ren.AddActor (axes)
axes.SetCamera (ren.GetActiveCamera ())
renWin.Render ()
for obj in (renWin, ren, cone, coneMapper, coneActor, axes):
print "Configuring", obj.GetClassName (), "..."
conf = ConfigVtkObj (renWin)
conf.configure (root, obj)
root.mainloop ()
|