12345qiupeng
/
gtsam
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #1530 from borglab/wrapper-update 

Wapper Update
release/4.3a0
Varun Agrawal 2023-05-25 09:07:59 -04:00 committed by GitHub
parent 9eb9770a43 60fe7e3579
commit 3a1d23b5bb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
21 changed files with 646 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
matlab/gtsam_tests/testEnum.m Normal file
View File

@ -0,0 +1,12 @@
% test Enum
import gtsam.*;
params = GncLMParams();
EXPECT('Get lossType',params.lossType==GncLossType.TLS);
params.lossType = GncLossType.GM;
EXPECT('Set lossType',params.lossType==GncLossType.GM);
params.setLossType(GncLossType.TLS);
EXPECT('setLossType',params.lossType==GncLossType.TLS);

6
wrap/.github/workflows/linux-ci.yml vendored
View File

@ -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

4
wrap/.github/workflows/macos-ci.yml vendored
View File

@ -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

9
wrap/gtwrap/interface_parser/tokens.py
View File

@ -10,9 +10,10 @@ All the token definitions.
Author: Duy Nguyen Ta, Fan Jiang, Matthew Sklar, Varun Agrawal, and Frank Dellaert
"""
from pyparsing import (Keyword, Literal, OneOrMore, Or, # type: ignore
QuotedString, Suppress, Word, alphanums, alphas,
nestedExpr, nums, originalTextFor, printables)
from pyparsing import Or # type: ignore
from pyparsing import (Keyword, Literal, OneOrMore, QuotedString, Suppress,
Word, alphanums, alphas, nestedExpr, nums,
originalTextFor, printables)
# rule for identifiers (e.g. variable names)
IDENT = Word(alphas + '_', alphanums + '_') ^ Word(nums)
@ -52,7 +53,7 @@ CONST, VIRTUAL, CLASS, STATIC, PAIR, TEMPLATE, TYPEDEF, INCLUDE = map(
)
ENUM = Keyword("enum") ^ Keyword("enum class") ^ Keyword("enum struct")
NAMESPACE = Keyword("namespace")
BASIS_TYPES = map(
BASIC_TYPES = map(
Keyword,
[
"void",

30
wrap/gtwrap/interface_parser/type.py
View File

@ -17,15 +17,13 @@ from typing import List, Sequence, Union
from pyparsing import ParseResults # type: ignore
from pyparsing import Forward, Optional, Or, delimitedList
from .tokens import (BASIS_TYPES, CONST, IDENT, LOPBRACK, RAW_POINTER, REF,
from .tokens import (BASIC_TYPES, CONST, IDENT, LOPBRACK, RAW_POINTER, REF,
ROPBRACK, SHARED_POINTER)
class Typename:
"""
Generic type which can be either a basic type or a class type,
similar to C++'s `typename` aka a qualified dependent type.
Contains type name with full namespace and template arguments.
Class which holds a type's name, full namespace, and template arguments.
E.g.
```
@ -89,7 +87,6 @@ class Typename:
def to_cpp(self) -> str:
"""Generate the C++ code for wrapping."""
idx = 1 if self.namespaces and not self.namespaces[0] else 0
if self.instantiations:
cpp_name = self.name + "<{}>".format(", ".join(
[inst.to_cpp() for inst in self.instantiations]))
@ -116,7 +113,7 @@ class BasicType:
"""
Basic types are the fundamental built-in types in C++ such as double, int, char, etc.
When using templates, the basis type will take on the same form as the template.
When using templates, the basic type will take on the same form as the template.
E.g.
```
@ -127,16 +124,16 @@ class BasicType:
will give
```
m_.def("CoolFunctionDoubleDouble",[](const double& s) {
return wrap_example::CoolFunction<double,double>(s);
}, py::arg("s"));
m_.def("funcDouble",[](const double& x){
::func<double>(x);
}, py::arg("x"));
```
"""
rule = (Or(BASIS_TYPES)("typename")).setParseAction(lambda t: BasicType(t))
rule = (Or(BASIC_TYPES)("typename")).setParseAction(lambda t: BasicType(t))
def __init__(self, t: ParseResults):
self.typename = Typename(t.asList())
self.typename = Typename(t)
class CustomType:
@ -160,9 +157,9 @@ class CustomType:
class Type:
"""
Parsed datatype, can be either a fundamental type or a custom datatype.
Parsed datatype, can be either a fundamental/basic type or a custom datatype.
E.g. void, double, size_t, Matrix.
Think of this as a high-level type which encodes the typename and other
Think of this as a high-level type which encodes the typename and other
characteristics of the type.
The type can optionally be a raw pointer, shared pointer or reference.
@ -170,7 +167,7 @@ class Type:
"""
rule = (
Optional(CONST("is_const")) #
+ (BasicType.rule("basis") | CustomType.rule("qualified")) # BR
+ (BasicType.rule("basic") | CustomType.rule("qualified")) # BR
+ Optional(
SHARED_POINTER("is_shared_ptr") | RAW_POINTER("is_ptr")
| REF("is_ref")) #
@ -188,9 +185,10 @@ class Type:
@staticmethod
def from_parse_result(t: ParseResults):
"""Return the resulting Type from parsing the source."""
if t.basis:
# If the type is a basic/fundamental c++ type (e.g int, bool)
if t.basic:
return Type(
typename=t.basis.typename,
typename=t.basic.typename,
is_const=t.is_const,
is_shared_ptr=t.is_shared_ptr,
is_ptr=t.is_ptr,

25
wrap/gtwrap/matlab_wrapper/mixins.py
View File

@ -60,6 +60,31 @@ 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_`."""
if class_:
class_enums = [enum.name for enum in class_.enums]
return arg_type.typename.name in class_enums
else:
return False
def is_global_enum(self, arg_type: parser.Type, class_: parser.Class):
"""Check if arg_type is a global enum."""
if class_:
# Get the enums in the class' namespace
global_enums = [
member.name for member in class_.parent.content
if isinstance(member, parser.Enum)
]
return arg_type.typename.name in global_enums
else:
return False
def is_enum(self, arg_type: parser.Type, class_: parser.Class):
"""Check if `arg_type` is an enum."""
return self.is_class_enum(arg_type, class_) or self.is_global_enum(
arg_type, class_)
class FormatMixin:
"""Mixin to provide formatting utilities."""

