1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
"""
VTK type converter.
This module handles conversion between VTK C++ and VTK Python objects
so that one can write inline C++ code to manipulate VTK Python
objects. It requires that you have VTK and the VTK-Python wrappers
installed. It has been tested with VTK 4.0 and above. The code is
based on wx_spec.py. You will need to call inline with include_dirs,
library_dirs and often even libraries appropriately set for this to
work without errors. Sometimes you might need to include additional
headers.
Distributed under the SciPy License.
Authors:
Prabhu Ramachandran <prabhu@aero.iitm.ernet.in>
Eric Jones <eric@enthought.com>
"""
import common_info
from c_spec import common_base_converter
vtk_py_to_c_template = \
"""
class %(type_name)s_handler
{
public:
%(c_type)s convert_to_%(type_name)s(PyObject* py_obj, const char* name)
{
%(c_type)s vtk_ptr = (%(c_type)s) vtkPythonGetPointerFromObject(py_obj, "%(type_name)s");
if (!vtk_ptr)
handle_conversion_error(py_obj,"%(type_name)s", name);
%(inc_ref_count)s
return vtk_ptr;
}
%(c_type)s py_to_%(type_name)s(PyObject* py_obj, const char* name)
{
%(c_type)s vtk_ptr = (%(c_type)s) vtkPythonGetPointerFromObject(py_obj, "%(type_name)s");
if (!vtk_ptr)
handle_bad_type(py_obj,"%(type_name)s", name);
%(inc_ref_count)s
return vtk_ptr;
}
};
%(type_name)s_handler x__%(type_name)s_handler = %(type_name)s_handler();
#define convert_to_%(type_name)s(py_obj,name) \\
x__%(type_name)s_handler.convert_to_%(type_name)s(py_obj,name)
#define py_to_%(type_name)s(py_obj,name) \\
x__%(type_name)s_handler.py_to_%(type_name)s(py_obj,name)
"""
vtk_c_to_py_template = \
"""
PyObject* %(type_name)s_to_py(vtkObjectBase* obj)
{
return vtkPythonGetObjectFromPointer(obj);
}
"""
class vtk_converter(common_base_converter):
def __init__(self,class_name="undefined"):
self.class_name = class_name
common_base_converter.__init__(self)
def init_info(self):
common_base_converter.init_info(self)
# These are generated on the fly instead of defined at
# the class level.
self.type_name = self.class_name
self.c_type = self.class_name + "*"
self.return_type = self.c_type
self.to_c_return = None # not used
self.check_func = None # not used
hdr = self.class_name + ".h"
# Remember that you need both the quotes!
self.headers.extend(['"vtkPythonUtil.h"', '"vtkObject.h"',
'"%s"'%hdr])
#self.include_dirs.extend(vtk_inc)
#self.define_macros.append(('SOME_VARIABLE', '1'))
#self.library_dirs.extend(vtk_lib)
self.libraries.extend(['vtkCommonPython', 'vtkCommon'])
#self.support_code.append(common_info.swig_support_code)
def type_match(self,value):
is_match = 0
try:
if value.IsA('vtkObject'):
is_match = 1
except AttributeError:
pass
return is_match
def generate_build_info(self):
if self.class_name != "undefined":
res = common_base_converter.generate_build_info(self)
else:
# if there isn't a class_name, we don't want the
# we don't want the support_code to be included
import base_info
res = base_info.base_info()
return res
def py_to_c_code(self):
return vtk_py_to_c_template % self.template_vars()
def c_to_py_code(self):
return vtk_c_to_py_template % self.template_vars()
def type_spec(self,name,value):
# factory
class_name = value.__class__.__name__
new_spec = self.__class__(class_name)
new_spec.name = name
return new_spec
def __cmp__(self,other):
#only works for equal
res = -1
try:
res = cmp(self.name,other.name) or \
cmp(self.__class__, other.__class__) or \
cmp(self.class_name, other.class_name) or \
cmp(self.type_name,other.type_name)
except:
pass
return res
|
