Squashed 'wrap/' changes from 076a5e3a9..520dbca0f
520dbca0f Merge pull request #158 from borglab/matlab-enum-support 661daf0dd fix python version specification 6f9111ddb fix python install 691e47734 update CI to newer OS versions 579539b1c finish wrapping 474aece68 fix issue in _collector_return 660c21bcc wrap enum types in cpp 1fa5c2756 begin updating generated cpp for enums 7b156a3f5 add wrap_enum and unwrap_enum helper functions 2a5423061 finish wrapping every part of enum.i 68cfa8a51 wrap enums inside classes ce734fa9f wrap enums declared on their own 66c84e5cb unit test for enum wrapping in matlab 1cc126669 module docstring for matlab_wrapper/templates.py git-subtree-dir: wrap git-subtree-split: 520dbca0f2c3db4d30f0a0fd020a729cc0caa7b7release/4.3a0
Varun Agrawal
parent
53714794e2
commit
6976cd6ea2
|
|
@ -5,12 +5,12 @@ on: [pull_request]
|
|||
jobs:
|
||||
build:
|
||||
name: Tests for 🐍 ${{ matrix.python-version }}
|
||||
runs-on: ubuntu-18.04
|
||||
runs-on: ubuntu-22.04
|
||||
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
python-version: [3.6, 3.7, 3.8, 3.9]
|
||||
python-version: ["3.7", "3.8", "3.9", "3.10"]
|
||||
|
||||
steps:
|
||||
- name: Checkout
|
||||
|
|
@ -19,7 +19,7 @@ jobs:
|
|||
- name: Install Dependencies
|
||||
run: |
|
||||
sudo apt-get -y update
|
||||
sudo apt install cmake build-essential pkg-config libpython-dev python-numpy libboost-all-dev
|
||||
sudo apt install cmake build-essential pkg-config libpython3-dev python3-numpy libboost-all-dev
|
||||
|
||||
- name: Set up Python ${{ matrix.python-version }}
|
||||
uses: actions/setup-python@v2
|
||||
|
|
|
|||
|
|
@ -5,12 +5,12 @@ on: [pull_request]
|
|||
jobs:
|
||||
build:
|
||||
name: Tests for 🐍 ${{ matrix.python-version }}
|
||||
runs-on: macos-10.15
|
||||
runs-on: macos-12
|
||||
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
python-version: [3.6, 3.7, 3.8, 3.9]
|
||||
python-version: ["3.7", "3.8", "3.9", "3.10"]
|
||||
|
||||
steps:
|
||||
- name: Checkout
|
||||
|
|
|
|||
|
|
@ -60,6 +60,11 @@ class CheckMixin:
|
|||
arg_type.typename.name not in self.not_ptr_type and \
|
||||
arg_type.is_ref
|
||||
|
||||
def is_class_enum(self, arg_type: parser.Type, class_: parser.Class):
|
||||
"""Check if `arg_type` is an enum in the class `class_`."""
|
||||
enums = (enum.name for enum in class_.enums)
|
||||
return arg_type.ctype.typename.name in enums
|
||||
|
||||
|
||||
class FormatMixin:
|
||||
"""Mixin to provide formatting utilities."""
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
"""Code generation templates for the Matlab wrapper."""
|
||||
|
||||
import textwrap
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -341,11 +341,26 @@ class MatlabWrapper(CheckMixin, FormatMixin):
|
|||
|
||||
return check_statement
|
||||
|
||||
def _unwrap_argument(self, arg, arg_id=0, constructor=False):
|
||||
def _unwrap_argument(self,
|
||||
arg,
|
||||
arg_id=0,
|
||||
constructor=False,
|
||||
instantiated_class=None):
|
||||
ctype_camel = self._format_type_name(arg.ctype.typename, separator='')
|
||||
ctype_sep = self._format_type_name(arg.ctype.typename)
|
||||
|
||||
if self.is_ref(arg.ctype): # and not constructor:
|
||||
if instantiated_class and \
|
||||
self.is_class_enum(arg, instantiated_class):
|
||||
|
||||
if instantiated_class.original.template:
|
||||
enum_type = f"{arg.ctype.typename}"
|
||||
else:
|
||||
enum_type = f"{instantiated_class.name}::{arg.ctype}"
|
||||
|
||||
arg_type = f"std::shared_ptr<{enum_type}>"
|
||||
unwrap = f'unwrap_enum<{enum_type}>(in[{arg_id}]);'
|
||||
|
||||
elif self.is_ref(arg.ctype): # and not constructor:
|
||||
arg_type = "{ctype}&".format(ctype=ctype_sep)
|
||||
unwrap = '*unwrap_shared_ptr< {ctype} >(in[{id}], "ptr_{ctype_camel}");'.format(
|
||||
ctype=ctype_sep, ctype_camel=ctype_camel, id=arg_id)
|
||||
|
|
@ -372,7 +387,11 @@ class MatlabWrapper(CheckMixin, FormatMixin):
|
|||
|
||||
return arg_type, unwrap
|
||||
|
||||
def _wrapper_unwrap_arguments(self, args, arg_id=0, constructor=False):
|
||||
def _wrapper_unwrap_arguments(self,
|
||||
args,
|
||||
arg_id=0,
|
||||
constructor=False,
|
||||
instantiated_class=None):
|
||||
"""Format the interface_parser.Arguments.
|
||||
|
||||
Examples:
|
||||
|
|
@ -383,7 +402,11 @@ class MatlabWrapper(CheckMixin, FormatMixin):
|
|||
body_args = ''
|
||||
|
||||
for arg in args.list():
|
||||
arg_type, unwrap = self._unwrap_argument(arg, arg_id, constructor)
|
||||
arg_type, unwrap = self._unwrap_argument(
|
||||
arg,
|
||||
arg_id,
|
||||
constructor,
|
||||
instantiated_class=instantiated_class)
|
||||
|
||||
body_args += textwrap.indent(textwrap.dedent('''\
|
||||
{arg_type} {name} = {unwrap}
|
||||
|
|
@ -535,7 +558,7 @@ class MatlabWrapper(CheckMixin, FormatMixin):
|
|||
|
||||
def wrap_methods(self, methods, global_funcs=False, global_ns=None):
|
||||
"""
|
||||
Wrap a sequence of methods. Groups methods with the same names
|
||||
Wrap a sequence of methods/functions. Groups methods with the same names
|
||||
together.
|
||||
If global_funcs is True then output every method into its own file.
|
||||
"""
|
||||
|
|
@ -1027,7 +1050,7 @@ class MatlabWrapper(CheckMixin, FormatMixin):
|
|||
if uninstantiated_name in self.ignore_classes:
|
||||
return None
|
||||
|
||||
# Class comment
|
||||
# Class docstring/comment
|
||||
content_text = self.class_comment(instantiated_class)
|
||||
content_text += self.wrap_methods(instantiated_class.methods)
|
||||
|
||||
|
|
@ -1108,31 +1131,73 @@ class MatlabWrapper(CheckMixin, FormatMixin):
|
|||
end
|
||||
''')
|
||||
|
||||
# Enums
|
||||
# Place enums into the correct submodule so we can access them
|
||||
# e.g. gtsam.Class.Enum.A
|
||||
for enum in instantiated_class.enums:
|
||||
enum_text = self.wrap_enum(enum)
|
||||
if namespace_name != '':
|
||||
submodule = f"+{namespace_name}/"
|
||||
else:
|
||||
submodule = ""
|
||||
submodule += f"+{instantiated_class.name}"
|
||||
self.content.append((submodule, [enum_text]))
|
||||
|
||||
return file_name + '.m', content_text
|
||||
|
||||
def wrap_namespace(self, namespace):
|
||||
def wrap_enum(self, enum):
|
||||
"""
|
||||
Wrap an enum definition.
|
||||
|
||||
Args:
|
||||
enum: The interface_parser.Enum instance
|
||||
"""
|
||||
file_name = enum.name + '.m'
|
||||
enum_template = textwrap.dedent("""\
|
||||
classdef {0} < uint32
|
||||
enumeration
|
||||
{1}
|
||||
end
|
||||
end
|
||||
""")
|
||||
enumerators = "\n ".join([
|
||||
f"{enumerator.name}({idx})"
|
||||
for idx, enumerator in enumerate(enum.enumerators)
|
||||
])
|
||||
|
||||
content = enum_template.format(enum.name, enumerators)
|
||||
return file_name, content
|
||||
|
||||
def wrap_namespace(self, namespace, add_mex_file=True):
|
||||
"""Wrap a namespace by wrapping all of its components.
|
||||
|
||||
Args:
|
||||
namespace: the interface_parser.namespace instance of the namespace
|
||||
parent: parent namespace
|
||||
add_cpp_file: Flag indicating whether the mex file should be added
|
||||
"""
|
||||
namespaces = namespace.full_namespaces()
|
||||
inner_namespace = namespace.name != ''
|
||||
wrapped = []
|
||||
|
||||
cpp_filename = self._wrapper_name() + '.cpp'
|
||||
self.content.append((cpp_filename, self.wrapper_file_headers))
|
||||
|
||||
current_scope = []
|
||||
namespace_scope = []
|
||||
top_level_scope = []
|
||||
inner_namespace_scope = []
|
||||
|
||||
for element in namespace.content:
|
||||
if isinstance(element, parser.Include):
|
||||
self.includes.append(element)
|
||||
|
||||
elif isinstance(element, parser.Namespace):
|
||||
self.wrap_namespace(element)
|
||||
self.wrap_namespace(element, False)
|
||||
|
||||
elif isinstance(element, parser.Enum):
|
||||
file, content = self.wrap_enum(element)
|
||||
if inner_namespace:
|
||||
module = "".join([
|
||||
'+' + x + '/' for x in namespace.full_namespaces()[1:]
|
||||
])[:-1]
|
||||
inner_namespace_scope.append((module, [(file, content)]))
|
||||
else:
|
||||
top_level_scope.append((file, content))
|
||||
|
||||
elif isinstance(element, instantiator.InstantiatedClass):
|
||||
self.add_class(element)
|
||||
|
|
@ -1142,18 +1207,22 @@ class MatlabWrapper(CheckMixin, FormatMixin):
|
|||
element, "".join(namespace.full_namespaces()))
|
||||
|
||||
if not class_text is None:
|
||||
namespace_scope.append(("".join([
|
||||
inner_namespace_scope.append(("".join([
|
||||
'+' + x + '/'
|
||||
for x in namespace.full_namespaces()[1:]
|
||||
])[:-1], [(class_text[0], class_text[1])]))
|
||||
else:
|
||||
class_text = self.wrap_instantiated_class(element)
|
||||
current_scope.append((class_text[0], class_text[1]))
|
||||
top_level_scope.append((class_text[0], class_text[1]))
|
||||
|
||||
self.content.extend(current_scope)
|
||||
self.content.extend(top_level_scope)
|
||||
|
||||
if inner_namespace:
|
||||
self.content.append(namespace_scope)
|
||||
self.content.append(inner_namespace_scope)
|
||||
|
||||
if add_mex_file:
|
||||
cpp_filename = self._wrapper_name() + '.cpp'
|
||||
self.content.append((cpp_filename, self.wrapper_file_headers))
|
||||
|
||||
# Global functions
|
||||
all_funcs = [
|
||||
|
|
@ -1213,10 +1282,22 @@ class MatlabWrapper(CheckMixin, FormatMixin):
|
|||
|
||||
return return_type_text
|
||||
|
||||
def _collector_return(self, obj: str, ctype: parser.Type):
|
||||
def _collector_return(self,
|
||||
obj: str,
|
||||
ctype: parser.Type,
|
||||
class_property: parser.Variable = None,
|
||||
instantiated_class: InstantiatedClass = None):
|
||||
"""Helper method to get the final statement before the return in the collector function."""
|
||||
expanded = ''
|
||||
if self.is_shared_ptr(ctype) or self.is_ptr(ctype) or \
|
||||
|
||||
if class_property and instantiated_class and \
|
||||
self.is_class_enum(class_property, instantiated_class):
|
||||
class_name = ".".join(instantiated_class.namespaces()[1:] + [instantiated_class.name])
|
||||
enum_type = f"{class_name}.{ctype.typename.name}"
|
||||
expanded = textwrap.indent(
|
||||
f'out[0] = wrap_enum({obj},\"{enum_type}\");', prefix=' ')
|
||||
|
||||
elif self.is_shared_ptr(ctype) or self.is_ptr(ctype) or \
|
||||
self.can_be_pointer(ctype):
|
||||
sep_method_name = partial(self._format_type_name,
|
||||
ctype.typename,
|
||||
|
|
@ -1316,13 +1397,19 @@ class MatlabWrapper(CheckMixin, FormatMixin):
|
|||
|
||||
return expanded
|
||||
|
||||
def wrap_collector_property_return(self, class_property: parser.Variable):
|
||||
def wrap_collector_property_return(
|
||||
self,
|
||||
class_property: parser.Variable,
|
||||
instantiated_class: InstantiatedClass = None):
|
||||
"""Get the last collector function statement before return for a property."""
|
||||
property_name = class_property.name
|
||||
obj = 'obj->{}'.format(property_name)
|
||||
property_type = class_property.ctype
|
||||
|
||||
return self._collector_return(obj, property_type)
|
||||
ctype = class_property.ctype
|
||||
return self._collector_return(obj,
|
||||
ctype,
|
||||
class_property=class_property,
|
||||
instantiated_class=instantiated_class)
|
||||
|
||||
def wrap_collector_function_upcast_from_void(self, class_name, func_id,
|
||||
cpp_name):
|
||||
|
|
@ -1381,7 +1468,9 @@ class MatlabWrapper(CheckMixin, FormatMixin):
|
|||
elif collector_func[2] == 'constructor':
|
||||
base = ''
|
||||
params, body_args = self._wrapper_unwrap_arguments(
|
||||
extra.args, constructor=True)
|
||||
extra.args,
|
||||
constructor=True,
|
||||
instantiated_class=collector_func[1])
|
||||
|
||||
if collector_func[1].parent_class:
|
||||
base += textwrap.indent(textwrap.dedent('''
|
||||
|
|
@ -1442,7 +1531,9 @@ class MatlabWrapper(CheckMixin, FormatMixin):
|
|||
method_name += extra.name
|
||||
|
||||
_, body_args = self._wrapper_unwrap_arguments(
|
||||
extra.args, arg_id=1 if is_method else 0)
|
||||
extra.args,
|
||||
arg_id=1 if is_method else 0,
|
||||
instantiated_class=collector_func[1])
|
||||
return_body = self.wrap_collector_function_return(extra)
|
||||
|
||||
shared_obj = ''
|
||||
|
|
@ -1472,7 +1563,8 @@ class MatlabWrapper(CheckMixin, FormatMixin):
|
|||
class_name=class_name)
|
||||
|
||||
# Unpack the property from mxArray
|
||||
property_type, unwrap = self._unwrap_argument(extra, arg_id=1)
|
||||
property_type, unwrap = self._unwrap_argument(
|
||||
extra, arg_id=1, instantiated_class=collector_func[1])
|
||||
unpack_property = textwrap.indent(textwrap.dedent('''\
|
||||
{arg_type} {name} = {unwrap}
|
||||
'''.format(arg_type=property_type,
|
||||
|
|
@ -1482,7 +1574,8 @@ class MatlabWrapper(CheckMixin, FormatMixin):
|
|||
|
||||
# Getter
|
||||
if "_get_" in method_name:
|
||||
return_body = self.wrap_collector_property_return(extra)
|
||||
return_body = self.wrap_collector_property_return(
|
||||
extra, instantiated_class=collector_func[1])
|
||||
|
||||
getter = ' checkArguments("{property_name}",nargout,nargin{min1},' \
|
||||
'{num_args});\n' \
|
||||
|
|
@ -1837,3 +1930,4 @@ class MatlabWrapper(CheckMixin, FormatMixin):
|
|||
self.generate_content(self.content, path)
|
||||
|
||||
return self.content
|
||||
|
||||
|
|
|
|||
36
matlab.h
36
matlab.h
|
|
@ -228,8 +228,22 @@ mxArray* wrap<gtsam::Matrix >(const gtsam::Matrix& A) {
|
|||
return wrap_Matrix(A);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
mxArray* wrap_enum(const T x, const std::string& classname) {
|
||||
// create double array to store value in
|
||||
mxArray* a = mxCreateDoubleMatrix(1, 1, mxREAL);
|
||||
double* data = mxGetPr(a);
|
||||
data[0] = static_cast<double>(x);
|
||||
|
||||
// convert to Matlab enumeration type
|
||||
mxArray* result;
|
||||
mexCallMATLAB(1, &result, 1, &a, classname.c_str());
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
//*****************************************************************************
|
||||
// unwrapping MATLAB arrays into C++ basis types
|
||||
// unwrapping MATLAB arrays into C++ basic types
|
||||
//*****************************************************************************
|
||||
|
||||
// default unwrapping throws an error
|
||||
|
|
@ -240,6 +254,22 @@ T unwrap(const mxArray* array) {
|
|||
return T();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
shared_ptr<T> unwrap_enum(const mxArray* array) {
|
||||
// Make duplicate to remove const-ness
|
||||
mxArray* a = mxDuplicateArray(array);
|
||||
std::cout << "unwrap enum type: " << typeid(array).name() << std::endl;
|
||||
|
||||
// convert void* to int32* array
|
||||
mxArray* a_int32;
|
||||
mexCallMATLAB(1, &a_int32, 1, &a, "int32");
|
||||
|
||||
// Get the value in the input array
|
||||
int32_T* value = (int32_T*)mxGetData(a_int32);
|
||||
// cast int32 to enum type
|
||||
return std::make_shared<T>(static_cast<T>(*value));
|
||||
}
|
||||
|
||||
// specialization to string
|
||||
// expects a character array
|
||||
// Warning: relies on mxChar==char
|
||||
|
|
@ -485,7 +515,7 @@ Class* unwrap_ptr(const mxArray* obj, const string& propertyName) {
|
|||
//template <>
|
||||
//Vector unwrap_shared_ptr<Vector>(const mxArray* obj, const string& propertyName) {
|
||||
// bool unwrap_shared_ptr_Vector_attempted = false;
|
||||
// BOOST_STATIC_ASSERT(unwrap_shared_ptr_Vector_attempted, "Vector cannot be unwrapped as a shared pointer");
|
||||
// static_assert(unwrap_shared_ptr_Vector_attempted, "Vector cannot be unwrapped as a shared pointer");
|
||||
// return Vector();
|
||||
//}
|
||||
|
||||
|
|
@ -493,7 +523,7 @@ Class* unwrap_ptr(const mxArray* obj, const string& propertyName) {
|
|||
//template <>
|
||||
//Matrix unwrap_shared_ptr<Matrix>(const mxArray* obj, const string& propertyName) {
|
||||
// bool unwrap_shared_ptr_Matrix_attempted = false;
|
||||
// BOOST_STATIC_ASSERT(unwrap_shared_ptr_Matrix_attempted, "Matrix cannot be unwrapped as a shared pointer");
|
||||
// static_assert(unwrap_shared_ptr_Matrix_attempted, "Matrix cannot be unwrapped as a shared pointer");
|
||||
// return Matrix();
|
||||
//}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,6 @@
|
|||
classdef Kind < uint32
|
||||
enumeration
|
||||
Dog(0)
|
||||
Cat(1)
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
classdef Avengers < uint32
|
||||
enumeration
|
||||
CaptainAmerica(0)
|
||||
IronMan(1)
|
||||
Hulk(2)
|
||||
Hawkeye(3)
|
||||
Thor(4)
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
classdef GotG < uint32
|
||||
enumeration
|
||||
Starlord(0)
|
||||
Gamorra(1)
|
||||
Rocket(2)
|
||||
Drax(3)
|
||||
Groot(4)
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
classdef Verbosity < uint32
|
||||
enumeration
|
||||
SILENT(0)
|
||||
SUMMARY(1)
|
||||
VERBOSE(2)
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
classdef VerbosityLM < uint32
|
||||
enumeration
|
||||
SILENT(0)
|
||||
SUMMARY(1)
|
||||
TERMINATION(2)
|
||||
LAMBDA(3)
|
||||
TRYLAMBDA(4)
|
||||
TRYCONFIG(5)
|
||||
DAMPED(6)
|
||||
TRYDELTA(7)
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
classdef Color < uint32
|
||||
enumeration
|
||||
Red(0)
|
||||
Green(1)
|
||||
Blue(2)
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,266 @@
|
|||
#include <gtwrap/matlab.h>
|
||||
#include <map>
|
||||
|
||||
|
||||
|
||||
typedef gtsam::Optimizer<gtsam::GaussNewtonParams> OptimizerGaussNewtonParams;
|
||||
|
||||
typedef std::set<std::shared_ptr<Pet>*> Collector_Pet;
|
||||
static Collector_Pet collector_Pet;
|
||||
typedef std::set<std::shared_ptr<gtsam::MCU>*> Collector_gtsamMCU;
|
||||
static Collector_gtsamMCU collector_gtsamMCU;
|
||||
typedef std::set<std::shared_ptr<OptimizerGaussNewtonParams>*> Collector_gtsamOptimizerGaussNewtonParams;
|
||||
static Collector_gtsamOptimizerGaussNewtonParams collector_gtsamOptimizerGaussNewtonParams;
|
||||
|
||||
|
||||
void _deleteAllObjects()
|
||||
{
|
||||
mstream mout;
|
||||
std::streambuf *outbuf = std::cout.rdbuf(&mout);
|
||||
|
||||
bool anyDeleted = false;
|
||||
{ for(Collector_Pet::iterator iter = collector_Pet.begin();
|
||||
iter != collector_Pet.end(); ) {
|
||||
delete *iter;
|
||||
collector_Pet.erase(iter++);
|
||||
anyDeleted = true;
|
||||
} }
|
||||
{ for(Collector_gtsamMCU::iterator iter = collector_gtsamMCU.begin();
|
||||
iter != collector_gtsamMCU.end(); ) {
|
||||
delete *iter;
|
||||
collector_gtsamMCU.erase(iter++);
|
||||
anyDeleted = true;
|
||||
} }
|
||||
{ for(Collector_gtsamOptimizerGaussNewtonParams::iterator iter = collector_gtsamOptimizerGaussNewtonParams.begin();
|
||||
iter != collector_gtsamOptimizerGaussNewtonParams.end(); ) {
|
||||
delete *iter;
|
||||
collector_gtsamOptimizerGaussNewtonParams.erase(iter++);
|
||||
anyDeleted = true;
|
||||
} }
|
||||
|
||||
if(anyDeleted)
|
||||
cout <<
|
||||
"WARNING: Wrap modules with variables in the workspace have been reloaded due to\n"
|
||||
"calling destructors, call 'clear all' again if you plan to now recompile a wrap\n"
|
||||
"module, so that your recompiled module is used instead of the old one." << endl;
|
||||
std::cout.rdbuf(outbuf);
|
||||
}
|
||||
|
||||
void _enum_RTTIRegister() {
|
||||
const mxArray *alreadyCreated = mexGetVariablePtr("global", "gtsam_enum_rttiRegistry_created");
|
||||
if(!alreadyCreated) {
|
||||
std::map<std::string, std::string> types;
|
||||
|
||||
|
||||
|
||||
mxArray *registry = mexGetVariable("global", "gtsamwrap_rttiRegistry");
|
||||
if(!registry)
|
||||
registry = mxCreateStructMatrix(1, 1, 0, NULL);
|
||||
typedef std::pair<std::string, std::string> StringPair;
|
||||
for(const StringPair& rtti_matlab: types) {
|
||||
int fieldId = mxAddField(registry, rtti_matlab.first.c_str());
|
||||
if(fieldId < 0) {
|
||||
mexErrMsgTxt("gtsam wrap: Error indexing RTTI types, inheritance will not work correctly");
|
||||
}
|
||||
mxArray *matlabName = mxCreateString(rtti_matlab.second.c_str());
|
||||
mxSetFieldByNumber(registry, 0, fieldId, matlabName);
|
||||
}
|
||||
if(mexPutVariable("global", "gtsamwrap_rttiRegistry", registry) != 0) {
|
||||
mexErrMsgTxt("gtsam wrap: Error indexing RTTI types, inheritance will not work correctly");
|
||||
}
|
||||
mxDestroyArray(registry);
|
||||
|
||||
mxArray *newAlreadyCreated = mxCreateNumericMatrix(0, 0, mxINT8_CLASS, mxREAL);
|
||||
if(mexPutVariable("global", "gtsam_enum_rttiRegistry_created", newAlreadyCreated) != 0) {
|
||||
mexErrMsgTxt("gtsam wrap: Error indexing RTTI types, inheritance will not work correctly");
|
||||
}
|
||||
mxDestroyArray(newAlreadyCreated);
|
||||
}
|
||||
}
|
||||
|
||||
void Pet_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
mexAtExit(&_deleteAllObjects);
|
||||
typedef std::shared_ptr<Pet> Shared;
|
||||
|
||||
Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
|
||||
collector_Pet.insert(self);
|
||||
}
|
||||
|
||||
void Pet_constructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
mexAtExit(&_deleteAllObjects);
|
||||
typedef std::shared_ptr<Pet> Shared;
|
||||
|
||||
string& name = *unwrap_shared_ptr< string >(in[0], "ptr_string");
|
||||
std::shared_ptr<Pet::Kind> type = unwrap_enum<Pet::Kind>(in[1]);
|
||||
Shared *self = new Shared(new Pet(name,*type));
|
||||
collector_Pet.insert(self);
|
||||
out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
|
||||
*reinterpret_cast<Shared**> (mxGetData(out[0])) = self;
|
||||
}
|
||||
|
||||
void Pet_deconstructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
typedef std::shared_ptr<Pet> Shared;
|
||||
checkArguments("delete_Pet",nargout,nargin,1);
|
||||
Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
|
||||
Collector_Pet::iterator item;
|
||||
item = collector_Pet.find(self);
|
||||
if(item != collector_Pet.end()) {
|
||||
collector_Pet.erase(item);
|
||||
}
|
||||
delete self;
|
||||
}
|
||||
|
||||
void Pet_get_name_3(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
checkArguments("name",nargout,nargin-1,0);
|
||||
auto obj = unwrap_shared_ptr<Pet>(in[0], "ptr_Pet");
|
||||
out[0] = wrap< string >(obj->name);
|
||||
}
|
||||
|
||||
void Pet_set_name_4(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
checkArguments("name",nargout,nargin-1,1);
|
||||
auto obj = unwrap_shared_ptr<Pet>(in[0], "ptr_Pet");
|
||||
string name = unwrap< string >(in[1]);
|
||||
obj->name = name;
|
||||
}
|
||||
|
||||
void Pet_get_type_5(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
checkArguments("type",nargout,nargin-1,0);
|
||||
auto obj = unwrap_shared_ptr<Pet>(in[0], "ptr_Pet");
|
||||
out[0] = wrap_enum(obj->type,"Pet.Kind");
|
||||
}
|
||||
|
||||
void Pet_set_type_6(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
checkArguments("type",nargout,nargin-1,1);
|
||||
auto obj = unwrap_shared_ptr<Pet>(in[0], "ptr_Pet");
|
||||
std::shared_ptr<Pet::Kind> type = unwrap_enum<Pet::Kind>(in[1]);
|
||||
obj->type = *type;
|
||||
}
|
||||
|
||||
void gtsamMCU_collectorInsertAndMakeBase_7(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
mexAtExit(&_deleteAllObjects);
|
||||
typedef std::shared_ptr<gtsam::MCU> Shared;
|
||||
|
||||
Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
|
||||
collector_gtsamMCU.insert(self);
|
||||
}
|
||||
|
||||
void gtsamMCU_constructor_8(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
mexAtExit(&_deleteAllObjects);
|
||||
typedef std::shared_ptr<gtsam::MCU> Shared;
|
||||
|
||||
Shared *self = new Shared(new gtsam::MCU());
|
||||
collector_gtsamMCU.insert(self);
|
||||
out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
|
||||
*reinterpret_cast<Shared**> (mxGetData(out[0])) = self;
|
||||
}
|
||||
|
||||
void gtsamMCU_deconstructor_9(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
typedef std::shared_ptr<gtsam::MCU> Shared;
|
||||
checkArguments("delete_gtsamMCU",nargout,nargin,1);
|
||||
Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
|
||||
Collector_gtsamMCU::iterator item;
|
||||
item = collector_gtsamMCU.find(self);
|
||||
if(item != collector_gtsamMCU.end()) {
|
||||
collector_gtsamMCU.erase(item);
|
||||
}
|
||||
delete self;
|
||||
}
|
||||
|
||||
void gtsamOptimizerGaussNewtonParams_collectorInsertAndMakeBase_10(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
mexAtExit(&_deleteAllObjects);
|
||||
typedef std::shared_ptr<gtsam::Optimizer<gtsam::GaussNewtonParams>> Shared;
|
||||
|
||||
Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
|
||||
collector_gtsamOptimizerGaussNewtonParams.insert(self);
|
||||
}
|
||||
|
||||
void gtsamOptimizerGaussNewtonParams_deconstructor_11(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
typedef std::shared_ptr<gtsam::Optimizer<gtsam::GaussNewtonParams>> Shared;
|
||||
checkArguments("delete_gtsamOptimizerGaussNewtonParams",nargout,nargin,1);
|
||||
Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
|
||||
Collector_gtsamOptimizerGaussNewtonParams::iterator item;
|
||||
item = collector_gtsamOptimizerGaussNewtonParams.find(self);
|
||||
if(item != collector_gtsamOptimizerGaussNewtonParams.end()) {
|
||||
collector_gtsamOptimizerGaussNewtonParams.erase(item);
|
||||
}
|
||||
delete self;
|
||||
}
|
||||
|
||||
void gtsamOptimizerGaussNewtonParams_setVerbosity_12(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
checkArguments("setVerbosity",nargout,nargin-1,1);
|
||||
auto obj = unwrap_shared_ptr<gtsam::Optimizer<gtsam::GaussNewtonParams>>(in[0], "ptr_gtsamOptimizerGaussNewtonParams");
|
||||
std::shared_ptr<Optimizer<gtsam::GaussNewtonParams>::Verbosity> value = unwrap_enum<Optimizer<gtsam::GaussNewtonParams>::Verbosity>(in[1]);
|
||||
obj->setVerbosity(*value);
|
||||
}
|
||||
|
||||
|
||||
void mexFunction(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
mstream mout;
|
||||
std::streambuf *outbuf = std::cout.rdbuf(&mout);
|
||||
|
||||
_enum_RTTIRegister();
|
||||
|
||||
int id = unwrap<int>(in[0]);
|
||||
|
||||
try {
|
||||
switch(id) {
|
||||
case 0:
|
||||
Pet_collectorInsertAndMakeBase_0(nargout, out, nargin-1, in+1);
|
||||
break;
|
||||
case 1:
|
||||
Pet_constructor_1(nargout, out, nargin-1, in+1);
|
||||
break;
|
||||
case 2:
|
||||
Pet_deconstructor_2(nargout, out, nargin-1, in+1);
|
||||
break;
|
||||
case 3:
|
||||
Pet_get_name_3(nargout, out, nargin-1, in+1);
|
||||
break;
|
||||
case 4:
|
||||
Pet_set_name_4(nargout, out, nargin-1, in+1);
|
||||
break;
|
||||
case 5:
|
||||
Pet_get_type_5(nargout, out, nargin-1, in+1);
|
||||
break;
|
||||
case 6:
|
||||
Pet_set_type_6(nargout, out, nargin-1, in+1);
|
||||
break;
|
||||
case 7:
|
||||
gtsamMCU_collectorInsertAndMakeBase_7(nargout, out, nargin-1, in+1);
|
||||
break;
|
||||
case 8:
|
||||
gtsamMCU_constructor_8(nargout, out, nargin-1, in+1);
|
||||
break;
|
||||
case 9:
|
||||
gtsamMCU_deconstructor_9(nargout, out, nargin-1, in+1);
|
||||
break;
|
||||
case 10:
|
||||
gtsamOptimizerGaussNewtonParams_collectorInsertAndMakeBase_10(nargout, out, nargin-1, in+1);
|
||||
break;
|
||||
case 11:
|
||||
gtsamOptimizerGaussNewtonParams_deconstructor_11(nargout, out, nargin-1, in+1);
|
||||
break;
|
||||
case 12:
|
||||
gtsamOptimizerGaussNewtonParams_setVerbosity_12(nargout, out, nargin-1, in+1);
|
||||
break;
|
||||
}
|
||||
} catch(const std::exception& e) {
|
||||
mexErrMsgTxt(("Exception from gtsam:\n" + std::string(e.what()) + "\n").c_str());
|
||||
}
|
||||
|
||||
std::cout.rdbuf(outbuf);
|
||||
}
|
||||
|
|
@ -204,14 +204,14 @@ void gtsamGeneralSFMFactorCal3Bundler_get_verbosity_11(int nargout, mxArray *out
|
|||
{
|
||||
checkArguments("verbosity",nargout,nargin-1,0);
|
||||
auto obj = unwrap_shared_ptr<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>>(in[0], "ptr_gtsamGeneralSFMFactorCal3Bundler");
|
||||
out[0] = wrap_shared_ptr(std::make_shared<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>::Verbosity>(obj->verbosity),"gtsam.GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>.Verbosity", false);
|
||||
out[0] = wrap_enum(obj->verbosity,"gtsam.GeneralSFMFactorCal3Bundler.Verbosity");
|
||||
}
|
||||
|
||||
void gtsamGeneralSFMFactorCal3Bundler_set_verbosity_12(int nargout, mxArray *out[], int nargin, const mxArray *in[])
|
||||
{
|
||||
checkArguments("verbosity",nargout,nargin-1,1);
|
||||
auto obj = unwrap_shared_ptr<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>>(in[0], "ptr_gtsamGeneralSFMFactorCal3Bundler");
|
||||
std::shared_ptr<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>::Verbosity> verbosity = unwrap_shared_ptr< gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>::Verbosity >(in[1], "ptr_gtsamGeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>Verbosity");
|
||||
std::shared_ptr<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>::Verbosity> verbosity = unwrap_enum<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>::Verbosity>(in[1]);
|
||||
obj->verbosity = *verbosity;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -141,6 +141,32 @@ class TestWrap(unittest.TestCase):
|
|||
actual = osp.join(self.MATLAB_ACTUAL_DIR, file)
|
||||
self.compare_and_diff(file, actual)
|
||||
|
||||
def test_enum(self):
|
||||
"""Test interface file with only enum info."""
|
||||
file = osp.join(self.INTERFACE_DIR, 'enum.i')
|
||||
|
||||
wrapper = MatlabWrapper(
|
||||
module_name='enum',
|
||||
top_module_namespace=['gtsam'],
|
||||
ignore_classes=[''],
|
||||
)
|
||||
|
||||
wrapper.wrap([file], path=self.MATLAB_ACTUAL_DIR)
|
||||
|
||||
files = [
|
||||
'enum_wrapper.cpp',
|
||||
'Color.m',
|
||||
'+Pet/Kind.m',
|
||||
'+gtsam/VerbosityLM.m',
|
||||
'+gtsam/+MCU/Avengers.m',
|
||||
'+gtsam/+MCU/GotG.m',
|
||||
'+gtsam/+OptimizerGaussNewtonParams/Verbosity.m',
|
||||
]
|
||||
|
||||
for file in files:
|
||||
actual = osp.join(self.MATLAB_ACTUAL_DIR, file)
|
||||
self.compare_and_diff(file, actual)
|
||||
|
||||
def test_templates(self):
|
||||
"""Test interface file with template info."""
|
||||
file = osp.join(self.INTERFACE_DIR, 'templates.i')
|
||||
|
|
|
|||
Loading…
Reference in New Issue