2
wrap/gtwrap/matlab_wrapper/templates.py
View File

@ -1,3 +1,5 @@
"""Code generation templates for the Matlab wrapper."""
import textwrap

156
wrap/gtwrap/matlab_wrapper/wrapper.py
View File

@ -341,11 +341,17 @@ 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, 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_enum(arg.ctype, instantiated_class):
enum_type = f"{arg.ctype.typename}"
arg_type = f"{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 +378,10 @@ 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,
instantiated_class=None):
"""Format the interface_parser.Arguments.
Examples:
@ -383,7 +392,8 @@ 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, instantiated_class=instantiated_class)
body_args += textwrap.indent(textwrap.dedent('''\
{arg_type} {name} = {unwrap}
@ -405,7 +415,8 @@ class MatlabWrapper(CheckMixin, FormatMixin):
continue
if not self.is_ref(arg.ctype) and (self.is_shared_ptr(arg.ctype) or \
self.is_ptr(arg.ctype) or self.can_be_pointer(arg.ctype))and \
self.is_ptr(arg.ctype) or self.can_be_pointer(arg.ctype)) and \
not self.is_enum(arg.ctype, instantiated_class) and \
arg.ctype.typename.name not in self.ignore_namespace:
if arg.ctype.is_shared_ptr:
call_type = arg.ctype.is_shared_ptr
@ -535,7 +546,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 +1038,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 +1119,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 as a Matlab class.
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 +1195,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 +1270,30 @@ 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,
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 instantiated_class and \
self.is_enum(ctype, instantiated_class):
if self.is_class_enum(ctype, instantiated_class):
class_name = ".".join(instantiated_class.namespaces()[1:] +
[instantiated_class.name])
else:
# Get the full namespace
class_name = ".".join(instantiated_class.parent.full_namespaces()[1:])
if class_name != "":
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,
@ -1259,13 +1336,14 @@ class MatlabWrapper(CheckMixin, FormatMixin):
return expanded
def wrap_collector_function_return(self, method):
def wrap_collector_function_return(self, method, instantiated_class=None):
"""
Wrap the complete return type of the function.
"""
expanded = ''
params = self._wrapper_unwrap_arguments(method.args, arg_id=1)[0]
params = self._wrapper_unwrap_arguments(
method.args, arg_id=1, instantiated_class=instantiated_class)[0]
return_1 = method.return_type.type1
return_count = self._return_count(method.return_type)
@ -1301,7 +1379,8 @@ class MatlabWrapper(CheckMixin, FormatMixin):
if return_1_name != 'void':
if return_count == 1:
expanded += self._collector_return(obj, return_1)
expanded += self._collector_return(
obj, return_1, instantiated_class=instantiated_class)
elif return_count == 2:
return_2 = method.return_type.type2
@ -1316,13 +1395,17 @@ 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)
return self._collector_return(obj,
class_property.ctype,
instantiated_class=instantiated_class)
def wrap_collector_function_upcast_from_void(self, class_name, func_id,
cpp_name):
@ -1381,7 +1464,7 @@ class MatlabWrapper(CheckMixin, FormatMixin):
elif collector_func[2] == 'constructor':
base = ''
params, body_args = self._wrapper_unwrap_arguments(
extra.args, constructor=True)
extra.args, instantiated_class=collector_func[1])
if collector_func[1].parent_class:
base += textwrap.indent(textwrap.dedent('''
@ -1442,8 +1525,12 @@ class MatlabWrapper(CheckMixin, FormatMixin):
method_name += extra.name
_, body_args = self._wrapper_unwrap_arguments(
extra.args, arg_id=1 if is_method else 0)
return_body = self.wrap_collector_function_return(extra)
extra.args,
arg_id=1 if is_method else 0,
instantiated_class=collector_func[1])
return_body = self.wrap_collector_function_return(
extra, collector_func[1])
shared_obj = ''
@ -1472,7 +1559,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 +1570,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' \
@ -1498,7 +1587,8 @@ class MatlabWrapper(CheckMixin, FormatMixin):
# Setter
if "_set_" in method_name:
is_ptr_type = self.can_be_pointer(extra.ctype)
is_ptr_type = self.can_be_pointer(extra.ctype) and \
not self.is_enum(extra.ctype, collector_func[1])
return_body = ' obj->{0} = {1}{0};'.format(
extra.name, '*' if is_ptr_type else '')

42
wrap/matlab.h
View File

@ -118,10 +118,10 @@ void checkArguments(const string& name, int nargout, int nargin, int expected) {
}
//*****************************************************************************
// wrapping C++ basis types in MATLAB arrays
// wrapping C++ basic types in MATLAB arrays
//*****************************************************************************
// default wrapping throws an error: only basis types are allowed in wrap
// default wrapping throws an error: only basic types are allowed in wrap
template <typename Class>
mxArray* wrap(const Class& value) {
error("wrap internal error: attempted wrap of invalid type");
@ -228,8 +228,26 @@ mxArray* wrap<gtsam::Matrix >(const gtsam::Matrix& A) {
return wrap_Matrix(A);
}
/// @brief Wrap the C++ enum to Matlab mxArray
/// @tparam T The C++ enum type
/// @param x C++ enum
/// @param classname Matlab enum classdef used to call Matlab constructor
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 +258,24 @@ T unwrap(const mxArray* array) {
return T();
}
/// @brief Unwrap from matlab array to C++ enum type
/// @tparam T The C++ enum type
/// @param array Matlab mxArray
template <typename T>
T unwrap_enum(const mxArray* array) {
// Make duplicate to remove const-ness
mxArray* a = mxDuplicateArray(array);
// 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 static_cast<T>(*value);
}
// specialization to string
// expects a character array
// Warning: relies on mxChar==char

6
wrap/tests/expected/matlab/+Pet/Kind.m Normal file
View File

@ -0,0 +1,6 @@
classdef Kind < uint32
enumeration
Dog(0)
Cat(1)
end
end

9
wrap/tests/expected/matlab/+gtsam/+MCU/Avengers.m Normal file
View File

@ -0,0 +1,9 @@
classdef Avengers < uint32
enumeration
CaptainAmerica(0)
IronMan(1)
Hulk(2)
Hawkeye(3)
Thor(4)
end
end

9
wrap/tests/expected/matlab/+gtsam/+MCU/GotG.m Normal file
View File

@ -0,0 +1,9 @@
classdef GotG < uint32
enumeration
Starlord(0)
Gamorra(1)
Rocket(2)
Drax(3)
Groot(4)
end
end

7
wrap/tests/expected/matlab/+gtsam/+OptimizerGaussNewtonParams/Verbosity.m Normal file
View File

@ -0,0 +1,7 @@
classdef Verbosity < uint32
enumeration
SILENT(0)
SUMMARY(1)
VERBOSE(2)
end
end

12
wrap/tests/expected/matlab/+gtsam/VerbosityLM.m Normal file
View File

@ -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

7
wrap/tests/expected/matlab/Color.m Normal file
View File

@ -0,0 +1,7 @@
classdef Color < uint32
enumeration
Red(0)
Green(1)
Blue(2)
end
end

322
wrap/tests/expected/matlab/enum_wrapper.cpp Normal file
View File

@ -0,0 +1,322 @@
#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");
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_getColor_3(int nargout, mxArray *out[], int nargin, const mxArray *in[])
{
checkArguments("getColor",nargout,nargin-1,0);
auto obj = unwrap_shared_ptr<Pet>(in[0], "ptr_Pet");
out[0] = wrap_enum(obj->getColor(),"Color");
}
void Pet_setColor_4(int nargout, mxArray *out[], int nargin, const mxArray *in[])
{
checkArguments("setColor",nargout,nargin-1,1);
auto obj = unwrap_shared_ptr<Pet>(in[0], "ptr_Pet");
Color color = unwrap_enum<Color>(in[1]);
obj->setColor(color);
}
void Pet_get_name_5(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_6(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_7(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_8(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");
Pet::Kind type = unwrap_enum<Pet::Kind>(in[1]);
obj->type = type;
}
void gtsamMCU_collectorInsertAndMakeBase_9(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_10(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_11(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_12(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_constructor_13(int nargout, mxArray *out[], int nargin, const mxArray *in[])
{
mexAtExit(&_deleteAllObjects);
typedef std::shared_ptr<gtsam::Optimizer<gtsam::GaussNewtonParams>> Shared;
Optimizer<gtsam::GaussNewtonParams>::Verbosity verbosity = unwrap_enum<Optimizer<gtsam::GaussNewtonParams>::Verbosity>(in[0]);
Shared *self = new Shared(new gtsam::Optimizer<gtsam::GaussNewtonParams>(verbosity));
collector_gtsamOptimizerGaussNewtonParams.insert(self);
out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
*reinterpret_cast<Shared**> (mxGetData(out[0])) = self;
}
void gtsamOptimizerGaussNewtonParams_deconstructor_14(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_getVerbosity_15(int nargout, mxArray *out[], int nargin, const mxArray *in[])
{
checkArguments("getVerbosity",nargout,nargin-1,0);
auto obj = unwrap_shared_ptr<gtsam::Optimizer<gtsam::GaussNewtonParams>>(in[0], "ptr_gtsamOptimizerGaussNewtonParams");
out[0] = wrap_enum(obj->getVerbosity(),"gtsam.OptimizerGaussNewtonParams.Verbosity");
}
void gtsamOptimizerGaussNewtonParams_getVerbosity_16(int nargout, mxArray *out[], int nargin, const mxArray *in[])
{
checkArguments("getVerbosity",nargout,nargin-1,0);
auto obj = unwrap_shared_ptr<gtsam::Optimizer<gtsam::GaussNewtonParams>>(in[0], "ptr_gtsamOptimizerGaussNewtonParams");
out[0] = wrap_enum(obj->getVerbosity(),"gtsam.VerbosityLM");
}
void gtsamOptimizerGaussNewtonParams_setVerbosity_17(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");
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_getColor_3(nargout, out, nargin-1, in+1);
break;
case 4:
Pet_setColor_4(nargout, out, nargin-1, in+1);
break;
case 5:
Pet_get_name_5(nargout, out, nargin-1, in+1);
break;
case 6:
Pet_set_name_6(nargout, out, nargin-1, in+1);
break;
case 7:
Pet_get_type_7(nargout, out, nargin-1, in+1);
break;
case 8:
Pet_set_type_8(nargout, out, nargin-1, in+1);
break;
case 9:
gtsamMCU_collectorInsertAndMakeBase_9(nargout, out, nargin-1, in+1);
break;
case 10:
gtsamMCU_constructor_10(nargout, out, nargin-1, in+1);
break;
case 11:
gtsamMCU_deconstructor_11(nargout, out, nargin-1, in+1);
break;
case 12:
gtsamOptimizerGaussNewtonParams_collectorInsertAndMakeBase_12(nargout, out, nargin-1, in+1);
break;
case 13:
gtsamOptimizerGaussNewtonParams_constructor_13(nargout, out, nargin-1, in+1);
break;
case 14:
gtsamOptimizerGaussNewtonParams_deconstructor_14(nargout, out, nargin-1, in+1);
break;
case 15:
gtsamOptimizerGaussNewtonParams_getVerbosity_15(nargout, out, nargin-1, in+1);
break;
case 16:
gtsamOptimizerGaussNewtonParams_getVerbosity_16(nargout, out, nargin-1, in+1);
break;
case 17:
gtsamOptimizerGaussNewtonParams_setVerbosity_17(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);
}

6
wrap/tests/expected/matlab/special_cases_wrapper.cpp
View File

@ -204,15 +204,15 @@ 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");
obj->verbosity = *verbosity;
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;
}

9
wrap/tests/expected/python/enum_pybind.cpp
View File

@ -23,7 +23,9 @@ PYBIND11_MODULE(enum_py, m_) {
py::class_<Pet, std::shared_ptr<Pet>> pet(m_, "Pet");
pet
.def(py::init<const string&, Kind>(), py::arg("name"), py::arg("type"))
.def(py::init<const string&, Pet::Kind>(), py::arg("name"), py::arg("type"))
.def("setColor",[](Pet* self, const Color& color){ self->setColor(color);}, py::arg("color"))
.def("getColor",[](Pet* self){return self->getColor();})
.def_readwrite("name", &Pet::name)
.def_readwrite("type", &Pet::type);
@ -65,7 +67,10 @@ PYBIND11_MODULE(enum_py, m_) {
py::class_<gtsam::Optimizer<gtsam::GaussNewtonParams>, std::shared_ptr<gtsam::Optimizer<gtsam::GaussNewtonParams>>> optimizergaussnewtonparams(m_gtsam, "OptimizerGaussNewtonParams");
optimizergaussnewtonparams
.def("setVerbosity",[](gtsam::Optimizer<gtsam::GaussNewtonParams>* self, const Optimizer<gtsam::GaussNewtonParams>::Verbosity value){ self->setVerbosity(value);}, py::arg("value"));
.def(py::init<const Optimizer<gtsam::GaussNewtonParams>::Verbosity&>(), py::arg("verbosity"))
.def("setVerbosity",[](gtsam::Optimizer<gtsam::GaussNewtonParams>* self, const Optimizer<gtsam::GaussNewtonParams>::Verbosity value){ self->setVerbosity(value);}, py::arg("value"))
.def("getVerbosity",[](gtsam::Optimizer<gtsam::GaussNewtonParams>* self){return self->getVerbosity();})
.def("getVerbosity",[](gtsam::Optimizer<gtsam::GaussNewtonParams>* self){return self->getVerbosity();});
py::enum_<gtsam::Optimizer<gtsam::GaussNewtonParams>::Verbosity>(optimizergaussnewtonparams, "Verbosity", py::arithmetic())
.value("SILENT", gtsam::Optimizer<gtsam::GaussNewtonParams>::Verbosity::SILENT)

13
wrap/tests/fixtures/enum.i vendored
View File

@ -3,13 +3,16 @@ enum Color { Red, Green, Blue };
class Pet {
enum Kind { Dog, Cat };
Pet(const string &name, Kind type);
Pet(const string &name, Pet::Kind type);
void setColor(const Color& color);
Color getColor() const;
string name;
Kind type;
Pet::Kind type;
};
namespace gtsam {
// Test global enums
enum VerbosityLM {
SILENT,
SUMMARY,
@ -21,6 +24,7 @@ enum VerbosityLM {
TRYDELTA
};
// Test multiple enums in a classs
class MCU {
MCU();
@ -50,7 +54,12 @@ class Optimizer {
VERBOSE
};
Optimizer(const This::Verbosity& verbosity);
void setVerbosity(const This::Verbosity value);
gtsam::Optimizer::Verbosity getVerbosity() const;
gtsam::VerbosityLM getVerbosity() const;
};
typedef gtsam::Optimizer<gtsam::GaussNewtonParams> OptimizerGaussNewtonParams;

4
wrap/tests/test_interface_parser.py
View File

@ -38,7 +38,7 @@ class TestInterfaceParser(unittest.TestCase):
def test_basic_type(self):
"""Tests for BasicType."""
# Check basis type
# Check basic type
t = Type.rule.parseString("int x")[0]
self.assertEqual("int", t.typename.name)
self.assertTrue(t.is_basic)
@ -243,7 +243,7 @@ class TestInterfaceParser(unittest.TestCase):
self.assertEqual("void", return_type.type1.typename.name)
self.assertTrue(return_type.type1.is_basic)
# Test basis type
# Test basic type
return_type = ReturnType.rule.parseString("size_t")[0]
self.assertEqual("size_t", return_type.type1.typename.name)
self.assertTrue(not return_type.type2)

26
wrap/tests/test_matlab_wrapper.py
View File

@ -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')