227 lines
7.7 KiB
Python
227 lines
7.7 KiB
Python
"""
|
|
This python module provides functionality to parse the methods of a
|
|
VTK object.
|
|
|
|
Created by Prabhu Ramachandran. Committed in Apr, 2002.
|
|
|
|
"""
|
|
|
|
import string, re, sys
|
|
import types
|
|
|
|
# set this to 1 if you want to see debugging messages - very useful if
|
|
# you have problems
|
|
DEBUG=0
|
|
|
|
def debug(msg):
|
|
if DEBUG:
|
|
print(msg)
|
|
|
|
class VtkDirMethodParser:
|
|
"""Parses the methods from dir(vtk_obj)."""
|
|
|
|
def initialize_methods(self, vtk_obj):
|
|
debug("VtkDirMethodParser:: initialize_methods()")
|
|
|
|
self.methods = dir(vtk_obj)[:]
|
|
# stores the <blah>On methods
|
|
self.toggle_meths = []
|
|
# stores the Set<blah>To<blah> methods
|
|
self.state_meths = []
|
|
# stores the methods that have a Get<blah> and Set<blah>
|
|
# only the <blah> is stored
|
|
self.get_set_meths = []
|
|
# pure get methods
|
|
self.get_meths = []
|
|
self.state_patn = re.compile("To[A-Z0-9]")
|
|
|
|
def parse_methods(self, vtk_obj):
|
|
debug("VtkDirMethodParser:: parse_methods()")
|
|
self.initialize_methods(vtk_obj)
|
|
debug("VtkDirMethodParser:: parse_methods() - initialized methods")
|
|
|
|
for method in self.methods[:]:
|
|
# finding all the methods that set the state.
|
|
if method[:3].find("Set") >= 0 and \
|
|
self.state_patn.search(method) is not None:
|
|
try:
|
|
eval("vtk_obj.Get%s" % method[3:])
|
|
except AttributeError:
|
|
self.state_meths.append(method)
|
|
self.methods.remove(method)
|
|
# finding all the On/Off toggle methods
|
|
elif method[-2:].find("On") >= 0:
|
|
try:
|
|
self.methods.index("%sOff" % method[:-2])
|
|
except ValueError:
|
|
pass
|
|
else:
|
|
self.toggle_meths.append(method)
|
|
self.methods.remove(method)
|
|
self.methods.remove("%sOff" % method[:-2])
|
|
# finding the Get/Set methods.
|
|
elif method[:3].find("Get") == 0:
|
|
set_m = "Set" + method[3:]
|
|
try:
|
|
self.methods.index(set_m)
|
|
except ValueError:
|
|
pass
|
|
else:
|
|
self.get_set_meths.append(method[3:])
|
|
self.methods.remove(method)
|
|
self.methods.remove(set_m)
|
|
|
|
self.clean_up_methods(vtk_obj)
|
|
|
|
def clean_up_methods(self, vtk_obj):
|
|
self.clean_get_set(vtk_obj)
|
|
self.clean_state_methods(vtk_obj)
|
|
self.clean_get_methods(vtk_obj)
|
|
|
|
def clean_get_set(self, vtk_obj):
|
|
debug("VtkDirMethodParser:: clean_get_set()")
|
|
# cleaning up the Get/Set methods by removing the toggle funcs.
|
|
for method in self.toggle_meths:
|
|
try:
|
|
self.get_set_meths.remove(method[:-2])
|
|
except ValueError:
|
|
pass
|
|
|
|
# cleaning them up by removing any methods that are responsible for
|
|
# other vtkObjects
|
|
for method in self.get_set_meths[:]:
|
|
try:
|
|
eval("vtk_obj.Get%s().GetClassName()" % method)
|
|
except (TypeError, AttributeError):
|
|
pass
|
|
else:
|
|
self.get_set_meths.remove(method)
|
|
continue
|
|
try:
|
|
val = eval("vtk_obj.Get%s()" % method)
|
|
except (TypeError, AttributeError):
|
|
self.get_set_meths.remove(method)
|
|
else:
|
|
if val is None:
|
|
self.get_set_meths.remove(method)
|
|
|
|
def clean_state_methods(self, vtk_obj):
|
|
debug("VtkDirMethodParser:: clean_state_methods()")
|
|
# Getting the remaining pure GetMethods
|
|
for method in self.methods[:]:
|
|
if method[:3].find("Get") == 0:
|
|
self.get_meths.append(method)
|
|
self.methods.remove(method)
|
|
|
|
# Grouping similar state methods
|
|
if len(self.state_meths) != 0:
|
|
tmp = self.state_meths[:]
|
|
self.state_meths = []
|
|
state_group = [tmp[0]]
|
|
end = self.state_patn.search(tmp[0]).start()
|
|
# stores the method type common to all similar methods
|
|
m = tmp[0][3:end]
|
|
for i in range(1, len(tmp)):
|
|
if tmp[i].find(m) >= 0:
|
|
state_group.append(tmp[i])
|
|
else:
|
|
self.state_meths.append(state_group)
|
|
state_group = [tmp[i]]
|
|
end = self.state_patn.search(tmp[i]).start()
|
|
m = tmp[i][3:end]
|
|
try: # remove the corresponding set method in get_set
|
|
val = self.get_set_meths.index(m)
|
|
except ValueError:
|
|
pass
|
|
else:
|
|
del self.get_set_meths[val]
|
|
#self.get_meths.append("Get" + m)
|
|
clamp_m = "Get" + m + "MinValue"
|
|
try: # remove the GetNameMax/MinValue in get_meths
|
|
val = self.get_meths.index(clamp_m)
|
|
except ValueError:
|
|
pass
|
|
else:
|
|
del self.get_meths[val]
|
|
val = self.get_meths.index("Get" + m + "MaxValue")
|
|
del self.get_meths[val]
|
|
|
|
if len(state_group) > 0:
|
|
self.state_meths.append(state_group)
|
|
|
|
def clean_get_methods(self, vtk_obj):
|
|
debug("VtkDirMethodParser:: clean_get_methods()")
|
|
for method in self.get_meths[:]:
|
|
debug(method)
|
|
try:
|
|
res = eval("vtk_obj.%s()" % method)
|
|
except (TypeError, AttributeError):
|
|
self.get_meths.remove(method)
|
|
continue
|
|
else:
|
|
try:
|
|
eval("vtk_obj.%s().GetClassName()" % method)
|
|
except AttributeError:
|
|
pass
|
|
else:
|
|
self.get_meths.remove(method)
|
|
continue
|
|
if method[-8:].find("MaxValue") > -1:
|
|
self.get_meths.remove(method)
|
|
elif method[-8:].find("MinValue") > -1:
|
|
self.get_meths.remove(method)
|
|
|
|
self.get_meths.sort()
|
|
|
|
def toggle_methods(self):
|
|
return self.toggle_meths
|
|
|
|
def state_methods(self):
|
|
return self.state_meths
|
|
|
|
def get_set_methods(self):
|
|
return self.get_set_meths
|
|
|
|
def get_methods(self):
|
|
return self.get_meths
|
|
|
|
|
|
class VtkPrintMethodParser:
|
|
"""This class finds the methods for a given vtkObject. It uses
|
|
the output from vtkObject->Print() (or in Python str(vtkObject))
|
|
and output from the VtkDirMethodParser to obtain the methods."""
|
|
|
|
def parse_methods(self, vtk_obj):
|
|
"""Parse for the methods."""
|
|
debug("VtkPrintMethodParser:: parse_methods()")
|
|
self._initialize_methods(vtk_obj)
|
|
|
|
def _get_str_obj(self, vtk_obj):
|
|
debug("VtkPrintMethodParser:: _get_str_obj()")
|
|
self.methods = str(vtk_obj)
|
|
self.methods = self.methods.split("\n")
|
|
del self.methods[0]
|
|
|
|
def _initialize_methods(self, vtk_obj):
|
|
"""Do the basic parsing and setting up"""
|
|
debug("VtkPrintMethodParser:: _initialize_methods()")
|
|
dir_p = VtkDirMethodParser()
|
|
dir_p.parse_methods(vtk_obj)
|
|
|
|
self.toggle_meths = dir_p.toggle_methods()
|
|
self.state_meths = dir_p.state_methods()
|
|
self.get_set_meths = dir_p.get_set_methods()
|
|
self.get_meths = dir_p.get_methods()
|
|
|
|
def toggle_methods(self):
|
|
return self.toggle_meths
|
|
|
|
def state_methods(self):
|
|
return self.state_meths
|
|
|
|
def get_set_methods(self):
|
|
return self.get_set_meths
|
|
|
|
def get_methods(self):
|
|
return self.get_meths
|